From 828d29c1c0f1b7f01e999a578e17652db03bc6f5 Mon Sep 17 00:00:00 2001 From: jaclark5 Date: Tue, 18 Aug 2026 11:55:32 -0400 Subject: [PATCH 01/11] phase 1: basic result class --- openfe_benchmarks/results/__init__.py | 6 + .../results/_benchmark_results.py | 427 ++++++++++++++++++ 2 files changed, 433 insertions(+) create mode 100644 openfe_benchmarks/results/_benchmark_results.py diff --git a/openfe_benchmarks/results/__init__.py b/openfe_benchmarks/results/__init__.py index 8b137891..9c6f16cc 100644 --- a/openfe_benchmarks/results/__init__.py +++ b/openfe_benchmarks/results/__init__.py @@ -1 +1,7 @@ +""" +Results loading and filtering module. +""" +from ._benchmark_results import BenchmarkResults, filter_results + +__all__ = ["BenchmarkResults", "filter_results"] diff --git a/openfe_benchmarks/results/_benchmark_results.py b/openfe_benchmarks/results/_benchmark_results.py new file mode 100644 index 00000000..9d61150e --- /dev/null +++ b/openfe_benchmarks/results/_benchmark_results.py @@ -0,0 +1,427 @@ +""" +Module for loading and filtering computational benchmark results from submission.yaml files. + +The BenchmarkResults class is a data container that loads on initialization. +Filtering functions are separate from the class, following functional programming principles. +""" + +from pathlib import Path +from dataclasses import dataclass +import yaml +import json +import bz2 +import fnmatch +import logging + +from gufe.tokenization import JSON_HANDLER + +# Get logger for this module - will inherit configuration from parent +logger = logging.getLogger(__name__) + +__all__ = [ + "BenchmarkResults", + "filter_results", +] + +_RESULTS_DIR = ( + Path(__file__).resolve().parent.parent.parent / "openfe_benchmarks" / "results" +) + + +@dataclass +class BenchmarkResults: + """ + Represents computational results from a submission.yaml file. + + Initialize with a submission_id to load the results. Use filter_results() + function to filter the raw computational data. + + Attributes + ---------- + submission_id : str + Unique identifier from submission.yaml + title : str + Descriptive title + calculation_type : str + Type of calculation (rbfe, asfe, etc.) + tags : list[str] + List of submission tags + metadata : dict + All metadata from submission.yaml (authors, date, forcefields, etc.) + raw_results : dict | None + Raw computational_results.json loaded as nested dict, or None if load_results=False + results_file : Path + Path to the computational_results.json file + submission_file : Path + Path to the submission.yaml file + + Examples + -------- + >>> # Load results with computational data + >>> results = BenchmarkResults(submission_id='2026-03-18-openmm-840-qa-testing') + >>> + >>> # Fast YAML-only load (for CI validation) + >>> results = BenchmarkResults(submission_id='2026-03-18-openmm-840-qa-testing', load_results=False) + >>> + >>> # Filter the results + >>> rbfe_results = filter_results(results, tags='rbfe') + >>> tyk2_results = filter_results(results, system_name='tyk2') + """ + + submission_id: str + title: str + calculation_type: str + tags: list[str] + metadata: dict + raw_results: dict | None + results_file: Path + submission_file: Path + + def __init__( + self, + submission_id: str, + load_results: bool = True, + results_dir: Path | None = None, + ): + """ + Initialize BenchmarkResults by loading from submission_id. + + Parameters + ---------- + submission_id : str + Unique submission identifier (e.g., '2026-03-18-openmm-840-qa-testing') + load_results : bool, default=True + If True, load computational_results.json. If False, only load YAML metadata + (for fast CI validation). When False, raw_results will be None. + results_dir : Path, optional + Results directory to search. Defaults to openfe_benchmarks/results/ + + Raises + ------ + FileNotFoundError + If submission_id directory or submission.yaml not found + ValueError + If submission.yaml missing required fields or submission_id mismatch + """ + # Auto-discover results directory + if results_dir is None: + results_dir = _RESULTS_DIR + else: + results_dir = Path(results_dir) + + # Construct paths + submission_dir = results_dir / submission_id + submission_file = submission_dir / "submission.yaml" + + # Validate paths exist + if not submission_dir.exists(): + raise FileNotFoundError(f"Submission not found: {submission_id}") + + if not submission_file.exists(): + raise FileNotFoundError(f"submission.yaml not found for: {submission_id}") + + # Load YAML + try: + with open(submission_file, "r") as f: + yaml_data = yaml.safe_load(f) + except Exception as e: + raise ValueError(f"Error reading submission.yaml for {submission_id}: {e}") + + # Validate required fields + required_fields = [ + "submission_id", + "title", + "calculation_type", + "tags", + "results", + ] + missing_fields = [field for field in required_fields if field not in yaml_data] + if missing_fields: + raise ValueError( + f"Invalid submission.yaml: missing required fields: {missing_fields}" + ) + + # Validate submission_id matches + yaml_submission_id = yaml_data["submission_id"] + if yaml_submission_id != submission_id: + raise ValueError( + f"submission_id mismatch: YAML has '{yaml_submission_id}', expected '{submission_id}'" + ) + + # Extract basic fields + self.submission_id = yaml_data["submission_id"] + self.title = yaml_data["title"] + self.calculation_type = yaml_data["calculation_type"] + self.tags = ( + yaml_data["tags"] + if isinstance(yaml_data["tags"], list) + else [yaml_data["tags"]] + ) + self.metadata = yaml_data + + # Construct results file path + results_filename = yaml_data["results"] + self.results_file = submission_dir / results_filename + self.submission_file = submission_file + + # Conditionally load computational results + self.raw_results = None + if load_results: + # Validate results file exists + if not self.results_file.exists(): + raise FileNotFoundError(f"Results file not found: {self.results_file}") + + # Load JSON with bz2 support + open_func = bz2.open if ".bz2" in str(self.results_file) else open + try: + with open_func(self.results_file, "rt") as handle: + self.raw_results = json.load(handle, cls=JSON_HANDLER.decoder) + except Exception as e: + raise ValueError(f"Error loading results file {self.results_file}: {e}") + + logger.debug( + f"Loaded BenchmarkResults: {self.submission_id} (load_results={load_results})" + ) + + def __repr__(self): + """Return string representation.""" + return f"BenchmarkResults(submission_id='{self.submission_id}', title='{self.title}')" + + +# Standalone filtering functions + + +def filter_results( + benchmark_results: BenchmarkResults, tags_mode: str = "all", **filters +) -> list[dict]: + """ + Filter raw computational results by any combination of fields. + + Supports: + - Top-level metadata: tags='rbfe', calculation_type='rbfe' + - Nested fields: protocol_settings__temperature='298.15 K' (use __ for nesting) + - Result fields: system_group='jacs_set', system_name='tyk2' + - Wildcards: system_name='*tyk2*' (uses fnmatch) + - OR logic within field: pass list for ANY match (e.g., system_name=['tyk2', 'thrombin']) + - NOT logic: use exclude_ prefix (e.g., exclude_tags=['deprecated']) + - AND logic between fields: all filter conditions must match + + Parameters + ---------- + benchmark_results : BenchmarkResults + BenchmarkResults instance to filter + tags_mode : {'all', 'any'}, default='all' + When filtering by multiple tags: + - 'all': result must have ALL specified tags (AND logic, default) + - 'any': result must have ANY specified tag (OR logic) + Ignored if tags filter is not provided or is a single value. + **filters : dict + Field=value pairs to filter by. Values can be: + - Single value: exact match (or wildcard if contains * or ?) + - List: matches if ANY value matches (OR logic) - EXCEPT tags which respects tags_mode + - Use exclude_ prefix for NOT logic (e.g., exclude_tags=['test']) + + Returns + ------- + list[dict] + Filtered result dictionaries + + Raises + ------ + ValueError + If raw_results is None (load_results=False was used) + + Examples + -------- + >>> results = BenchmarkResults(submission_id='2026-03-18-openmm-840-qa-testing') + >>> + >>> # Exact match + >>> rbfe_results = filter_results(results, tags='rbfe') + >>> + >>> # Tags AND logic (default): must have ALL tags + >>> validated = filter_results(results, tags=['rbfe', 'openfe', 'validation']) + >>> + >>> # Tags OR logic: must have ANY tag + >>> any_calc = filter_results(results, tags=['rbfe', 'asfe'], tags_mode='any') + >>> + >>> # OR within non-tag fields (list = ANY match) + >>> multi_system = filter_results(results, system_name=['tyk2', 'thrombin']) + >>> + >>> # NOT logic (exclude_ prefix) + >>> no_deprecated = filter_results(results, exclude_tags='deprecated') + >>> no_test = filter_results(results, exclude_tags=['deprecated', 'test'], tags_mode='any') + >>> + >>> # Complex: multiple tags (AND), system OR, exclude + >>> filtered = filter_results( + ... results, + ... tags=['rbfe', 'openfe'], # has BOTH rbfe AND openfe + ... system_name=['tyk2', 'thrombin'], # AND (tyk2 OR thrombin) + ... exclude_tags=['deprecated'] # AND NOT deprecated + ... ) + >>> + >>> # Nested fields and wildcards + >>> lambda11 = filter_results(results, protocol_settings__lambda_windows='11') + >>> tyk2_wildcard = filter_results(results, system_name='*tyk2*') + """ + if benchmark_results.raw_results is None: + raise ValueError( + "Cannot filter results: raw_results is None. " + "Initialize with load_results=True to access computational data." + ) + + # Collect all results (dg + ddg) + all_results = [] + if "dg" in benchmark_results.raw_results: + all_results.extend(benchmark_results.raw_results["dg"]) + if "ddg" in benchmark_results.raw_results: + all_results.extend(benchmark_results.raw_results["ddg"]) + + # Apply filters + filtered = [] + for result in all_results: + # Check all filters (AND logic between different filters) + if all( + _match_filter(result, benchmark_results.metadata, key, value, tags_mode) + for key, value in filters.items() + ): + filtered.append(result) + + return filtered + + +def _match_filter( + result: dict, metadata: dict, filter_key: str, filter_val, tags_mode: str = "all" +) -> bool: + """ + Check if a result matches a filter predicate. + + Parameters + ---------- + result : dict + Result dictionary to check + metadata : dict + Metadata from BenchmarkResults (for fallback field access) + filter_key : str + Filter key (may have exclude_ prefix, may have __ for nested access) + filter_val : any + Filter value (may be single value or list for OR logic) + tags_mode : str + Mode for tags filtering ('all' or 'any') + + Returns + ------- + bool + True if result matches filter, False otherwise + """ + # Handle NOT logic (exclude_ prefix) + negate = False + if filter_key.startswith("exclude_"): + negate = True + filter_key = filter_key[8:] # Remove 'exclude_' prefix + + # Handle nested field access (e.g., protocol_settings__lambda_windows) + if "__" in filter_key: + # Split on __ and traverse nested dict + keys = filter_key.split("__") + value = result + for key in keys: + if isinstance(value, dict): + value = value.get(key, None) + else: + value = None + break + + if value is None: + # Field not found in result + result_matched = False + else: + result_matched = _match_value(value, filter_val, filter_key, tags_mode) + else: + # Direct field access + # First try result dict, then fall back to metadata for top-level fields + if filter_key in result: + value = result[filter_key] + elif filter_key in metadata: + value = metadata[filter_key] + else: + # Field not found + result_matched = False + return not result_matched if negate else result_matched + + result_matched = _match_value(value, filter_val, filter_key, tags_mode) + + # Apply negation if needed + return not result_matched if negate else result_matched + + +def _match_value(result_value, filter_val, filter_key: str, tags_mode: str) -> bool: + """ + Check if a result value matches a filter value. + + Parameters + ---------- + result_value : any + Value from result to check + filter_val : any + Filter value (may be single value or list) + filter_key : str + Filter key (for special handling of 'tags') + tags_mode : str + Mode for tags filtering ('all' or 'any') + + Returns + ------- + bool + True if value matches filter, False otherwise + """ + # Special handling for tags field with list filter_val + if filter_key == "tags" and isinstance(filter_val, list): + # Ensure result_value is a list + result_tags = result_value if isinstance(result_value, list) else [result_value] + + if tags_mode == "all": + # AND logic: result must have ALL filter tags + return all(tag in result_tags for tag in filter_val) + elif tags_mode == "any": + # OR logic: result must have ANY filter tag + return any(tag in result_tags for tag in filter_val) + else: + raise ValueError(f"Invalid tags_mode: {tags_mode}. Must be 'all' or 'any'") + + # OR logic for list filter values (non-tags fields) + if isinstance(filter_val, list): + # Check if ANY filter value matches + return any(_match_single_value(result_value, fv) for fv in filter_val) + else: + # Single value match + return _match_single_value(result_value, filter_val) + + +def _match_single_value(result_value, filter_val) -> bool: + """ + Check if a single result value matches a single filter value. + + Handles wildcards and list-valued result fields. + + Parameters + ---------- + result_value : any + Value from result to check + filter_val : any + Single filter value (not a list) + + Returns + ------- + bool + True if value matches, False otherwise + """ + # Handle list-valued result fields (check if ANY element matches) + if isinstance(result_value, list): + return any(_match_single_value(item, filter_val) for item in result_value) + + # Wildcard matching for strings + if isinstance(filter_val, str) and ("*" in filter_val or "?" in filter_val): + return fnmatch.fnmatch(str(result_value), filter_val) + + # Exact match + return result_value == filter_val From c2def71c11f3c7f7377cc6fb9857c01c20be69e4 Mon Sep 17 00:00:00 2001 From: jaclark5 Date: Tue, 18 Aug 2026 13:34:57 -0400 Subject: [PATCH 02/11] add test --- .../results/_benchmark_results.py | 113 +++++ .../tests/test_benchmark_results.py | 408 ++++++++++++++++++ 2 files changed, 521 insertions(+) create mode 100644 openfe_benchmarks/tests/test_benchmark_results.py diff --git a/openfe_benchmarks/results/_benchmark_results.py b/openfe_benchmarks/results/_benchmark_results.py index 9d61150e..67b0db83 100644 --- a/openfe_benchmarks/results/_benchmark_results.py +++ b/openfe_benchmarks/results/_benchmark_results.py @@ -14,6 +14,7 @@ import logging from gufe.tokenization import JSON_HANDLER +from cinnabar import FEMap # Get logger for this module - will inherit configuration from parent logger = logging.getLogger(__name__) @@ -179,6 +180,10 @@ def __init__( except Exception as e: raise ValueError(f"Error loading results file {self.results_file}: {e}") + # Initialize FEMap caches + self._dg_femaps_cache = None + self._ddg_femaps_cache = None + logger.debug( f"Loaded BenchmarkResults: {self.submission_id} (load_results={load_results})" ) @@ -187,6 +192,114 @@ def __repr__(self): """Return string representation.""" return f"BenchmarkResults(submission_id='{self.submission_id}', title='{self.title}')" + @property + def dg_femaps(self) -> dict[tuple[str, str], FEMap]: + """ + Lazy-loaded FEMaps for absolute (dg) results grouped by system. + + Returns FEMaps with calculated and experimental solvation free energy data. + Results are cached after first access to avoid repeated processing. + + Returns + ------- + dict[tuple[str, str], FEMap] + Dictionary mapping (system_group, system_name) to FEMap objects + + Raises + ------ + ValueError + If raw_results is None (load_results=False was used) or if 'dg' key not found + + Examples + -------- + >>> results = BenchmarkResults(submission_id='2026-08-06-openff-2.3.0-solvation_set_freesolv') + >>> femaps = results.dg_femaps + >>> for (group, name), femap in femaps.items(): + ... print(f"{group}/{name}: {len(femap.edges)} calculations") + """ + if self.raw_results is None: + raise ValueError( + "Cannot access dg_femaps: raw_results is None. " + "Initialize with load_results=True to access computational data." + ) + + if "dg" not in self.raw_results: + raise ValueError( + f"'dg' key not found in raw_results for {self.submission_id}. " + f"Available keys: {list(self.raw_results.keys())}" + ) + + # Return cached value if available + if self._dg_femaps_cache is not None: + return self._dg_femaps_cache + + # Import here to avoid circular dependency + from openfe_benchmarks.scripts._results_utils import ( + build_femap_from_absolute_results, + ) + + # Build FEMaps and cache + logger.warning("Computing FEMaps for dg results - first access may be slow") + self._dg_femaps_cache = build_femap_from_absolute_results( + self.raw_results["dg"] + ) + + return self._dg_femaps_cache + + @property + def ddg_femaps(self) -> dict[tuple[str, str], FEMap]: + """ + Lazy-loaded FEMaps for relative (ddg) results grouped by system. + + Returns FEMaps with calculated and experimental binding free energy data. + Results are cached after first access to avoid repeated processing. + + Returns + ------- + dict[tuple[str, str], FEMap] + Dictionary mapping (system_group, system_name) to FEMap objects + + Raises + ------ + ValueError + If raw_results is None (load_results=False was used) or if 'ddg' key not found + + Examples + -------- + >>> results = BenchmarkResults(submission_id='2026-03-18-openmm-840-qa-testing') + >>> femaps = results.ddg_femaps + >>> for (group, name), femap in femaps.items(): + ... print(f"{group}/{name}: {len(femap.edges)} edges") + """ + if self.raw_results is None: + raise ValueError( + "Cannot access ddg_femaps: raw_results is None. " + "Initialize with load_results=True to access computational data." + ) + + if "ddg" not in self.raw_results: + raise ValueError( + f"'ddg' key not found in raw_results for {self.submission_id}. " + f"Available keys: {list(self.raw_results.keys())}" + ) + + # Return cached value if available + if self._ddg_femaps_cache is not None: + return self._ddg_femaps_cache + + # Import here to avoid circular dependency + from openfe_benchmarks.scripts._results_utils import ( + build_femap_from_relative_results, + ) + + # Build FEMaps and cache + logger.warning("Computing FEMaps for ddg results - first access may be slow") + self._ddg_femaps_cache = build_femap_from_relative_results( + self.raw_results["ddg"] + ) + + return self._ddg_femaps_cache + # Standalone filtering functions diff --git a/openfe_benchmarks/tests/test_benchmark_results.py b/openfe_benchmarks/tests/test_benchmark_results.py new file mode 100644 index 00000000..711665b1 --- /dev/null +++ b/openfe_benchmarks/tests/test_benchmark_results.py @@ -0,0 +1,408 @@ +""" +Tests for the BenchmarkResults class and filtering functionality. + +Tests cover: +- Loading (full and fast YAML-only) +- Raw results structure validation +- Filtering (tags, systems, nested fields, wildcards, OR/NOT/AND logic) +- Lazy FEMap generation (dg and ddg) +- Error handling (missing files, invalid YAML, etc.) +""" + +import pytest +import yaml +import time + +from cinnabar import FEMap + +from openfe_benchmarks.results import BenchmarkResults, filter_results + + +# Test data submission IDs +RBFE_SUBMISSION = "2026-03-18-openmm-840-qa-testing" +ASFE_SUBMISSION = "2026-08-06-openff-2.3.0-solvation_set_freesolv" + + +# ========== Loading Tests ========== + + +def test_load_by_submission_id(): + """Test loading by submission_id with full data loading.""" + result = BenchmarkResults(RBFE_SUBMISSION) + + # Verify attributes + assert result.submission_id == RBFE_SUBMISSION + assert isinstance(result.title, str) + assert result.calculation_type == "rbfe" + assert isinstance(result.tags, list) + assert "rbfe" in result.tags + assert isinstance(result.metadata, dict) + assert result.raw_results is not None + assert isinstance(result.raw_results, dict) + assert result.results_file.exists() + assert result.submission_file.exists() + + +def test_load_yaml_only_fast(): + """Test fast YAML-only loading (load_results=False).""" + start = time.time() + result = BenchmarkResults(RBFE_SUBMISSION, load_results=False) + elapsed = time.time() - start + + # Verify YAML metadata loaded + assert result.submission_id == RBFE_SUBMISSION + assert isinstance(result.title, str) + assert result.calculation_type == "rbfe" + assert isinstance(result.tags, list) + + # Verify raw_results is None + assert result.raw_results is None + + # Verify fast loading (<1s) + assert elapsed < 1.0, f"Fast load too slow: {elapsed:.3f}s (should be <1s)" + + +# ========== Raw Results Structure Tests ========== + + +def test_raw_results_structure(): + """Test that raw_results has expected structure with dg/ddg keys.""" + result = BenchmarkResults(RBFE_SUBMISSION) + + # Verify keys + assert "dg" in result.raw_results or "ddg" in result.raw_results + + # Verify structure + if "dg" in result.raw_results: + assert isinstance(result.raw_results["dg"], list) + assert len(result.raw_results["dg"]) >= 0 + + if "ddg" in result.raw_results: + assert isinstance(result.raw_results["ddg"], list) + assert len(result.raw_results["ddg"]) > 0 # RBFE should have ddg results + + # Verify result structure (first result should have system info) + first_result = result.raw_results["ddg"][0] + assert isinstance(first_result, dict) + assert "system_group" in first_result or "system_name" in first_result + + +# ========== Filter Tests ========== + + +def test_filter_by_tags(): + """Test filtering by exact tag match.""" + result = BenchmarkResults(RBFE_SUBMISSION) + filtered = filter_results(result, tags="rbfe") + + assert len(filtered) > 0 + # All results should have the tag (check metadata since tags is top-level) + assert "rbfe" in result.tags + + +def test_filter_by_multiple_tags_and(): + """Test filtering by multiple tags with AND logic (default).""" + result = BenchmarkResults(RBFE_SUBMISSION) + + # Use tags that should exist in the submission + filtered = filter_results(result, tags=["rbfe", "jacs_set"]) + + # Verify it returns a list + assert isinstance(filtered, list) + + # Verify tags exist in submission metadata (tags are top-level, not per-result) + assert "rbfe" in result.tags + assert "jacs_set" in result.tags + + +def test_filter_by_multiple_tags_or(): + """Test filtering by multiple tags with OR logic.""" + result = BenchmarkResults(RBFE_SUBMISSION) + + # Use tags_mode='any' for OR logic + filtered = filter_results(result, tags=["rbfe", "asfe"], tags_mode="any") + + # Should return results since 'rbfe' tag exists + assert len(filtered) > 0 + assert isinstance(filtered, list) + + +def test_filter_by_system(): + """Test filtering by system_group and system_name.""" + result = BenchmarkResults(RBFE_SUBMISSION) + filtered = filter_results(result, system_group="jacs_set", system_name="tyk2") + + assert len(filtered) > 0 + # Verify all results match + for r in filtered: + assert r["system_group"] == "jacs_set" + assert r["system_name"] == "tyk2" + + +def test_filter_by_nested_field(): + """Test filtering by nested field using __ syntax.""" + result = BenchmarkResults(RBFE_SUBMISSION) + + # Note: Current test data doesn't have nested dicts within individual results. + # Nested field filtering (using __) works for result-level nested fields, + # but test data only has flat result dicts. + # This test verifies the mechanism doesn't crash with __ syntax. + + # Test that nested field syntax doesn't crash + # Using a hypothetical nested field that doesn't exist + filtered = filter_results(result, hypothetical__nested__field="value") + + # Should return empty list (field doesn't exist) + assert isinstance(filtered, list) + assert len(filtered) == 0 + + # Verify regular filtering still works + filtered_normal = filter_results(result, system_group="jacs_set") + assert len(filtered_normal) > 0 + + +def test_filter_with_wildcard(): + """Test filtering with wildcard pattern matching.""" + result = BenchmarkResults(RBFE_SUBMISSION) + filtered = filter_results(result, system_name="*tyk2*") + + assert len(filtered) > 0 + # Verify all results match wildcard (case-sensitive by fnmatch) + for r in filtered: + assert "tyk2" in r["system_name"] + + +def test_filter_or_logic(): + """Test OR logic within a field using list values.""" + result = BenchmarkResults(RBFE_SUBMISSION) + filtered = filter_results(result, system_name=["tyk2", "p38"]) + + assert len(filtered) > 0 + # Verify all results match one of the values + for r in filtered: + assert r["system_name"] in ["tyk2", "p38"] + + +def test_filter_not_logic(): + """Test NOT logic using exclude_ prefix.""" + result = BenchmarkResults(RBFE_SUBMISSION) + + # Test 1: Filter for jacs_set but exclude tyk2 system + filtered = filter_results( + result, system_group="jacs_set", exclude_system_name="tyk2" + ) + + assert len(filtered) > 0 + # Verify no tyk2 results + for r in filtered: + assert r["system_group"] == "jacs_set" + assert r["system_name"] != "tyk2" + + # Test 2: Exclude by tags (as specified in plan) + # Note: This tests the mechanism even if 'deprecated' tag doesn't exist + # The filter should return all results (no exclusion) if tag doesn't exist + filtered_tags = filter_results(result, exclude_tags="deprecated") + assert isinstance(filtered_tags, list) + + +def test_filter_complex_logic(): + """Test complex filtering combining tags AND + system OR + exclude.""" + result = BenchmarkResults(RBFE_SUBMISSION) + + # Complex filter: tags AND + system OR + exclude (as per plan) + filtered = filter_results( + result, + tags=["rbfe", "jacs_set"], + system_name=["tyk2", "p38"], + exclude_tags="deprecated", + ) + + # Verify it returns a list + assert isinstance(filtered, list) + + # Verify tags exist in metadata (tags are top-level) + assert "rbfe" in result.tags + assert "jacs_set" in result.tags + + # Verify system_name matches one of the specified values (if results exist) + if len(filtered) > 0: + for r in filtered: + assert r["system_name"] in ["tyk2", "p38"] + + +def test_filter_multi_and_logic(): + """Test multiple predicates with AND logic between fields.""" + result = BenchmarkResults(RBFE_SUBMISSION) + filtered = filter_results(result, system_group="jacs_set", calculation_type="rbfe") + + # Should return results matching both predicates + assert len(filtered) > 0 + for r in filtered: + assert r["system_group"] == "jacs_set" + + # Verify calculation_type in metadata (it's a top-level field) + assert result.calculation_type == "rbfe" + + +# ========== FEMap Tests ========== + + +def test_ddg_femaps_lazy_load(): + """Test ddg_femaps property with lazy loading and caching.""" + result = BenchmarkResults(RBFE_SUBMISSION) + + # First access - should compute + femaps_first = result.ddg_femaps + + # Verify structure + assert isinstance(femaps_first, dict) + assert len(femaps_first) > 0 + + # Verify keys are tuples + for key in femaps_first.keys(): + assert isinstance(key, tuple) + assert len(key) == 2 + + # Verify values are FEMaps + for femap in femaps_first.values(): + assert isinstance(femap, FEMap) + + # Second access - should return cached + femaps_second = result.ddg_femaps + assert femaps_second is femaps_first # Identity check for caching + + +def test_dg_femaps(): + """Test dg_femaps property with ASFE results.""" + result = BenchmarkResults(ASFE_SUBMISSION) + + # Access dg_femaps + femaps = result.dg_femaps + + # Verify structure + assert isinstance(femaps, dict) + assert len(femaps) > 0 + + # Verify keys are tuples + for key in femaps.keys(): + assert isinstance(key, tuple) + assert len(key) == 2 + + # Verify values are FEMaps + for femap in femaps.values(): + assert isinstance(femap, FEMap) + + +# ========== Error Handling Tests ========== + + +def test_missing_submission_id(): + """Test error when submission_id does not exist.""" + submission_id = "nonexistent-submission" + with pytest.raises(FileNotFoundError) as excinfo: + BenchmarkResults(submission_id) + + assert str(excinfo.value) == f"Submission not found: {submission_id}" + + +def test_missing_results_file(tmp_path): + """Test error when results file referenced in YAML does not exist.""" + # Create a mock submission directory with YAML but no results file + submission_id = "test-missing-results" + submission_dir = tmp_path / submission_id + submission_dir.mkdir() + + yaml_data = { + "submission_id": submission_id, + "title": "Test Missing Results", + "calculation_type": "rbfe", + "tags": ["test"], + "results": "nonexistent_results.json", + } + + yaml_file = submission_dir / "submission.yaml" + with open(yaml_file, "w") as f: + yaml.dump(yaml_data, f) + + # Try to load with load_results=True + with pytest.raises(FileNotFoundError) as excinfo: + BenchmarkResults(submission_id, load_results=True, results_dir=tmp_path) + + assert "Results file not found" in str(excinfo.value) + + +def test_invalid_submission_yaml(tmp_path): + """Test error when submission.yaml is missing required fields.""" + # Create a mock submission directory with incomplete YAML + submission_id = "test-invalid-yaml" + submission_dir = tmp_path / submission_id + submission_dir.mkdir() + + # Missing 'title' and 'calculation_type' fields + yaml_data = { + "submission_id": submission_id, + "tags": ["test"], + } + + yaml_file = submission_dir / "submission.yaml" + with open(yaml_file, "w") as f: + yaml.dump(yaml_data, f) + + with pytest.raises(ValueError) as excinfo: + BenchmarkResults(submission_id, results_dir=tmp_path, load_results=False) + + assert "missing required fields" in str(excinfo.value) + + +def test_submission_id_mismatch(tmp_path): + """Test error when submission_id in YAML doesn't match directory name.""" + # Create a mock submission directory + submission_id = "test-mismatch" + submission_dir = tmp_path / submission_id + submission_dir.mkdir() + + # YAML has different submission_id + yaml_data = { + "submission_id": "different-id", + "title": "Test Mismatch", + "calculation_type": "rbfe", + "tags": ["test"], + "results": "results.json", + } + + yaml_file = submission_dir / "submission.yaml" + with open(yaml_file, "w") as f: + yaml.dump(yaml_data, f) + + with pytest.raises(ValueError) as excinfo: + BenchmarkResults(submission_id, results_dir=tmp_path, load_results=False) + + assert "submission_id mismatch" in str(excinfo.value) + + +def test_filter_on_fast_loaded_results(): + """Test that filtering raises error when raw_results is None.""" + result = BenchmarkResults(RBFE_SUBMISSION, load_results=False) + + with pytest.raises(ValueError) as excinfo: + filter_results(result, tags="rbfe") + + expected_msg = ( + "Cannot filter results: raw_results is None. " + "Initialize with load_results=True to access computational data." + ) + assert str(excinfo.value) == expected_msg + + +def test_femaps_on_fast_loaded_results(): + """Test that accessing FEMaps raises error when raw_results is None.""" + result = BenchmarkResults(RBFE_SUBMISSION, load_results=False) + + with pytest.raises(ValueError) as excinfo: + _ = result.ddg_femaps + + expected_msg = ( + "Cannot access ddg_femaps: raw_results is None. " + "Initialize with load_results=True to access computational data." + ) + assert str(excinfo.value) == expected_msg From e99664c4ad16a849efde9cddb9b247976d9e4bd4 Mon Sep 17 00:00:00 2001 From: jaclark5 Date: Tue, 18 Aug 2026 14:47:38 -0400 Subject: [PATCH 03/11] Update dir names --- .../computational_results.json | 0 .../submission.yaml | 0 .../computational_results.json.bz2 | Bin .../submission.yaml | 0 .../computational_results.json.bz2 | Bin .../submission.yaml | 0 .../computational_results.json.bz2 | Bin .../submission.yaml | 0 8 files changed, 0 insertions(+), 0 deletions(-) rename openfe_benchmarks/results/{2026-02-12_sage_230_jacs => 2026-02-12_sage_230_jacs_set}/computational_results.json (100%) rename openfe_benchmarks/results/{2026-02-12_sage_230_jacs => 2026-02-12_sage_230_jacs_set}/submission.yaml (100%) rename openfe_benchmarks/results/{2026-08_04-openff3.0.0-alpha1b_opc3-jacs => 2026-08-04-openff3.0.0-alpha1b_opc3-jacs}/computational_results.json.bz2 (100%) rename openfe_benchmarks/results/{2026-08_04-openff3.0.0-alpha1b_opc3-jacs => 2026-08-04-openff3.0.0-alpha1b_opc3-jacs}/submission.yaml (100%) rename openfe_benchmarks/results/{2026-08_05-openff3.0.0-alpha1b_tip3p-jacs => 2026-08-05-openff3.0.0-alpha1b_tip3p-jacs}/computational_results.json.bz2 (100%) rename openfe_benchmarks/results/{2026-08_05-openff3.0.0-alpha1b_tip3p-jacs => 2026-08-05-openff3.0.0-alpha1b_tip3p-jacs}/submission.yaml (100%) rename openfe_benchmarks/results/{2026-08_05-openff3.0.0-alpha0_opc3-jacs => 2026_08_05_openff-3.0.0-alpha0_opc3_jacs}/computational_results.json.bz2 (100%) rename openfe_benchmarks/results/{2026-08_05-openff3.0.0-alpha0_opc3-jacs => 2026_08_05_openff-3.0.0-alpha0_opc3_jacs}/submission.yaml (100%) diff --git a/openfe_benchmarks/results/2026-02-12_sage_230_jacs/computational_results.json b/openfe_benchmarks/results/2026-02-12_sage_230_jacs_set/computational_results.json similarity index 100% rename from openfe_benchmarks/results/2026-02-12_sage_230_jacs/computational_results.json rename to openfe_benchmarks/results/2026-02-12_sage_230_jacs_set/computational_results.json diff --git a/openfe_benchmarks/results/2026-02-12_sage_230_jacs/submission.yaml b/openfe_benchmarks/results/2026-02-12_sage_230_jacs_set/submission.yaml similarity index 100% rename from openfe_benchmarks/results/2026-02-12_sage_230_jacs/submission.yaml rename to openfe_benchmarks/results/2026-02-12_sage_230_jacs_set/submission.yaml diff --git a/openfe_benchmarks/results/2026-08_04-openff3.0.0-alpha1b_opc3-jacs/computational_results.json.bz2 b/openfe_benchmarks/results/2026-08-04-openff3.0.0-alpha1b_opc3-jacs/computational_results.json.bz2 similarity index 100% rename from openfe_benchmarks/results/2026-08_04-openff3.0.0-alpha1b_opc3-jacs/computational_results.json.bz2 rename to openfe_benchmarks/results/2026-08-04-openff3.0.0-alpha1b_opc3-jacs/computational_results.json.bz2 diff --git a/openfe_benchmarks/results/2026-08_04-openff3.0.0-alpha1b_opc3-jacs/submission.yaml b/openfe_benchmarks/results/2026-08-04-openff3.0.0-alpha1b_opc3-jacs/submission.yaml similarity index 100% rename from openfe_benchmarks/results/2026-08_04-openff3.0.0-alpha1b_opc3-jacs/submission.yaml rename to openfe_benchmarks/results/2026-08-04-openff3.0.0-alpha1b_opc3-jacs/submission.yaml diff --git a/openfe_benchmarks/results/2026-08_05-openff3.0.0-alpha1b_tip3p-jacs/computational_results.json.bz2 b/openfe_benchmarks/results/2026-08-05-openff3.0.0-alpha1b_tip3p-jacs/computational_results.json.bz2 similarity index 100% rename from openfe_benchmarks/results/2026-08_05-openff3.0.0-alpha1b_tip3p-jacs/computational_results.json.bz2 rename to openfe_benchmarks/results/2026-08-05-openff3.0.0-alpha1b_tip3p-jacs/computational_results.json.bz2 diff --git a/openfe_benchmarks/results/2026-08_05-openff3.0.0-alpha1b_tip3p-jacs/submission.yaml b/openfe_benchmarks/results/2026-08-05-openff3.0.0-alpha1b_tip3p-jacs/submission.yaml similarity index 100% rename from openfe_benchmarks/results/2026-08_05-openff3.0.0-alpha1b_tip3p-jacs/submission.yaml rename to openfe_benchmarks/results/2026-08-05-openff3.0.0-alpha1b_tip3p-jacs/submission.yaml diff --git a/openfe_benchmarks/results/2026-08_05-openff3.0.0-alpha0_opc3-jacs/computational_results.json.bz2 b/openfe_benchmarks/results/2026_08_05_openff-3.0.0-alpha0_opc3_jacs/computational_results.json.bz2 similarity index 100% rename from openfe_benchmarks/results/2026-08_05-openff3.0.0-alpha0_opc3-jacs/computational_results.json.bz2 rename to openfe_benchmarks/results/2026_08_05_openff-3.0.0-alpha0_opc3_jacs/computational_results.json.bz2 diff --git a/openfe_benchmarks/results/2026-08_05-openff3.0.0-alpha0_opc3-jacs/submission.yaml b/openfe_benchmarks/results/2026_08_05_openff-3.0.0-alpha0_opc3_jacs/submission.yaml similarity index 100% rename from openfe_benchmarks/results/2026-08_05-openff3.0.0-alpha0_opc3-jacs/submission.yaml rename to openfe_benchmarks/results/2026_08_05_openff-3.0.0-alpha0_opc3_jacs/submission.yaml From 2ad580dc5f87067fb145dbae3ac98088a376e7b9 Mon Sep 17 00:00:00 2001 From: jaclark5 Date: Tue, 18 Aug 2026 19:51:24 -0400 Subject: [PATCH 04/11] Finish PR --- examples/4_benchmark_result_plot.ipynb | 673 ++++++++++++++ openfe_benchmarks/results/__init__.py | 4 +- .../results/_benchmark_results.py | 826 ++++++++++++++---- openfe_benchmarks/results/_validation.py | 251 ++++++ .../scripts/_example_plot_rbfe.py | 68 +- .../scripts/_no_test_example_plot_asfe.py | 68 +- openfe_benchmarks/scripts/_results_utils.py | 110 ++- .../tests/test_benchmark_results.py | 518 +++++++++-- .../tests/test_results_validation.py | 508 +++++++++++ 9 files changed, 2673 insertions(+), 353 deletions(-) create mode 100644 examples/4_benchmark_result_plot.ipynb create mode 100644 openfe_benchmarks/results/_validation.py create mode 100644 openfe_benchmarks/tests/test_results_validation.py diff --git a/examples/4_benchmark_result_plot.ipynb b/examples/4_benchmark_result_plot.ipynb new file mode 100644 index 00000000..dc383f6f --- /dev/null +++ b/examples/4_benchmark_result_plot.ipynb @@ -0,0 +1,673 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6444fc8c", + "metadata": {}, + "source": [ + "# BenchmarkResults: Loading, Filtering, and Plotting Results\n", + "\n", + "This notebook demonstrates the `BenchmarkResults` class for loading and filtering computational free energy results.\n", + "\n", + "Key features:\n", + "- Load results with `get_benchmark_results()`\n", + "- Filter by tags, systems, and metadata\n", + "- Use comparison operators with pint Quantities (e.g., `dg='>1.0 kilocalories_per_mole'`)\n", + "- Generate FEMaps with lazy `.dg_femaps` and `.ddg_femaps` properties\n", + "- Plot predicted vs experimental values with cinnabar" + ] + }, + { + "cell_type": "markdown", + "id": "18e21df2", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5208611b", + "metadata": {}, + "outputs": [], + "source": [ + "from openfe_benchmarks.results import get_benchmark_results, filter_results\n", + "from cinnabar import plotting\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "850481d7", + "metadata": {}, + "source": [ + "## Load a Submission\n", + "\n", + "We'll load an RBFE submission using the `get_benchmark_results()` factory function." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "330933e1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BenchmarkResults(submission_id='2026-03-18-openmm-840-qa-testing', calculation_type='rbfe')\n" + ] + } + ], + "source": [ + "# Load results\n", + "results = get_benchmark_results(\"2026-03-18-openmm-840-qa-testing\")\n", + "print(results)" + ] + }, + { + "cell_type": "markdown", + "id": "24ae15e8", + "metadata": {}, + "source": [ + "## Explore Metadata" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c7f91ae8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Submission ID: 2026-03-18-openmm-840-qa-testing\n", + "Title: OpenFE RBFE - Multi-set Benchmark (2 sets, 5 systems) - 2026-03-18-openmm-840-qa-testing\n", + "Calculation Type: rbfe\n", + "Tags: rbfe, ff14SB, phosaa10, tip3p_HFE_multivalent, tip3p_standard, charge_annihilation_set, egfr, irak4_s2, irak4_s3, jacs_set, p38, tyk2, nagl_openff-gnn-am1bcc-1.0.0.pt, charge_change, benchmark, openfe, openmm-840\n", + "Date: 2026-06-19\n", + "OpenFE Version: 1.9.1\n", + "Force field: ['ff14SB', 'phosaa10', 'tip3p_HFE_multivalent', 'tip3p_standard']\n" + ] + } + ], + "source": [ + "print(f\"Submission ID: {results.submission_id}\")\n", + "print(f\"Title: {results.title}\")\n", + "print(f\"Calculation Type: {results.calculation_type}\")\n", + "print(f\"Tags: {', '.join(results.tags)}\")\n", + "print(f\"Date: {results.date}\")\n", + "print(f\"OpenFE Version: {results.openfe_version}\")\n", + "print(f\"Force field: {results.forcefield}\")" + ] + }, + { + "cell_type": "markdown", + "id": "508165b5", + "metadata": {}, + "source": [ + "## Raw Results Structure\n", + "\n", + "The `raw_results` attribute contains the computational data as nested dictionaries." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d04552fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Raw results keys: ['dg', 'ddg']\n", + "\n", + "Number of dg results: 56\n", + "Number of ddg results: 80\n", + "\n", + "Sample ddg result keys: ['ligand_a', 'ligand_b', 'system_group', 'system_name', 'ddg', 'ddg_uncertainty', 'dgs_complex', 'dgs_solvent', 'complex_smallest_mbar_overlaps', 'complex_smallest_replica_mixing', 'solvent_smallest_mbar_overlaps', 'solvent_smallest_replica_mixing']\n", + "System: jacs_set/tyk2\n", + "Ligand pair: None -> None\n", + "DDG: -0.31190011815882457 kilocalories_per_mole\n" + ] + } + ], + "source": [ + "print(f\"Raw results keys: {list(results.raw_results.keys())}\")\n", + "print(f\"\\nNumber of dg results: {len(results.raw_results.get('dg', []))}\")\n", + "print(f\"Number of ddg results: {len(results.raw_results.get('ddg', []))}\")\n", + "\n", + "# Show structure of one ddg result\n", + "if \"ddg\" in results.raw_results and results.raw_results[\"ddg\"]:\n", + " sample_result = results.raw_results[\"ddg\"][0]\n", + " print(f\"\\nSample ddg result keys: {list(sample_result.keys())}\")\n", + " print(\n", + " f\"System: {sample_result.get('system_group')}/{sample_result.get('system_name')}\"\n", + " )\n", + " print(\n", + " f\"Ligand pair: {sample_result.get('ligand_i_name')} -> {sample_result.get('ligand_j_name')}\"\n", + " )\n", + " print(f\"DDG: {sample_result.get('ddg')}\")" + ] + }, + { + "cell_type": "markdown", + "id": "4aa17fa8", + "metadata": {}, + "source": [ + "## Filtering Examples\n", + "\n", + "The `filter_results()` function supports various filtering operations." + ] + }, + { + "cell_type": "markdown", + "id": "01065142", + "metadata": {}, + "source": [ + "### Filter by Tag (Single)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "12ac31bc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results with 'rbfe' tag: 136\n" + ] + } + ], + "source": [ + "rbfe_results = filter_results(results, tags=\"rbfe\")\n", + "print(f\"Results with 'rbfe' tag: {len(rbfe_results)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b5c8c46e", + "metadata": {}, + "source": [ + "### Filter by Multiple Tags (AND logic, default)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7bc5fe2f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results with BOTH 'rbfe' AND 'openfe' tags: 136\n" + ] + } + ], + "source": [ + "# Must have ALL specified tags\n", + "validated_results = filter_results(results, tags=[\"rbfe\", \"openfe\"])\n", + "print(f\"Results with BOTH 'rbfe' AND 'openfe' tags: {len(validated_results)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "343f87bc", + "metadata": {}, + "source": [ + "### Filter by Multiple Tags (OR logic)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4687cb56", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results with 'rbfe' OR 'asfe' tag: 136\n" + ] + } + ], + "source": [ + "# Must have ANY of the specified tags\n", + "any_calc_results = filter_results(results, tags=[\"rbfe\", \"asfe\"], tags_mode=\"any\")\n", + "print(f\"Results with 'rbfe' OR 'asfe' tag: {len(any_calc_results)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "4a52b7ec", + "metadata": {}, + "source": [ + "### Filter by System Group" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9177a58f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results from jacs_set: 123\n" + ] + } + ], + "source": [ + "jacs_results = filter_results(results, system_group=\"jacs_set\")\n", + "print(f\"Results from jacs_set: {len(jacs_results)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "7a9dcb4f", + "metadata": {}, + "source": [ + "### Filter with Wildcard" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3430e389", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results with 'tyk2' in system name: 38\n" + ] + } + ], + "source": [ + "tyk2_results = filter_results(results, system_name=\"*tyk2*\")\n", + "print(f\"Results with 'tyk2' in system name: {len(tyk2_results)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "013ad50c", + "metadata": {}, + "source": [ + "### Filter with OR Logic (List Values for Non-Tags)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c4d0da8f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results from tyk2 OR thrombin: 38\n" + ] + } + ], + "source": [ + "# Match if system_name is tyk2 OR thrombin\n", + "multi_system = filter_results(results, system_name=[\"tyk2\", \"thrombin\"])\n", + "print(f\"Results from tyk2 OR thrombin: {len(multi_system)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "94184e5f", + "metadata": {}, + "source": [ + "### Filter with NOT Logic (exclude_ prefix)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8515b4a9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results without 'deprecated' tag: 136\n" + ] + } + ], + "source": [ + "# Exclude results with 'deprecated' tag\n", + "no_deprecated = filter_results(results, exclude_tags=\"deprecated\")\n", + "print(f\"Results without 'deprecated' tag: {len(no_deprecated)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "a63e218a", + "metadata": {}, + "source": [ + "### Complex Filter: Combine Multiple Conditions" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1d540767", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Complex filtered results: 38\n" + ] + } + ], + "source": [ + "# Combine tags AND + system OR + exclude\n", + "complex_filtered = filter_results(\n", + " results,\n", + " tags=[\"rbfe\", \"openfe\"], # has BOTH rbfe AND openfe\n", + " system_name=[\"tyk2\", \"thrombin\"], # AND (tyk2 OR thrombin)\n", + " exclude_tags=[\"test\"], # AND NOT test\n", + ")\n", + "print(f\"Complex filtered results: {len(complex_filtered)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b5bc1b9b", + "metadata": {}, + "source": [ + "### Filter by Nested Protocol Settings" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "893abdbb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results with lambda_windows='11': 0\n" + ] + } + ], + "source": [ + "# Use double underscore (__) for nested field access\n", + "# Note: This example may not match anything depending on the submission structure\n", + "nested_results = filter_results(results, protocol_settings__lambda_windows=\"11\")\n", + "print(f\"Results with lambda_windows='11': {len(nested_results)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5b1bc26d", + "metadata": {}, + "source": [ + "## Comparison Operators with Pint Quantities\n", + "\n", + "The new pint Quantity comparison feature allows filtering by magnitude with automatic unit conversion.\n", + "\n", + "**Note**: Direct comparison operators in `filter_results()` are demonstrated here for documentation purposes. The implementation handles unit conversion automatically when comparing pint Quantity objects." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c7a677ad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Results with |ddg| > 1.0 kcal/mol: 36\n", + "Total ddg results: 80\n", + "\n", + "Example high-magnitude results:\n", + " None -> None: 1.102046405017669 kilocalories_per_mole\n", + " None -> None: -1.6725148955864118 kilocalories_per_mole\n", + " None -> None: 2.3959460144061424 kilocalories_per_mole\n" + ] + } + ], + "source": [ + "# Example: Filter for high magnitude results\n", + "# In practice, you would filter the raw dg/ddg values directly\n", + "if \"ddg\" in results.raw_results:\n", + " ddg_results = results.raw_results[\"ddg\"]\n", + "\n", + " # Manual filtering showing pint Quantity comparison\n", + " # The comparison automatically handles unit conversion\n", + " high_magnitude = [\n", + " r\n", + " for r in ddg_results\n", + " if abs(r.get(\"ddg\", 0).magnitude) > 1.0 # magnitude in kilocalories_per_mole\n", + " ]\n", + "\n", + " print(f\"\\nResults with |ddg| > 1.0 kcal/mol: {len(high_magnitude)}\")\n", + " print(f\"Total ddg results: {len(ddg_results)}\")\n", + "\n", + " # Show a few examples\n", + " if high_magnitude:\n", + " print(\"\\nExample high-magnitude results:\")\n", + " for r in high_magnitude[:3]:\n", + " print(\n", + " f\" {r.get('ligand_i_name')} -> {r.get('ligand_j_name')}: {r.get('ddg')}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "16d91d93", + "metadata": {}, + "source": [ + "## FEMap Generation\n", + "\n", + "FEMaps are generated lazily using the `.ddg_femaps` and `.dg_femaps` properties." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "cd643fea", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-08-18 19:46:00 - openfe_benchmarks.results._benchmark_results - INFO - Computing FEMaps for ddg results - first access may be slow\n", + "2026-08-18 19:46:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'tyk2' from benchmark set 'jacs_set' with:\n", + " 5 ligand file(s), and 0 cofactor file(s).\n", + " Found protein file: True.\n", + " Found 1 ligand network files with keys: industry_benchmarks_network\n", + "2026-08-18 19:46:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'p38' from benchmark set 'jacs_set' with:\n", + " 5 ligand file(s), and 0 cofactor file(s).\n", + " Found protein file: True.\n", + " Found 1 ligand network files with keys: industry_benchmarks_network\n", + "2026-08-18 19:46:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'irak4_s2' from benchmark set 'charge_annihilation_set' with:\n", + " 5 ligand file(s), and 0 cofactor file(s).\n", + " Found protein file: True.\n", + " Found 1 ligand network files with keys: industry_benchmarks_network\n", + "2026-08-18 19:46:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'irak4_s3' from benchmark set 'charge_annihilation_set' with:\n", + " 5 ligand file(s), and 0 cofactor file(s).\n", + " Found protein file: True.\n", + " Found 1 ligand network files with keys: industry_benchmarks_network\n", + "2026-08-18 19:46:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'egfr' from benchmark set 'charge_annihilation_set' with:\n", + " 5 ligand file(s), and 0 cofactor file(s).\n", + " Found protein file: True.\n", + " Found 1 ligand network files with keys: industry_benchmarks_network\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generating FEMaps...\n", + "\n", + "Generated 5 FEMaps:\n", + " - jacs_set/tyk2: 22 edges\n", + " - jacs_set/p38: 51 edges\n", + " - charge_annihilation_set/irak4_s2: 3 edges\n", + " - charge_annihilation_set/irak4_s3: 2 edges\n", + " - charge_annihilation_set/egfr: 2 edges\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jenniferclark/mamba/envs/openfe-benchmarks-test/lib/python3.13/site-packages/cinnabar/femap.py:556: UserWarning: Graph is not connected enough to compute absolute values\n", + " warnings.warn(\"Graph is not connected enough to compute absolute values\")\n" + ] + } + ], + "source": [ + "# Access ddg_femaps (first access may be slow)\n", + "print(\"Generating FEMaps...\")\n", + "ddg_femaps = results.ddg_femaps\n", + "\n", + "print(f\"\\nGenerated {len(ddg_femaps)} FEMaps:\")\n", + "for (system_group, system_name), femap in ddg_femaps.items():\n", + " # Use to_legacy_graph() to get the networkx graph\n", + " leg_graph = femap.to_legacy_graph()\n", + " n_edges = len(leg_graph.edges())\n", + " print(f\" - {system_group}/{system_name}: {n_edges} edges\")" + ] + }, + { + "cell_type": "markdown", + "id": "cf333bc7", + "metadata": {}, + "source": [ + "## Plotting Example\n", + "\n", + "Use cinnabar to plot predicted vs experimental for one system." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "9b516fe0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Plotted jacs_set/tyk2 with 22 edges\n" + ] + } + ], + "source": [ + "# Plot the first system\n", + "if ddg_femaps:\n", + " (system_group, system_name), femap = list(ddg_femaps.items())[0]\n", + "\n", + " # Create the plot\n", + " leg_graph = femap.to_legacy_graph()\n", + " fig = plotting.plot_DDGs(\n", + " graph=leg_graph,\n", + " title=f\"{system_group} - {system_name}\",\n", + " figsize=6,\n", + " scatter_kwargs={\"s\": 30, \"marker\": \"o\", \"alpha\": 0.7},\n", + " )\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + " print(f\"\\nPlotted {system_group}/{system_name} with {len(leg_graph.edges())} edges\")" + ] + }, + { + "cell_type": "markdown", + "id": "b0caaadd", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "This notebook demonstrated:\n", + "\n", + "1. **Loading results** with `get_benchmark_results()`\n", + "2. **Filtering** with various conditions:\n", + " - Single and multiple tags (AND/OR logic)\n", + " - System name and group\n", + " - Wildcards and NOT logic\n", + " - Nested protocol settings\n", + "3. **Pint Quantity comparison** for filtering by magnitude\n", + "4. **Lazy FEMap generation** with `.ddg_femaps` property\n", + "5. **Plotting** with cinnabar\n", + "\n", + "Next steps:\n", + "- Explore other submissions with different calculation types (ASFE, RBFE)\n", + "- Use filtering to focus on specific systems or conditions\n", + "- Combine with statistical analysis for benchmark comparisons" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/openfe_benchmarks/results/__init__.py b/openfe_benchmarks/results/__init__.py index 9c6f16cc..ca933cc5 100644 --- a/openfe_benchmarks/results/__init__.py +++ b/openfe_benchmarks/results/__init__.py @@ -2,6 +2,6 @@ Results loading and filtering module. """ -from ._benchmark_results import BenchmarkResults, filter_results +from ._benchmark_results import BenchmarkResults, get_benchmark_results, filter_results -__all__ = ["BenchmarkResults", "filter_results"] +__all__ = ["BenchmarkResults", "get_benchmark_results", "filter_results"] diff --git a/openfe_benchmarks/results/_benchmark_results.py b/openfe_benchmarks/results/_benchmark_results.py index 67b0db83..c543b8f3 100644 --- a/openfe_benchmarks/results/_benchmark_results.py +++ b/openfe_benchmarks/results/_benchmark_results.py @@ -6,21 +6,34 @@ """ from pathlib import Path -from dataclasses import dataclass +from dataclasses import dataclass, field +from typing import Optional, Any, Union +from datetime import date as date_type import yaml import json import bz2 import fnmatch +import re import logging +import warnings + +from packaging.version import Version, InvalidVersion +import pint from gufe.tokenization import JSON_HANDLER from cinnabar import FEMap +from openfe_benchmarks.scripts._results_utils import ( + build_femap_from_absolute_results, + build_femap_from_relative_results, +) + # Get logger for this module - will inherit configuration from parent logger = logging.getLogger(__name__) __all__ = [ "BenchmarkResults", + "get_benchmark_results", "filter_results", ] @@ -29,175 +42,195 @@ ) +@dataclass +class Archive: + """ + Archive metadata for submission. + + Parameters + ---------- + doi : str + Digital Object Identifier for the archived submission + archive_provider : str + Name of the archive provider (e.g., 'zenodo', 'figshare') + """ + + doi: str + archive_provider: str + + @dataclass class BenchmarkResults: """ Represents computational results from a submission.yaml file. - Initialize with a submission_id to load the results. Use filter_results() - function to filter the raw computational data. + This dataclass mirrors the exact structure of submission.yaml files generated by + prepare_metadata_submission.py, providing self-validating schema enforcement. + + Use get_benchmark_results() to load from disk. Attributes ---------- submission_id : str - Unique identifier from submission.yaml + Unique identifier from submission.yaml (required) title : str - Descriptive title - calculation_type : str - Type of calculation (rbfe, asfe, etc.) + Descriptive title (required) + summary : str + Short descriptive summary (required) tags : list[str] - List of submission tags - metadata : dict - All metadata from submission.yaml (authors, date, forcefields, etc.) - raw_results : dict | None - Raw computational_results.json loaded as nested dict, or None if load_results=False - results_file : Path - Path to the computational_results.json file - submission_file : Path - Path to the submission.yaml file + List of submission tags (required) + calculation_type : str + Type of calculation: 'rbfe', 'asfe', etc. (required) + authors : list[dict] + List of author dictionaries with 'name', optional 'affiliation', 'orcid' (required) + date : str + Publication/submission date in ISO 8601 format (required) + results : str + Results filename (required) + archive : Archive + Archive metadata with doi and archive_provider (required) + license : str + License identifier (required) + openfe_version : str, optional + OpenFE version string + openmm_version : str, optional + OpenMM version string + openff_toolkit_version : str, optional + OpenFF Toolkit version string + mapper : str, optional + Mapper name and version + forcefield : list[str] | str, optional + Protein/solvent force field(s) + small_molecule_forcefield : str, optional + Small molecule force field + partial_charges : str, optional + Partial charge method + benchmark_data : dict, optional + BenchmarkData provenance with network keys + protocol_settings : list[dict], optional + Protocol settings for each configuration Examples -------- >>> # Load results with computational data - >>> results = BenchmarkResults(submission_id='2026-03-18-openmm-840-qa-testing') + >>> results = get_benchmark_results('2026-03-18-openmm-840-qa-testing') >>> >>> # Fast YAML-only load (for CI validation) - >>> results = BenchmarkResults(submission_id='2026-03-18-openmm-840-qa-testing', load_results=False) + >>> results = get_benchmark_results('2026-03-18-openmm-840-qa-testing', load_results=False) >>> >>> # Filter the results >>> rbfe_results = filter_results(results, tags='rbfe') >>> tyk2_results = filter_results(results, system_name='tyk2') """ + # Required fields (match submission.yaml structure exactly) submission_id: str title: str - calculation_type: str + summary: str tags: list[str] - metadata: dict - raw_results: dict | None - results_file: Path - submission_file: Path - - def __init__( - self, - submission_id: str, - load_results: bool = True, - results_dir: Path | None = None, - ): + calculation_type: str + authors: list[dict[str, str]] + date: str + results: str + archive: Archive + license: str + openfe_version: str + openmm_version: str + openff_toolkit_version: str + partial_charges: str + benchmark_data: dict[str, Any] + protocol_settings: list[dict[str, Any]] + + # Optional fields (commonly present in submission.yaml) + mapper: Optional[str] = None + forcefield: Optional[list[str] | str] = None + small_molecule_forcefield: Optional[str] = None + + # Computed fields (not from YAML, set by get_benchmark_results) + raw_results: Optional[dict] = field(default=None, repr=False) + results_file: Optional[Path] = field(default=None, repr=False) + submission_file: Optional[Path] = field(default=None, repr=False) + + # FEMap caches (private) + _dg_femaps_cache: Optional[dict] = field(default=None, repr=False, init=False) + _ddg_femaps_cache: Optional[dict] = field(default=None, repr=False, init=False) + + def __post_init__(self): """ - Initialize BenchmarkResults by loading from submission_id. - - Parameters - ---------- - submission_id : str - Unique submission identifier (e.g., '2026-03-18-openmm-840-qa-testing') - load_results : bool, default=True - If True, load computational_results.json. If False, only load YAML metadata - (for fast CI validation). When False, raw_results will be None. - results_dir : Path, optional - Results directory to search. Defaults to openfe_benchmarks/results/ + Validate and normalize fields after dataclass initialization. - Raises - ------ - FileNotFoundError - If submission_id directory or submission.yaml not found - ValueError - If submission.yaml missing required fields or submission_id mismatch + Normalizations performed: + - Converts single tag string to list + - Converts single forcefield string to list + - Converts archive dict to Archive dataclass + - Initializes FEMap caches to None """ - # Auto-discover results directory - if results_dir is None: - results_dir = _RESULTS_DIR - else: - results_dir = Path(results_dir) + # Ensure tags is a list + if not isinstance(self.tags, list): + self.tags = [self.tags] - # Construct paths - submission_dir = results_dir / submission_id - submission_file = submission_dir / "submission.yaml" + # Ensure forcefield is normalized (if present) + if self.forcefield is not None and not isinstance(self.forcefield, list): + self.forcefield = [self.forcefield] - # Validate paths exist - if not submission_dir.exists(): - raise FileNotFoundError(f"Submission not found: {submission_id}") + # Convert archive dict to Archive dataclass if needed + if isinstance(self.archive, dict): + self.archive = Archive(**self.archive) - if not submission_file.exists(): - raise FileNotFoundError(f"submission.yaml not found for: {submission_id}") + # Initialize FEMap caches + self._dg_femaps_cache = None + self._ddg_femaps_cache = None - # Load YAML - try: - with open(submission_file, "r") as f: - yaml_data = yaml.safe_load(f) - except Exception as e: - raise ValueError(f"Error reading submission.yaml for {submission_id}: {e}") - - # Validate required fields - required_fields = [ - "submission_id", - "title", - "calculation_type", - "tags", - "results", - ] - missing_fields = [field for field in required_fields if field not in yaml_data] - if missing_fields: - raise ValueError( - f"Invalid submission.yaml: missing required fields: {missing_fields}" - ) + def __repr__(self): + """Return concise string representation with submission_id and calculation_type.""" + return f"BenchmarkResults(submission_id='{self.submission_id}', calculation_type='{self.calculation_type}')" - # Validate submission_id matches - yaml_submission_id = yaml_data["submission_id"] - if yaml_submission_id != submission_id: - raise ValueError( - f"submission_id mismatch: YAML has '{yaml_submission_id}', expected '{submission_id}'" - ) + def load_raw_results(self) -> None: + """ + Load computational results JSON file into raw_results. - # Extract basic fields - self.submission_id = yaml_data["submission_id"] - self.title = yaml_data["title"] - self.calculation_type = yaml_data["calculation_type"] - self.tags = ( - yaml_data["tags"] - if isinstance(yaml_data["tags"], list) - else [yaml_data["tags"]] - ) - self.metadata = yaml_data - - # Construct results file path - results_filename = yaml_data["results"] - self.results_file = submission_dir / results_filename - self.submission_file = submission_file - - # Conditionally load computational results - self.raw_results = None - if load_results: - # Validate results file exists - if not self.results_file.exists(): - raise FileNotFoundError(f"Results file not found: {self.results_file}") - - # Load JSON with bz2 support - open_func = bz2.open if ".bz2" in str(self.results_file) else open - try: - with open_func(self.results_file, "rt") as handle: - self.raw_results = json.load(handle, cls=JSON_HANDLER.decoder) - except Exception as e: - raise ValueError(f"Error loading results file {self.results_file}: {e}") + Loads the JSON file specified in the results field, with automatic bz2 support. + Updates the raw_results attribute in place. - # Initialize FEMap caches - self._dg_femaps_cache = None - self._ddg_femaps_cache = None + Raises + ------ + FileNotFoundError + If results file does not exist + ValueError + If results file cannot be loaded - logger.debug( - f"Loaded BenchmarkResults: {self.submission_id} (load_results={load_results})" - ) + Examples + -------- + >>> results = get_benchmark_results('2026-03-18-openmm-840-qa-testing', load_results=False) + >>> results.raw_results is None + True + >>> results.load_raw_results() + >>> results.raw_results is not None + True + """ + # Validate results file exists + if not self.results_file.exists(): + raise FileNotFoundError(f"Results file not found: {self.results_file}") - def __repr__(self): - """Return string representation.""" - return f"BenchmarkResults(submission_id='{self.submission_id}', title='{self.title}')" + # Load JSON with bz2 support + open_func = bz2.open if ".bz2" in str(self.results_file) else open + try: + with open_func(self.results_file, "rt") as handle: + self.raw_results = json.load(handle, cls=JSON_HANDLER.decoder) + except Exception as e: + raise ValueError(f"Error loading results file {self.results_file}: {e}") + + logger.debug(f"Loaded raw_results for {self.submission_id}") @property def dg_femaps(self) -> dict[tuple[str, str], FEMap]: """ Lazy-loaded FEMaps for absolute (dg) results grouped by system. - Returns FEMaps with calculated and experimental solvation free energy data. + Returns FEMaps with calculated and experimental data for both ASFE and RBFE submissions: + - ASFE: absolute solvation free energies with experimental comparison + - RBFE: absolute binding free energies (reference values) + Results are cached after first access to avoid repeated processing. Returns @@ -212,10 +245,17 @@ def dg_femaps(self) -> dict[tuple[str, str], FEMap]: Examples -------- + >>> # ASFE submission >>> results = BenchmarkResults(submission_id='2026-08-06-openff-2.3.0-solvation_set_freesolv') >>> femaps = results.dg_femaps >>> for (group, name), femap in femaps.items(): ... print(f"{group}/{name}: {len(femap.edges)} calculations") + >>> + >>> # RBFE submission + >>> results = BenchmarkResults(submission_id='2026-02-12_sage_230_jacs') + >>> femaps = results.dg_femaps + >>> for (group, name), femap in femaps.items(): + ... print(f"{group}/{name}: absolute binding values") """ if self.raw_results is None: raise ValueError( @@ -223,25 +263,21 @@ def dg_femaps(self) -> dict[tuple[str, str], FEMap]: "Initialize with load_results=True to access computational data." ) - if "dg" not in self.raw_results: - raise ValueError( - f"'dg' key not found in raw_results for {self.submission_id}. " - f"Available keys: {list(self.raw_results.keys())}" - ) - # Return cached value if available if self._dg_femaps_cache is not None: return self._dg_femaps_cache - # Import here to avoid circular dependency - from openfe_benchmarks.scripts._results_utils import ( - build_femap_from_absolute_results, - ) + # Build FEMaps from absolute results (both ASFE and RBFE supported) + if "dg" not in self.raw_results: + raise ValueError( + f"'dg' key not found in raw_results for {self.calculation_type} submission {self.submission_id}. " + f"Available keys: {list(self.raw_results.keys())}" + ) - # Build FEMaps and cache - logger.warning("Computing FEMaps for dg results - first access may be slow") + # Build FEMaps and cache, passing calculation type + logger.info("Computing FEMaps for dg results - first access may be slow") self._dg_femaps_cache = build_femap_from_absolute_results( - self.raw_results["dg"] + self.raw_results["dg"], calculation_type=self.calculation_type ) return self._dg_femaps_cache @@ -287,13 +323,8 @@ def ddg_femaps(self) -> dict[tuple[str, str], FEMap]: if self._ddg_femaps_cache is not None: return self._ddg_femaps_cache - # Import here to avoid circular dependency - from openfe_benchmarks.scripts._results_utils import ( - build_femap_from_relative_results, - ) - # Build FEMaps and cache - logger.warning("Computing FEMaps for ddg results - first access may be slow") + logger.info("Computing FEMaps for ddg results - first access may be slow") self._ddg_femaps_cache = build_femap_from_relative_results( self.raw_results["ddg"] ) @@ -301,6 +332,185 @@ def ddg_femaps(self) -> dict[tuple[str, str], FEMap]: return self._ddg_femaps_cache +# Factory function helpers + + +def _load_and_validate_yaml(submission_file: Path, submission_id: str) -> dict: + """ + Load and validate YAML structure from submission file. + + Parameters + ---------- + submission_file : Path + Path to submission.yaml file + submission_id : str + Expected submission identifier + + Returns + ------- + dict + Loaded YAML data + + Raises + ------ + ValueError + If YAML cannot be parsed or submission_id doesn't match + """ + try: + with open(submission_file, "r") as f: + yaml_data = yaml.safe_load(f) + except Exception as e: + raise ValueError(f"Error reading submission.yaml for {submission_id}: {e}") + + # Validate submission_id matches directory name + yaml_submission_id = yaml_data.get("submission_id") + if yaml_submission_id != submission_id: + raise ValueError( + f"submission_id mismatch: YAML has '{yaml_submission_id}', expected '{submission_id}'" + ) + + return yaml_data + + +def _extract_benchmark_fields(yaml_data: dict, submission_id: str) -> BenchmarkResults: + """ + Extract and validate fields from YAML data to construct BenchmarkResults. + + Uses pop() to consume fields and detect unknown entries. + + Parameters + ---------- + yaml_data : dict + Loaded YAML data + submission_id : str + Submission identifier for error messages + + Returns + ------- + BenchmarkResults + Constructed dataclass instance (without file paths or loaded results) + + Raises + ------ + ValueError + If required fields are missing or unknown fields are present + """ + yaml_fields = yaml_data.copy() + + try: + benchmark_results = BenchmarkResults( + # Required fields + submission_id=yaml_fields.pop("submission_id"), + title=yaml_fields.pop("title"), + summary=yaml_fields.pop("summary"), + tags=yaml_fields.pop("tags"), + calculation_type=yaml_fields.pop("calculation_type"), + authors=yaml_fields.pop("authors"), + date=yaml_fields.pop("date"), + results=yaml_fields.pop("results"), + archive=yaml_fields.pop("archive"), + license=yaml_fields.pop("license"), + openfe_version=yaml_fields.pop("openfe_version"), + openmm_version=yaml_fields.pop("openmm_version"), + openff_toolkit_version=yaml_fields.pop("openff_toolkit_version"), + partial_charges=yaml_fields.pop("partial_charges"), + benchmark_data=yaml_fields.pop("benchmark_data"), + protocol_settings=yaml_fields.pop("protocol_settings"), + # Optional fields + mapper=yaml_fields.pop("mapper", None), + forcefield=yaml_fields.pop("forcefield", None), + small_molecule_forcefield=yaml_fields.pop( + "small_molecule_forcefield", None + ), + ) + except KeyError as e: + raise ValueError( + f"Invalid submission.yaml for {submission_id}: missing required field {e}" + ) + + # Check for unknown fields remaining in yaml_fields + if yaml_fields: + unknown_fields = list(yaml_fields.keys()) + raise ValueError( + f"Unknown fields in submission.yaml for {submission_id}: {unknown_fields}" + ) + + return benchmark_results + + +def get_benchmark_results( + submission_id: str, + load_results: bool = True, +) -> BenchmarkResults: + """ + Factory function to load BenchmarkResults from a submission_id. + + This is the primary way to load BenchmarkResults objects from disk. + Loads submission.yaml and optionally the computational results JSON. + + Parameters + ---------- + submission_id : str + Unique submission identifier (e.g., '2026-03-18-openmm-840-qa-testing') + load_results : bool, default=True + If True, load computational_results.json. If False, only load YAML metadata + (for fast CI validation). When False, raw_results will be None. + + Returns + ------- + BenchmarkResults + Loaded results object + + Raises + ------ + FileNotFoundError + If submission_id directory or submission.yaml not found + ValueError + If submission.yaml is invalid or has mismatched submission_id + + Examples + -------- + >>> results = get_benchmark_results('2026-03-18-openmm-840-qa-testing') + >>> results.title + 'OpenFE RBFE - Multi-set Benchmark...' + + >>> # Fast YAML-only load for validation + >>> results = get_benchmark_results('2026-03-18-openmm-840-qa-testing', load_results=False) + >>> print(results.calculation_type) + 'rbfe' + """ + # Construct and validate paths + submission_dir = _RESULTS_DIR / submission_id + submission_file = submission_dir / "submission.yaml" + + if not submission_dir.exists(): + raise FileNotFoundError(f"Submission not found: {submission_id}") + + if not submission_file.exists(): + raise FileNotFoundError(f"submission.yaml not found for: {submission_id}") + + # Load and validate YAML + yaml_data = _load_and_validate_yaml(submission_file, submission_id) + + # Extract fields to construct BenchmarkResults + benchmark_results = _extract_benchmark_fields(yaml_data, submission_id) + + # Set computed fields + results_filename = yaml_data["results"] + benchmark_results.results_file = submission_dir / results_filename + benchmark_results.submission_file = submission_file + + # Conditionally load computational results + if load_results: + benchmark_results.load_raw_results() + + logger.debug( + f"Loaded BenchmarkResults: {benchmark_results.submission_id} (load_results={load_results})" + ) + + return benchmark_results + + # Standalone filtering functions @@ -315,6 +525,9 @@ def filter_results( - Nested fields: protocol_settings__temperature='298.15 K' (use __ for nesting) - Result fields: system_group='jacs_set', system_name='tyk2' - Wildcards: system_name='*tyk2*' (uses fnmatch) + - Comparison operators inline notation: date='>=2026-01-01', openfe_version='<1.0.0' + (supports <, <=, >, >= for dates, versions, and pint Quantity objects) + - Pint Quantity comparison: automatically handles unit conversion (e.g., '25 celsius' == '298.15 K') - OR logic within field: pass list for ANY match (e.g., system_name=['tyk2', 'thrombin']) - NOT logic: use exclude_ prefix (e.g., exclude_tags=['deprecated']) - AND logic between fields: all filter conditions must match @@ -364,6 +577,11 @@ def filter_results( >>> no_deprecated = filter_results(results, exclude_tags='deprecated') >>> no_test = filter_results(results, exclude_tags=['deprecated', 'test'], tags_mode='any') >>> + >>> # Comparison operators (inline notation) + >>> recent = filter_results(results, date='>=2026-01-01') + >>> old_versions = filter_results(results, openfe_version='<1.0.0') + >>> newer_versions = filter_results(results, openmm_version='>=8.0.0') + >>> >>> # Complex: multiple tags (AND), system OR, exclude >>> filtered = filter_results( ... results, @@ -394,7 +612,7 @@ def filter_results( for result in all_results: # Check all filters (AND logic between different filters) if all( - _match_filter(result, benchmark_results.metadata, key, value, tags_mode) + _match_filter(result, benchmark_results, key, value, tags_mode) for key, value in filters.items() ): filtered.append(result) @@ -402,8 +620,46 @@ def filter_results( return filtered +def _get_nested_value(result: dict, nested_key: str) -> Optional[Any]: + """ + Extract value from nested dictionary using double-underscore separated keys. + + Parameters + ---------- + result : dict + Result dictionary to extract from + nested_key : str + Nested key with __ separator (e.g., 'protocol_settings__temperature') + + Returns + ------- + Optional[Any] + The nested value if found, None otherwise + + Examples + -------- + >>> result = {'protocol_settings': {'temperature': '298.15 K'}} + >>> _get_nested_value(result, 'protocol_settings__temperature') + '298.15 K' + >>> _get_nested_value(result, 'protocol_settings__missing') + None + """ + keys = nested_key.split("__") + value = result + for key in keys: + if isinstance(value, dict): + value = value.get(key, None) + else: + return None + return value + + def _match_filter( - result: dict, metadata: dict, filter_key: str, filter_val, tags_mode: str = "all" + result: dict, + benchmark_results: BenchmarkResults, + filter_key: str, + filter_val: Union[str, list, Any], + tags_mode: str = "all", ) -> bool: """ Check if a result matches a filter predicate. @@ -412,14 +668,15 @@ def _match_filter( ---------- result : dict Result dictionary to check - metadata : dict - Metadata from BenchmarkResults (for fallback field access) + benchmark_results : BenchmarkResults + BenchmarkResults object (for fallback field access to top-level metadata) filter_key : str - Filter key (may have exclude_ prefix, may have __ for nested access) - filter_val : any - Filter value (may be single value or list for OR logic) - tags_mode : str - Mode for tags filtering ('all' or 'any') + Filter key (may have exclude_ prefix, may have __ for nested fields) + filter_val : Union[str, list, Any] + Filter value (single value for exact match, list for OR logic, + or string with leading comparison operator like '>=1.0.0') + tags_mode : str, default='all' + Mode for tags filtering: 'all' (AND) or 'any' (OR) Returns ------- @@ -427,65 +684,75 @@ def _match_filter( True if result matches filter, False otherwise """ # Handle NOT logic (exclude_ prefix) + EXCLUDE_PREFIX = "exclude_" negate = False - if filter_key.startswith("exclude_"): + if filter_key.startswith(EXCLUDE_PREFIX): negate = True - filter_key = filter_key[8:] # Remove 'exclude_' prefix + filter_key = filter_key[len(EXCLUDE_PREFIX) :] # Remove 'exclude_' prefix - # Handle nested field access (e.g., protocol_settings__lambda_windows) - if "__" in filter_key: - # Split on __ and traverse nested dict - keys = filter_key.split("__") - value = result - for key in keys: - if isinstance(value, dict): - value = value.get(key, None) - else: - value = None - break + # Parse inline comparison operators from filter value (e.g., '>=2026-01-01') + comparison_op = None + if isinstance(filter_val, str): + comparison_op, filter_val = _parse_inline_operator(filter_val) + # Extract field value (handle nested access) + if "__" in filter_key: + value = _get_nested_value(result, filter_key) if value is None: # Field not found in result result_matched = False - else: - result_matched = _match_value(value, filter_val, filter_key, tags_mode) + return not result_matched if negate else result_matched else: # Direct field access - # First try result dict, then fall back to metadata for top-level fields + # First try result dict, then fall back to BenchmarkResults attributes for top-level fields if filter_key in result: value = result[filter_key] - elif filter_key in metadata: - value = metadata[filter_key] + elif hasattr(benchmark_results, filter_key): + value = getattr(benchmark_results, filter_key) else: # Field not found result_matched = False return not result_matched if negate else result_matched + # Apply comparison or match logic + if comparison_op is not None: + result_matched = _compare_values(value, filter_val, comparison_op, filter_key) + else: result_matched = _match_value(value, filter_val, filter_key, tags_mode) # Apply negation if needed return not result_matched if negate else result_matched -def _match_value(result_value, filter_val, filter_key: str, tags_mode: str) -> bool: +def _match_value( + result_value: Any, + filter_val: Union[str, list, Any], + filter_key: str, + tags_mode: str, +) -> bool: """ - Check if a result value matches a filter value. + Check if a result value matches a filter value with special tags handling. Parameters ---------- - result_value : any - Value from result to check - filter_val : any - Filter value (may be single value or list) + result_value : Any + Value from result to check against the filter + filter_val : Union[str, list, Any] + Filter value - single value for exact match, list for OR logic filter_key : str - Filter key (for special handling of 'tags') + Filter key name (used for special handling of 'tags' field) tags_mode : str - Mode for tags filtering ('all' or 'any') + Mode for tags filtering: 'all' (AND logic) or 'any' (OR logic) Returns ------- bool True if value matches filter, False otherwise + + Raises + ------ + ValueError + If tags_mode is not 'all' or 'any' """ # Special handling for tags field with list filter_val if filter_key == "tags" and isinstance(filter_val, list): @@ -510,7 +777,7 @@ def _match_value(result_value, filter_val, filter_key: str, tags_mode: str) -> b return _match_single_value(result_value, filter_val) -def _match_single_value(result_value, filter_val) -> bool: +def _match_single_value(result_value: Any, filter_val: Any) -> bool: """ Check if a single result value matches a single filter value. @@ -518,9 +785,9 @@ def _match_single_value(result_value, filter_val) -> bool: Parameters ---------- - result_value : any + result_value : Any Value from result to check - filter_val : any + filter_val : Any Single filter value (not a list) Returns @@ -538,3 +805,196 @@ def _match_single_value(result_value, filter_val) -> bool: # Exact match return result_value == filter_val + + +def _parse_inline_operator(value: str) -> tuple[Optional[str], str]: + """ + Parse inline comparison operator from a filter value string. + + Detects operators like >=, >, <=, < at the start of the value. + + Parameters + ---------- + value : str + Filter value that may contain an inline operator (e.g., ">=2026-01-01") + + Returns + ------- + tuple[Optional[str], str] + (operator, value) where operator is '>=', '>', '<=', '<', or None + and value is the remaining string after removing the operator + + Examples + -------- + >>> _parse_inline_operator(">=2026-01-01") + ('>=', '2026-01-01') + >>> _parse_inline_operator("<1.0.0") + ('<', '1.0.0') + >>> _parse_inline_operator("2026-01-01") + (None, '2026-01-01') + """ + # Match >=, >, <=, < at the start of the string + match = re.match(r"^(>=|>|<=|<)(.+)$", value) + if not match: + return None, value + + op_str, remaining = match.groups() + return op_str, remaining.strip() + + +def _compare_values( + result_value: Any, filter_val: Any, operator: str, field_name: str = "" +) -> bool: + """ + Compare result value against filter value using a comparison operator. + + Handles semantic version comparison, date comparison, pint Quantity comparison, + and string comparison. Issues a warning if comparison operators are used with + non-date/version fields. + + Parameters + ---------- + result_value : Any + Value from result to compare + filter_val : Any + Filter value to compare against + operator : str + Comparison operator: '<', '<=', '>', or '>=' + field_name : str, optional + Name of the field being compared (for warning messages) + + Returns + ------- + bool + True if comparison succeeds, False otherwise + + Examples + -------- + >>> _compare_values('2026-01-15', '2026-01-01', '>=', 'date') + True + >>> _compare_values('1.0.0', '2.0.0', '<', 'openfe_version') + True + >>> _compare_values('8.2.0', '8.1.0', '>', 'openmm_version') + True + >>> # pint Quantity comparison (from raw_results JSON) + >>> import pint + >>> ureg = pint.UnitRegistry() + >>> q1 = ureg.Quantity(298.15, 'kelvin') + >>> _compare_values(q1, '300 K', '<') + True + >>> _compare_values(q1, '25 celsius', '>=') # Unit conversion handled automatically + True + """ + # Check if field is appropriate for comparison operators + # Don't warn for date/version fields or pint Quantity objects (semantically meaningful) + COMPARISON_ALLOWED_FIELDS = { + "date", + "openfe_version", + "openmm_version", + "openff_toolkit_version", + } + if ( + field_name + and field_name not in COMPARISON_ALLOWED_FIELDS + and not field_name.endswith("_version") + and not isinstance(result_value, pint.Quantity) + ): + warnings.warn( + f"Comparison operator '{operator}' used with field '{field_name}'. " + f"Comparison operators are designed for date and version fields. " + f"Results may not be semantically meaningful for other field types.", + UserWarning, + stacklevel=4, + ) + + # Handle datetime.date objects (from YAML parsing) + if isinstance(result_value, date_type): + # Convert filter value to date if it's a string + if isinstance(filter_val, str): + try: + # Parse ISO format date string YYYY-MM-DD + filter_val = date_type.fromisoformat(filter_val) + except (ValueError, AttributeError): + # If parsing fails, convert both to strings for comparison + result_value = result_value.isoformat() + + # Now compare dates (both should be date objects or both strings) + if operator == "<": + return result_value < filter_val + elif operator == "<=": + return result_value <= filter_val + elif operator == ">": + return result_value > filter_val + elif operator == ">=": + return result_value >= filter_val + else: + raise ValueError(f"Unknown comparison operator: {operator}") + + # Handle pint Quantity objects (from JSON_HANDLER deserialization) + if isinstance(result_value, pint.Quantity): + # Convert filter value to Quantity if it's a string + # Use the same UnitRegistry as the result_value to ensure compatibility + if isinstance(filter_val, str): + try: + # Parse quantity string using the result_value's UnitRegistry + # This ensures we can compare quantities from the same registry + ureg = result_value._REGISTRY + filter_val = ureg.Quantity(filter_val) + except (ValueError, pint.errors.UndefinedUnitError, AttributeError): + # If parsing fails, convert both to strings for comparison + result_value = str(result_value) + filter_val = str(filter_val) + elif not isinstance(filter_val, pint.Quantity): + # If filter_val is not a string or Quantity, convert both to strings + result_value = str(result_value) + filter_val = str(filter_val) + + # Compare Quantities (pint handles unit conversion automatically) + try: + if operator == "<": + return result_value < filter_val + elif operator == "<=": + return result_value <= filter_val + elif operator == ">": + return result_value > filter_val + elif operator == ">=": + return result_value >= filter_val + else: + raise ValueError(f"Unknown comparison operator: {operator}") + except (pint.errors.DimensionalityError, ValueError): + # Units are incompatible (e.g., comparing temperature to pressure) + # or different registries - fall back to string comparison + result_value = str(result_value) + filter_val = str(filter_val) + + # Try semantic version comparison (for version fields) + try: + result_ver = Version(str(result_value)) + filter_ver = Version(str(filter_val)) + + if operator == "<": + return result_ver < filter_ver + elif operator == "<=": + return result_ver <= filter_ver + elif operator == ">": + return result_ver > filter_ver + elif operator == ">=": + return result_ver >= filter_ver + else: + raise ValueError(f"Unknown comparison operator: {operator}") + + except (InvalidVersion, TypeError): + # Fall back to string comparison + result_str = str(result_value) + filter_str = str(filter_val) + + if operator == "<": + return result_str < filter_str + elif operator == "<=": + return result_str <= filter_str + elif operator == ">": + return result_str > filter_str + elif operator == ">=": + return result_str >= filter_str + else: + raise ValueError(f"Unknown comparison operator: {operator}") diff --git a/openfe_benchmarks/results/_validation.py b/openfe_benchmarks/results/_validation.py new file mode 100644 index 00000000..5dc639ca --- /dev/null +++ b/openfe_benchmarks/results/_validation.py @@ -0,0 +1,251 @@ +""" +CI-optimized validation helpers for BenchmarkResults. + +This module provides fast validation functions for CI scalability: +- YAML-only validation using get_benchmark_results(load_results=False) +- Git-aware changed file detection +- Random sampling with calculation_type coverage + +Target CI performance: <6 min for 100 submissions with 10% changed. +""" + +import subprocess +import random +from pathlib import Path + +from openfe_benchmarks.results import get_benchmark_results +from openfe_benchmarks.results._benchmark_results import _RESULTS_DIR + + +def validate_submission_yaml_fast(yaml_path: Path) -> dict: + """ + Fast YAML-only validation using get_benchmark_results(load_results=False). + + Validates by attempting to construct BenchmarkResults object without + loading JSON data or generating FEMaps. Delegates validation to the + actual factory function that will be used. + + Parameters + ---------- + yaml_path : Path + Path to submission.yaml file + + Returns + ------- + dict + Validation result with keys: + - valid : bool + True if BenchmarkResults construction succeeded + - errors : list[str] + List of validation errors (empty if valid) + - submission_id : str or None + Submission ID if present in YAML + - calculation_type : str or None + Calculation type if present in YAML + + Examples + -------- + >>> result = validate_submission_yaml_fast(Path("results/my-submission/submission.yaml")) + >>> if not result['valid']: + ... print(f"Errors: {result['errors']}") + """ + + result = { + "valid": True, + "errors": [], + "submission_id": None, + "calculation_type": None, + } + + # Check file exists + if not yaml_path.exists(): + result["valid"] = False + result["errors"].append(f"File not found: {yaml_path}") + return result + + # Extract submission_id from path + submission_id = yaml_path.parent.name + + # Attempt to construct BenchmarkResults without loading data + try: + benchmark = get_benchmark_results( + submission_id=submission_id, load_results=False + ) + + # Extract metadata + result["submission_id"] = benchmark.submission_id + result["calculation_type"] = benchmark.calculation_type + + # Verify submission_id matches directory name + if result["submission_id"] and result["submission_id"] != submission_id: + result["valid"] = False + result["errors"].append( + f"submission_id mismatch: YAML has '{result['submission_id']}', " + f"directory is '{submission_id}'" + ) + + except (FileNotFoundError, ValueError) as e: + result["valid"] = False + result["errors"].append(str(e)) + except Exception as e: + result["valid"] = False + result["errors"].append(f"Unexpected error: {e}") + + return result + + +def get_all_submission_ids() -> list[str]: + """ + Find all submission_ids in results directory. + + Discovers directories containing submission.yaml files. + + Returns + ------- + list[str] + List of submission_ids (directory names containing submission.yaml) + + Examples + -------- + >>> ids = get_all_submission_ids() + >>> print(f"Found {len(ids)} submissions") + """ + + if not _RESULTS_DIR.exists(): + return [] + + submission_ids = [] + + # Find all directories with submission.yaml + for item in _RESULTS_DIR.iterdir(): + if item.is_dir(): + yaml_path = item / "submission.yaml" + if yaml_path.exists(): + submission_ids.append(item.name) + + return sorted(submission_ids) + + +def get_changed_submission_ids(base_branch: str = "origin/main") -> list[str]: + """ + Get submission_ids that changed in current branch. + + Uses git diff to detect changes in results/*/submission.yaml or + results/*/computational_results.json files. + + Parameters + ---------- + base_branch : str, default='origin/main' + Base branch to compare against + + Returns + ------- + list[str] + List of submission_ids (extracted from changed file paths) + Returns empty list if git not available or no git repository + + Examples + -------- + >>> changed = get_changed_submission_ids() + >>> print(f"Changed submissions: {changed}") + """ + try: + # Run git diff to get changed files + result = subprocess.run( + ["git", "diff", "--name-only", f"{base_branch}...HEAD"], + capture_output=True, + text=True, + check=True, + ) + + changed_files = result.stdout.strip().split("\n") + + # Extract submission_ids from changed results paths + submission_ids = set() + for file_path in changed_files: + # Match patterns like: results/SUBMISSION_ID/submission.yaml + # or results/SUBMISSION_ID/computational_results.json + parts = Path(file_path).parts + if len(parts) >= 2 and parts[0] == "results": + # Check if it's a submission.yaml or results file + if "submission.yaml" in parts or "computational_results" in parts[-1]: + submission_ids.add(parts[1]) + + return sorted(list(submission_ids)) + + except (subprocess.CalledProcessError, FileNotFoundError): + # Git not available or not a git repository + return [] + + +def select_random_sample( + all_ids: list[str], sample_rate: float = 0.1, seed: int = 42 +) -> list[str]: + """ + Select random sample of submissions ensuring calculation_type coverage. + + Uses get_benchmark_results(load_results=False) to load metadata, groups by + calculation_type, ensures at least one submission per type, then randomly + samples remaining to reach target sample_rate. + + Parameters + ---------- + all_ids : list[str] + All submission_ids to sample from + sample_rate : float, default=0.1 + Fraction to sample (0.1 = 10%, reduced from 20% for CI performance) + seed : int, default=42 + Random seed for reproducibility + + Returns + ------- + list[str] + Selected submission_ids (at least one per calculation_type) + + Examples + -------- + >>> sample = select_random_sample(all_ids, sample_rate=0.1, seed=42) + >>> # Verify reproducibility + >>> sample2 = select_random_sample(all_ids, sample_rate=0.1, seed=42) + >>> assert sample == sample2 + """ + # Set random seed for reproducibility + random.seed(seed) + + # Load metadata using get_benchmark_results to get calculation_type for each submission + calc_type_groups = {} + + for submission_id in all_ids: + # Use get_benchmark_results to load metadata (consistent with validation) + # If loading fails, let the exception propagate - silent failures are bad + benchmark = get_benchmark_results( + submission_id=submission_id, load_results=False + ) + calc_type = benchmark.calculation_type + + if calc_type not in calc_type_groups: + calc_type_groups[calc_type] = [] + + calc_type_groups[calc_type].append(submission_id) + + # Ensure at least one per calculation_type + selected = [] + remaining = [] + + for calc_type, ids in calc_type_groups.items(): + if ids: + # Select one representative for this type + selected.append(ids[0]) + # Add rest to remaining pool + remaining.extend(ids[1:]) + + # Calculate how many more we need to reach sample_rate + target_count = max(int(len(all_ids) * sample_rate), len(selected)) + additional_needed = target_count - len(selected) + + if additional_needed > 0 and remaining: + # Randomly sample from remaining to reach target + additional = random.sample(remaining, min(additional_needed, len(remaining))) + selected.extend(additional) + + return sorted(selected) diff --git a/openfe_benchmarks/scripts/_example_plot_rbfe.py b/openfe_benchmarks/scripts/_example_plot_rbfe.py index 22d883e6..cccf02ba 100644 --- a/openfe_benchmarks/scripts/_example_plot_rbfe.py +++ b/openfe_benchmarks/scripts/_example_plot_rbfe.py @@ -1,58 +1,66 @@ -import pathlib -import json -import bz2 - -from gufe.tokenization import JSON_HANDLER -from cinnabar import plotting +"""Example script demonstrating BenchmarkResults API for RBFE plotting. -from openfe_benchmarks.scripts._results_utils import build_femap_from_relative_results - -RESULTS_FILE = "../results/2026-03-18-openmm-840-qa-testing/computational_results.json" -OUTPUT_DIR = "outputs" +This script showcases the new BenchmarkResults features: +- Loading results using get_benchmark_results() +- Filtering results with filter_results() +- Using lazy .ddg_femaps property for automatic FEMap generation +- Generating plots using cinnabar +Simply edit the SUBMISSION_ID variable to plot a different submission. +""" -def _load_results(results_file: str) -> dict: - results_path = pathlib.Path(results_file) +import pathlib - if not results_path.exists(): - raise FileNotFoundError(f"Could not find results file: {results_path}") +from cinnabar import plotting - open_func = bz2.open if "bz2" in results_file else open +from openfe_benchmarks.results import get_benchmark_results - with open_func(results_path, "rt") as handle: - return json.load(handle, cls=JSON_HANDLER.decoder) +# Edit this to plot a different submission +SUBMISSION_ID = "2026-03-18-openmm-840-qa-testing" +OUTPUT_DIR = "outputs" def main(): - """ - An example script which can load the calculated DDG values from RBFE calculations and plot vs experimental data for each system. + """Load RBFE results and plot vs experimental data for each system.""" - Notes: - - Does not plot the DG values - """ + # 1. Load results using the new get_benchmark_results() factory function + print(f"Loading submission: {SUBMISSION_ID}") + results = get_benchmark_results(SUBMISSION_ID) + print(f"Loaded: {results.title}") + print(f"Calculation type: {results.calculation_type}") + print(f"Tags: {', '.join(results.tags)}") - # load the results file, whether compressed or not - results = _load_results(RESULTS_FILE) - if "ddg" not in results: + # Verify this is an RBFE submission + if "ddg" not in results.raw_results: raise ValueError( - f"Results file {RESULTS_FILE} does not contain 'ddg' values, cannot plot" + f"Submission {SUBMISSION_ID} does not contain 'ddg' values. " + f"This script is for RBFE calculations only." ) - # build FEMaps and load with experimental data - femaps_by_system = build_femap_from_relative_results(results=results["ddg"]) + print("\nGenerating FEMaps...") + femaps_by_system = results.ddg_femaps + print(f"Generated {len(femaps_by_system)} FEMaps:") + for (system_group, system_name), femap in femaps_by_system.items(): + n_edges = len(femap.edges) + print(f" - {system_group}/{system_name}: {n_edges} edges") output_dir = pathlib.Path(OUTPUT_DIR) output_dir.mkdir(parents=True, exist_ok=True) - # for each system plot the RBFE results + + print(f"\nGenerating plots in {output_dir}/...") for (system_group, system_name), femap in femaps_by_system.items(): leg_graph = femap.to_legacy_graph() + output_file = output_dir / f"{system_group}_{system_name}_DDG.png" plotting.plot_DDGs( graph=leg_graph, title=f"{system_group}-{system_name}", figsize=5, scatter_kwargs={"s": 20, "marker": "o"}, - filename=(output_dir / f"{system_group}_{system_name}_DDG.png").as_posix(), + filename=output_file.as_posix(), ) + print(f" Created: {output_file}") + + print(f"\nComplete! Generated {len(femaps_by_system)} plots.") if __name__ == "__main__": diff --git a/openfe_benchmarks/scripts/_no_test_example_plot_asfe.py b/openfe_benchmarks/scripts/_no_test_example_plot_asfe.py index b267329d..14f682c7 100644 --- a/openfe_benchmarks/scripts/_no_test_example_plot_asfe.py +++ b/openfe_benchmarks/scripts/_no_test_example_plot_asfe.py @@ -1,61 +1,67 @@ -"""Plot ASFEs, only for cinnabar >= 0.6.1, which is not compatible with current env""" +"""Example script demonstrating BenchmarkResults API for ASFE plotting. -import pathlib -import json -import bz2 - -from gufe.tokenization import JSON_HANDLER -from cinnabar import plotting +This script showcases the new BenchmarkResults features: +- Loading results using get_benchmark_results() +- Filtering results with filter_results() +- Using lazy .dg_femaps property for automatic FEMap generation +- Generating plots using cinnabar -from openfe_benchmarks.scripts._results_utils import build_femap_from_absolute_results - -RESULTS_FILE = "../results/2026-08-06-openff-2.3.0-solvation_set_freesolv/computational_results.json.bz2" -OUTPUT_DIR = "outputs" +Simply edit the SUBMISSION_ID variable to plot a different submission. +Note: Requires cinnabar >= 0.6.1 for ASFE plotting support. +""" -def _load_results(results_file: str) -> dict: - results_path = pathlib.Path(results_file) +import pathlib - if not results_path.exists(): - raise FileNotFoundError(f"Could not find results file: {results_path}") +from cinnabar import plotting - open_func = bz2.open if "bz2" in results_file else open +from openfe_benchmarks.results import get_benchmark_results - with open_func(results_path, "rt") as handle: - return json.load(handle, cls=JSON_HANDLER.decoder) +# Edit this to plot a different submission +SUBMISSION_ID = "2026-08-06-openff-2.3.0-solvation_set_freesolv" +OUTPUT_DIR = "outputs" def main(): - """ - An example script which can load the calculated DG values from ASFE calculations and plot vs experimental solvation data. + """Load ASFE results and plot vs experimental solvation data for each system.""" - This script creates plots comparing the computed absolute solvation free energies (DG) - to experimental values for each benchmark system. - """ + print(f"Loading submission: {SUBMISSION_ID}") + results = get_benchmark_results(SUBMISSION_ID) + print(f"Loaded: {results.title}") + print(f"Calculation type: {results.calculation_type}") + print(f"Tags: {', '.join(results.tags)}") - # load the results file, whether compressed or not - results = _load_results(RESULTS_FILE) - if "dg" not in results: + # Verify this is an ASFE submission + if "dg" not in results.raw_results: raise ValueError( - f"Results file {RESULTS_FILE} does not contain 'dg' values, cannot plot" + f"Submission {SUBMISSION_ID} does not contain 'dg' values. " + f"This script is for ASFE calculations only." ) - # build FEMaps and load with experimental data - femaps_by_system = build_femap_from_absolute_results(results=results["dg"]) + print("\nGenerating FEMaps...") + femaps_by_system = results.dg_femaps + print(f"Generated {len(femaps_by_system)} FEMaps:") + for (system_group, system_name), femap in femaps_by_system.items(): + n_values = len(femap.graph.nodes) + print(f" - {system_group}/{system_name}: {n_values} calculations") output_dir = pathlib.Path(OUTPUT_DIR) output_dir.mkdir(parents=True, exist_ok=True) - # for each system plot the ASFE results compared to experimental data + print(f"\nGenerating plots in {output_dir}/...") for (system_group, system_name), femap in femaps_by_system.items(): + output_file = output_dir / f"{system_group}_{system_name}_DG.png" plotting.plot_DGs( femap, source="Computational", title=f"{system_group}-{system_name}", figsize=5, scatter_kwargs={"s": 20, "marker": "o"}, - filename=(output_dir / f"{system_group}_{system_name}_DG.png").as_posix(), + filename=output_file.as_posix(), ) + print(f" Created: {output_file}") + + print(f"\nComplete! Generated {len(femaps_by_system)} plots.") if __name__ == "__main__": diff --git a/openfe_benchmarks/scripts/_results_utils.py b/openfe_benchmarks/scripts/_results_utils.py index d2091604..7dedd02f 100644 --- a/openfe_benchmarks/scripts/_results_utils.py +++ b/openfe_benchmarks/scripts/_results_utils.py @@ -89,27 +89,48 @@ def build_femap_from_relative_results( def build_femap_from_absolute_results( results: list[dict], + calculation_type: str = "asfe", ) -> dict[tuple[str, str], FEMap]: """ - Build FEMaps for each of the unique combinations of system_group and system_name in the absolute solvation results - and add experimental solvation free energy data. + Build FEMaps for each of the unique combinations of system_group and system_name in the absolute results + and add experimental data where available. Parameters ---------- results: list[dict] - A list of absolute solvation free energy estimates which should include at least the following entries: + A list of absolute free energy estimates. Format depends on calculation_type: + + For ASFE (absolute solvation): - solute: str + - solvent: str + - system_group: str + - system_name: str + - dg or estimate: Quantity + - dg_uncertainty or estimate_error: Quantity + + For RBFE (absolute binding reference values): + - ligand: str - system_group: str - system_name: str - dg: Quantity - dg_uncertainty: Quantity + calculation_type: str, default='asfe' + Type of calculation: 'asfe' for absolute solvation, 'rbfe' for relative binding + Returns ------- dict[tuple[str, str], FEMap] A dictionary mapping each unique combination of system_group and system_name to an FEMap with calculated - and experimental solvation free energy data. + and experimental data (where available). """ + # Detect format from data if not specified + if results and calculation_type == "asfe": + # Check if this is actually RBFE format + first_result = results[0] + if "ligand" in first_result and "solute" not in first_result: + calculation_type = "rbfe" + # get the unique combinations of system_group and system_name results_by_system_key = defaultdict(list) for result in results: @@ -121,9 +142,17 @@ def build_femap_from_absolute_results( system_group, system_name = system_key benchmark_data = get_benchmark_data_system(system_group, system_name) - # Check if all solutes have valid dg_uncertainty (not NaN) - solutes_no_uncertainty = [ - result["solute"] + # Determine molecule key and value/error keys based on calculation type + if calculation_type == "asfe": + molecule_key = "solute" + has_solvent = True + else: # rbfe + molecule_key = "ligand" + has_solvent = False + + # Check if all molecules have valid uncertainty (not NaN) + molecules_no_uncertainty = [ + result[molecule_key] for result in system_results if np.isnan( result["dg_uncertainty"].magnitude @@ -131,16 +160,22 @@ def build_femap_from_absolute_results( else result["estimate_error"].magnitude ) ] - if solutes_no_uncertainty: + if molecules_no_uncertainty: raise ValueError( - f"Not all solutes have dg_uncertainty for {system_group} {system_name}: {solutes_no_uncertainty}" + f"Not all {molecule_key}s have uncertainty for {system_group} {system_name}: {molecules_no_uncertainty}" ) femap = FEMap() for result in system_results: value_key = "dg" if "dg" in result else "estimate" err_key = "dg_uncertainty" if value_key == "dg" else "estimate_error" - label = f"{result['solute']},{result['solvent']}" + + # Build label based on format + if has_solvent: + label = f"{result[molecule_key]},{result['solvent']}" + else: + label = result[molecule_key] + femap.add_absolute_calculation( label=label, value=result[value_key], @@ -148,26 +183,45 @@ def build_femap_from_absolute_results( source="Computational", ) - # add experimental solvation data for each of the solutes in the results - experimental_file = benchmark_data.reference_data[ + # Add experimental data if available + # For ASFE: experimental solvation free energy data + # For RBFE: experimental binding free energy data (if available) + experimental_key = ( "experimental_solvation_free_energy_data" - ] - experimental_data = json.load(open(experimental_file), cls=JSON_HANDLER.decoder) - n_experimental_points = 0 - for result in system_results: - label = f"{result['solute']},{result['solvent']}" - exp_data = experimental_data.get(label, None) - if exp_data is not None: - femap.add_experimental_measurement( - label=label, - value=exp_data["dg"], - uncertainty=exp_data.get( - "uncertainty", 0 * unit.kilocalories_per_mole - ), + if calculation_type == "asfe" + else "experimental_binding_free_energy_data" + ) + + if experimental_key in benchmark_data.reference_data: + experimental_file = benchmark_data.reference_data[experimental_key] + experimental_data = json.load( + open(experimental_file), cls=JSON_HANDLER.decoder + ) + n_experimental_points = 0 + + for result in system_results: + # Build label to match experimental data format + if has_solvent: + label = f"{result[molecule_key]},{result['solvent']}" + else: + label = result[molecule_key] + + exp_data = experimental_data.get(label, None) + if exp_data is not None: + femap.add_experimental_measurement( + label=label, + value=exp_data["dg"], + uncertainty=exp_data.get( + "uncertainty", 0 * unit.kilocalories_per_mole + ), + ) + n_experimental_points += 1 + + if n_experimental_points == 0 and calculation_type == "asfe": + # Only raise error for ASFE where experimental data is expected + raise ValueError( + "No experimental data points were found for ASFE submission" ) - n_experimental_points += 1 - if n_experimental_points == 0: - raise ValueError("No experimental data points were found") femaps_by_system_key[system_key] = femap diff --git a/openfe_benchmarks/tests/test_benchmark_results.py b/openfe_benchmarks/tests/test_benchmark_results.py index 711665b1..2aca4e1a 100644 --- a/openfe_benchmarks/tests/test_benchmark_results.py +++ b/openfe_benchmarks/tests/test_benchmark_results.py @@ -15,7 +15,8 @@ from cinnabar import FEMap -from openfe_benchmarks.results import BenchmarkResults, filter_results +from openfe_benchmarks.results import get_benchmark_results, filter_results +import openfe_benchmarks.results._benchmark_results as br_module # Test data submission IDs @@ -23,12 +24,106 @@ ASFE_SUBMISSION = "2026-08-06-openff-2.3.0-solvation_set_freesolv" +# ========== Fixtures ========== + + +@pytest.fixture +def mock_submission_yaml(): + """ + Factory fixture to create complete mock submission YAML data. + + Returns a function that generates a valid submission.yaml dict + with all required fields, allowing custom overrides. + """ + + def _make_yaml(submission_id="test-submission", **overrides): + """ + Generate a complete submission.yaml dict. + + Parameters + ---------- + submission_id : str + Submission ID for the test + **overrides : dict + Any fields to override from the defaults + + Returns + ------- + dict + Complete submission.yaml dictionary + """ + yaml_data = { + "submission_id": submission_id, + "title": "Test Submission", + "summary": "Test summary", + "calculation_type": "rbfe", + "tags": ["test"], + "authors": [{"name": "Test Author"}], + "date": "2026-01-01", + "results": "results.json", + "archive": {"doi": "10.1234/test", "archive_provider": "test"}, + "license": "MIT", + "openfe_version": "1.0.0", + "openmm_version": "8.0.0", + "openff_toolkit_version": "0.10.0", + "partial_charges": "am1bcc", + "benchmark_data": {}, + "protocol_settings": [], + } + yaml_data.update(overrides) + return yaml_data + + return _make_yaml + + +@pytest.fixture +def create_test_submission(tmp_path, monkeypatch, mock_submission_yaml): + """ + Factory fixture to create test submission directories with YAML files. + + Automatically patches _RESULTS_DIR and creates the directory structure. + """ + monkeypatch.setattr(br_module, "_RESULTS_DIR", tmp_path) + + def _create(submission_id, yaml_data=None, **yaml_overrides): + """ + Create a test submission directory with submission.yaml. + + Parameters + ---------- + submission_id : str + Submission ID for the test + yaml_data : dict, optional + Complete YAML data dict. If None, uses mock_submission_yaml factory + **yaml_overrides : dict + Fields to override in the default YAML (only used if yaml_data is None) + + Returns + ------- + Path + Path to the submission directory + """ + submission_dir = tmp_path / submission_id + submission_dir.mkdir() + + if yaml_data is None: + yaml_data = mock_submission_yaml(submission_id, **yaml_overrides) + + yaml_file = submission_dir / "submission.yaml" + with open(yaml_file, "w") as f: + yaml.dump(yaml_data, f) + + return submission_dir + + return _create + + # ========== Loading Tests ========== def test_load_by_submission_id(): """Test loading by submission_id with full data loading.""" - result = BenchmarkResults(RBFE_SUBMISSION) + result = get_benchmark_results(RBFE_SUBMISSION) # Verify attributes assert result.submission_id == RBFE_SUBMISSION @@ -36,7 +131,6 @@ def test_load_by_submission_id(): assert result.calculation_type == "rbfe" assert isinstance(result.tags, list) assert "rbfe" in result.tags - assert isinstance(result.metadata, dict) assert result.raw_results is not None assert isinstance(result.raw_results, dict) assert result.results_file.exists() @@ -46,7 +140,7 @@ def test_load_by_submission_id(): def test_load_yaml_only_fast(): """Test fast YAML-only loading (load_results=False).""" start = time.time() - result = BenchmarkResults(RBFE_SUBMISSION, load_results=False) + result = get_benchmark_results(RBFE_SUBMISSION, load_results=False) elapsed = time.time() - start # Verify YAML metadata loaded @@ -58,8 +152,9 @@ def test_load_yaml_only_fast(): # Verify raw_results is None assert result.raw_results is None - # Verify fast loading (<1s) - assert elapsed < 1.0, f"Fast load too slow: {elapsed:.3f}s (should be <1s)" + # Verify fast loading (generous threshold for slow CI systems) + # Most systems should complete in <0.5s, but allow up to 2s for loaded CI + assert elapsed < 2.0, f"Fast load too slow: {elapsed:.3f}s (should be <2s)" # ========== Raw Results Structure Tests ========== @@ -67,7 +162,7 @@ def test_load_yaml_only_fast(): def test_raw_results_structure(): """Test that raw_results has expected structure with dg/ddg keys.""" - result = BenchmarkResults(RBFE_SUBMISSION) + result = get_benchmark_results(RBFE_SUBMISSION) # Verify keys assert "dg" in result.raw_results or "ddg" in result.raw_results @@ -92,7 +187,7 @@ def test_raw_results_structure(): def test_filter_by_tags(): """Test filtering by exact tag match.""" - result = BenchmarkResults(RBFE_SUBMISSION) + result = get_benchmark_results(RBFE_SUBMISSION) filtered = filter_results(result, tags="rbfe") assert len(filtered) > 0 @@ -102,7 +197,7 @@ def test_filter_by_tags(): def test_filter_by_multiple_tags_and(): """Test filtering by multiple tags with AND logic (default).""" - result = BenchmarkResults(RBFE_SUBMISSION) + result = get_benchmark_results(RBFE_SUBMISSION) # Use tags that should exist in the submission filtered = filter_results(result, tags=["rbfe", "jacs_set"]) @@ -117,7 +212,7 @@ def test_filter_by_multiple_tags_and(): def test_filter_by_multiple_tags_or(): """Test filtering by multiple tags with OR logic.""" - result = BenchmarkResults(RBFE_SUBMISSION) + result = get_benchmark_results(RBFE_SUBMISSION) # Use tags_mode='any' for OR logic filtered = filter_results(result, tags=["rbfe", "asfe"], tags_mode="any") @@ -129,7 +224,7 @@ def test_filter_by_multiple_tags_or(): def test_filter_by_system(): """Test filtering by system_group and system_name.""" - result = BenchmarkResults(RBFE_SUBMISSION) + result = get_benchmark_results(RBFE_SUBMISSION) filtered = filter_results(result, system_group="jacs_set", system_name="tyk2") assert len(filtered) > 0 @@ -140,30 +235,33 @@ def test_filter_by_system(): def test_filter_by_nested_field(): - """Test filtering by nested field using __ syntax.""" - result = BenchmarkResults(RBFE_SUBMISSION) + """ + Test filtering by nested field using __ syntax. - # Note: Current test data doesn't have nested dicts within individual results. - # Nested field filtering (using __) works for result-level nested fields, - # but test data only has flat result dicts. - # This test verifies the mechanism doesn't crash with __ syntax. + Note: Current test data doesn't have nested dicts within individual results, + so this test verifies that the nested field filtering mechanism works correctly + when the field doesn't exist (should return empty list). + """ + result = get_benchmark_results(RBFE_SUBMISSION) - # Test that nested field syntax doesn't crash - # Using a hypothetical nested field that doesn't exist + # Test that nested field syntax doesn't crash when field doesn't exist + # Using a hypothetical nested field that doesn't exist in current test data filtered = filter_results(result, hypothetical__nested__field="value") # Should return empty list (field doesn't exist) assert isinstance(filtered, list) - assert len(filtered) == 0 + assert len(filtered) == 0, ( + "Filtering by non-existent nested field should return empty list" + ) # Verify regular filtering still works filtered_normal = filter_results(result, system_group="jacs_set") - assert len(filtered_normal) > 0 + assert len(filtered_normal) > 0, "Regular filtering should still work" def test_filter_with_wildcard(): """Test filtering with wildcard pattern matching.""" - result = BenchmarkResults(RBFE_SUBMISSION) + result = get_benchmark_results(RBFE_SUBMISSION) filtered = filter_results(result, system_name="*tyk2*") assert len(filtered) > 0 @@ -174,7 +272,7 @@ def test_filter_with_wildcard(): def test_filter_or_logic(): """Test OR logic within a field using list values.""" - result = BenchmarkResults(RBFE_SUBMISSION) + result = get_benchmark_results(RBFE_SUBMISSION) filtered = filter_results(result, system_name=["tyk2", "p38"]) assert len(filtered) > 0 @@ -185,7 +283,7 @@ def test_filter_or_logic(): def test_filter_not_logic(): """Test NOT logic using exclude_ prefix.""" - result = BenchmarkResults(RBFE_SUBMISSION) + result = get_benchmark_results(RBFE_SUBMISSION) # Test 1: Filter for jacs_set but exclude tyk2 system filtered = filter_results( @@ -207,9 +305,9 @@ def test_filter_not_logic(): def test_filter_complex_logic(): """Test complex filtering combining tags AND + system OR + exclude.""" - result = BenchmarkResults(RBFE_SUBMISSION) + result = get_benchmark_results(RBFE_SUBMISSION) - # Complex filter: tags AND + system OR + exclude (as per plan) + # Complex filter: tags AND + system OR + exclude filtered = filter_results( result, tags=["rbfe", "jacs_set"], @@ -224,15 +322,29 @@ def test_filter_complex_logic(): assert "rbfe" in result.tags assert "jacs_set" in result.tags - # Verify system_name matches one of the specified values (if results exist) + # Verify filtering worked correctly if len(filtered) > 0: for r in filtered: - assert r["system_name"] in ["tyk2", "p38"] + # Must match one of the system names (OR logic within field) + assert r["system_name"] in ["tyk2", "p38"], ( + f"Expected system_name in ['tyk2', 'p38'], got {r['system_name']}" + ) + + # Must NOT have 'deprecated' tag (exclude logic) + # Tags are at result level if they exist in the result dict + if "tags" in r: + assert "deprecated" not in r["tags"], ( + f"Result should not have 'deprecated' tag but found it in {r.get('tags')}" + ) + else: + # If no results, ensure the filter criteria could be met + # (i.e., the submission has the required tags) + assert "rbfe" in result.tags and "jacs_set" in result.tags def test_filter_multi_and_logic(): """Test multiple predicates with AND logic between fields.""" - result = BenchmarkResults(RBFE_SUBMISSION) + result = get_benchmark_results(RBFE_SUBMISSION) filtered = filter_results(result, system_group="jacs_set", calculation_type="rbfe") # Should return results matching both predicates @@ -249,7 +361,7 @@ def test_filter_multi_and_logic(): def test_ddg_femaps_lazy_load(): """Test ddg_femaps property with lazy loading and caching.""" - result = BenchmarkResults(RBFE_SUBMISSION) + result = get_benchmark_results(RBFE_SUBMISSION) # First access - should compute femaps_first = result.ddg_femaps @@ -274,7 +386,7 @@ def test_ddg_femaps_lazy_load(): def test_dg_femaps(): """Test dg_femaps property with ASFE results.""" - result = BenchmarkResults(ASFE_SUBMISSION) + result = get_benchmark_results(ASFE_SUBMISSION) # Access dg_femaps femaps = result.dg_femaps @@ -300,89 +412,81 @@ def test_missing_submission_id(): """Test error when submission_id does not exist.""" submission_id = "nonexistent-submission" with pytest.raises(FileNotFoundError) as excinfo: - BenchmarkResults(submission_id) + get_benchmark_results(submission_id) assert str(excinfo.value) == f"Submission not found: {submission_id}" -def test_missing_results_file(tmp_path): +def test_missing_results_file(create_test_submission): """Test error when results file referenced in YAML does not exist.""" - # Create a mock submission directory with YAML but no results file submission_id = "test-missing-results" - submission_dir = tmp_path / submission_id - submission_dir.mkdir() - - yaml_data = { - "submission_id": submission_id, - "title": "Test Missing Results", - "calculation_type": "rbfe", - "tags": ["test"], - "results": "nonexistent_results.json", - } - - yaml_file = submission_dir / "submission.yaml" - with open(yaml_file, "w") as f: - yaml.dump(yaml_data, f) + create_test_submission( + submission_id, title="Test Missing Results", results="nonexistent_results.json" + ) # Try to load with load_results=True with pytest.raises(FileNotFoundError) as excinfo: - BenchmarkResults(submission_id, load_results=True, results_dir=tmp_path) + get_benchmark_results(submission_id, load_results=True) assert "Results file not found" in str(excinfo.value) -def test_invalid_submission_yaml(tmp_path): +def test_invalid_submission_yaml(create_test_submission): """Test error when submission.yaml is missing required fields.""" - # Create a mock submission directory with incomplete YAML submission_id = "test-invalid-yaml" - submission_dir = tmp_path / submission_id - submission_dir.mkdir() - # Missing 'title' and 'calculation_type' fields + # Create YAML with only submission_id and tags (missing many required fields) yaml_data = { "submission_id": submission_id, "tags": ["test"], } - - yaml_file = submission_dir / "submission.yaml" - with open(yaml_file, "w") as f: - yaml.dump(yaml_data, f) + create_test_submission(submission_id, yaml_data=yaml_data) with pytest.raises(ValueError) as excinfo: - BenchmarkResults(submission_id, results_dir=tmp_path, load_results=False) + get_benchmark_results(submission_id, load_results=False) - assert "missing required fields" in str(excinfo.value) + # Should raise ValueError for a missing required field + assert "missing required field" in str(excinfo.value) -def test_submission_id_mismatch(tmp_path): +def test_submission_id_mismatch(create_test_submission, mock_submission_yaml): """Test error when submission_id in YAML doesn't match directory name.""" - # Create a mock submission directory submission_id = "test-mismatch" - submission_dir = tmp_path / submission_id - submission_dir.mkdir() - - # YAML has different submission_id - yaml_data = { - "submission_id": "different-id", - "title": "Test Mismatch", - "calculation_type": "rbfe", - "tags": ["test"], - "results": "results.json", - } - yaml_file = submission_dir / "submission.yaml" - with open(yaml_file, "w") as f: - yaml.dump(yaml_data, f) + # Create YAML with different submission_id (different from directory name) + yaml_data = mock_submission_yaml("different-id", title="Test Mismatch") + create_test_submission(submission_id, yaml_data=yaml_data) with pytest.raises(ValueError) as excinfo: - BenchmarkResults(submission_id, results_dir=tmp_path, load_results=False) + get_benchmark_results(submission_id, load_results=False) assert "submission_id mismatch" in str(excinfo.value) +def test_unknown_fields_in_yaml(create_test_submission): + """Test error when submission.yaml contains unknown fields.""" + submission_id = "test-unknown-fields" + + # Create complete YAML with extra unknown fields + create_test_submission( + submission_id, + title="Test Unknown Fields", + unknown_field="this should not be here", + another_unknown="also unexpected", + ) + + with pytest.raises(ValueError) as excinfo: + get_benchmark_results(submission_id, load_results=False) + + assert "Unknown fields" in str(excinfo.value) + assert "unknown_field" in str(excinfo.value) or "another_unknown" in str( + excinfo.value + ) + + def test_filter_on_fast_loaded_results(): """Test that filtering raises error when raw_results is None.""" - result = BenchmarkResults(RBFE_SUBMISSION, load_results=False) + result = get_benchmark_results(RBFE_SUBMISSION, load_results=False) with pytest.raises(ValueError) as excinfo: filter_results(result, tags="rbfe") @@ -396,7 +500,7 @@ def test_filter_on_fast_loaded_results(): def test_femaps_on_fast_loaded_results(): """Test that accessing FEMaps raises error when raw_results is None.""" - result = BenchmarkResults(RBFE_SUBMISSION, load_results=False) + result = get_benchmark_results(RBFE_SUBMISSION, load_results=False) with pytest.raises(ValueError) as excinfo: _ = result.ddg_femaps @@ -406,3 +510,259 @@ def test_femaps_on_fast_loaded_results(): "Initialize with load_results=True to access computational data." ) assert str(excinfo.value) == expected_msg + + +# ========== Comparison Operator Tests ========== + + +def test_filter_date_greater_than_or_equal(): + """Test date filtering with >= operator.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Filter for dates >= 2026-03-01 + filtered = filter_results(result, date=">=2026-03-01") + + # Should include results (submission date is after 2026-03-01) + assert len(filtered) > 0 + # Convert date to string for comparison + assert result.date.isoformat() >= "2026-03-01" + + +def test_filter_date_less_than(): + """Test date filtering with < operator.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Filter for dates < 2027-01-01 + filtered = filter_results(result, date="<2027-01-01") + + # Should include results (submission date is before 2027) + assert len(filtered) > 0 + assert result.date.isoformat() < "2027-01-01" + + +def test_filter_date_range(): + """Test date filtering with range (combining two filters).""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Filter for dates in 2026 (>= 2026-01-01 AND < 2027-01-01) + # Note: This requires applying both filters, but current API doesn't support + # multiple operators on same field, so we test separately + filtered_after = filter_results(result, date=">=2026-01-01") + filtered_before = filter_results(result, date="<2027-01-01") + + # Both should return results + assert len(filtered_after) > 0 + assert len(filtered_before) > 0 + + +def test_filter_version_less_than(): + """Test version filtering with < operator using semantic versioning.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Get the actual version from the submission + actual_version = result.openfe_version + + # Filter for versions < actual_version + 1 (should include all) + major, minor, *rest = actual_version.split(".") + next_version = f"{int(major) + 1}.0.0" + filtered = filter_results(result, openfe_version=f"<{next_version}") + + # Should include results + assert len(filtered) > 0 + + +def test_filter_version_greater_than_or_equal(): + """Test version filtering with >= operator using semantic versioning.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Filter for versions >= 1.0.0 (should include most versions) + filtered = filter_results(result, openfe_version=">=1.0.0") + + # Should include results (openfe_version is likely >= 1.0.0) + assert isinstance(filtered, list) + + +def test_filter_version_semantic_comparison(): + """Test that version comparison uses semantic versioning, not string comparison.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Semantic: 1.10.0 > 1.9.0 + # String: "1.10.0" < "1.9.0" (would be wrong) + + # Just verify filtering works without error + filtered_gte = filter_results(result, openfe_version=">=1.0.0") + filtered_lt = filter_results(result, openfe_version="<99.0.0") + + assert isinstance(filtered_gte, list) + assert isinstance(filtered_lt, list) + + +def test_filter_comparison_with_other_filters(): + """Test comparison operators combined with other filter types.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Combine date comparison with system filter + filtered = filter_results(result, date=">=2026-01-01", system_group="jacs_set") + + # Should return results matching both conditions + assert isinstance(filtered, list) + if len(filtered) > 0: + for r in filtered: + assert r["system_group"] == "jacs_set" + # Date is metadata-level, checked via isoformat + assert result.date.isoformat() >= "2026-01-01" + + +def test_filter_comparison_no_operator(): + """Test that values without operators still work as exact match.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Date without operator should be exact match + exact_date = result.date + filtered = filter_results(result, date=exact_date) + + # Should return all results (exact match on metadata) + assert len(filtered) > 0 + + +def test_filter_comparison_exclude_with_operator(): + """Test that exclude_ prefix works with comparison operators.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Exclude dates before 2026 + filtered = filter_results(result, exclude_date="<2026-01-01") + + # Should return results (submission date is after 2026-01-01, so not excluded) + assert len(filtered) > 0 + assert result.date.isoformat() >= "2026-01-01" + + +def test_filter_comparison_openmm_version(): + """Test comparison on openmm_version field.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Filter for OpenMM >= 8.0.0 + filtered = filter_results(result, openmm_version=">=8.0.0") + + # Should return results if openmm_version >= 8.0.0 + assert isinstance(filtered, list) + + +def test_filter_comparison_openff_toolkit_version(): + """Test comparison on openff_toolkit_version field.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Filter for OpenFF Toolkit >= 0.10.0 + filtered = filter_results(result, openff_toolkit_version=">=0.10.0") + + # Should return results if version matches + assert isinstance(filtered, list) + + +def test_filter_comparison_warning_non_version_field(): + """Test that warning is issued when comparison operators used with non-date/version fields.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Using comparison operator with system_name (not a date/version field) should warn + with pytest.warns( + UserWarning, + match="Comparison operator.*system_name.*designed for date and version fields", + ): + filtered = filter_results(result, system_name=">=tyk2") + + # Still returns results (falls back to string comparison) + assert isinstance(filtered, list) + + +def test_filter_quantity_comparison_greater_than(): + """Test filtering on pint Quantity fields with > operator.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Filter results where dg > 1.0 kcal/mol + # dg values are Quantity objects deserialized from JSON + filtered = filter_results(result, dg=">1.0 kilocalories_per_mole") + + assert isinstance(filtered, list) + assert len(filtered) > 0 + + # Verify all results have dg > 1.0 kcal/mol + for r in filtered: + assert r["dg"].magnitude > 1.0 + + +def test_filter_quantity_comparison_less_than_or_equal(): + """Test filtering on pint Quantity fields with <= operator.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Filter results where dg <= 2.0 kcal/mol + filtered = filter_results(result, dg="<=2.0 kilocalories_per_mole") + + assert isinstance(filtered, list) + assert len(filtered) > 0 + + # Verify all results have dg <= 2.0 kcal/mol + for r in filtered: + assert r["dg"].magnitude <= 2.0 + + +def test_filter_quantity_comparison_unit_conversion(): + """Test that pint Quantity comparison handles unit conversion automatically.""" + + result = get_benchmark_results(RBFE_SUBMISSION) + + # Filter with different but compatible units + # 1 kcal/mol ≈ 4.184 kJ/mol + filtered_kcal = filter_results(result, dg=">1.0 kilocalories_per_mole") + filtered_kj = filter_results(result, dg=">4.184 kilojoules_per_mole") + + # Should get the same results (or very close due to floating point) + assert ( + len(filtered_kcal) == len(filtered_kj) + or abs(len(filtered_kcal) - len(filtered_kj)) <= 1 + ) + + +def test_filter_quantity_comparison_range(): + """Test filtering on pint Quantity with range (testing both filters separately).""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Filter for dg >= 0.5 kcal/mol + filtered_gte = filter_results(result, dg=">=0.5 kilocalories_per_mole") + + # Filter for dg <= 2.0 kcal/mol + filtered_lte = filter_results(result, dg="<=2.0 kilocalories_per_mole") + + assert isinstance(filtered_gte, list) + assert isinstance(filtered_lte, list) + assert len(filtered_gte) > 0 + assert len(filtered_lte) > 0 + + # Verify ranges + for r in filtered_gte: + assert r["dg"].magnitude >= 0.5 + + for r in filtered_lte: + assert r["dg"].magnitude <= 2.0 + + +def test_filter_quantity_incompatible_units_fallback(): + """Test that incompatible units fall back to string comparison.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Try to compare energy (kcal/mol) with temperature (K) - dimensionally incompatible + # Should fall back to string comparison without error + filtered = filter_results(result, dg=">298 kelvin") + + # Should not raise an error, but may return unexpected results (string comparison) + assert isinstance(filtered, list) + + +def test_filter_quantity_invalid_string_fallback(): + """Test that invalid quantity strings fall back to string comparison.""" + result = get_benchmark_results(RBFE_SUBMISSION) + + # Use a string that can't be parsed as a quantity + filtered = filter_results(result, dg=">not_a_quantity") + + # Should fall back to string comparison without error + assert isinstance(filtered, list) diff --git a/openfe_benchmarks/tests/test_results_validation.py b/openfe_benchmarks/tests/test_results_validation.py new file mode 100644 index 00000000..eccdf608 --- /dev/null +++ b/openfe_benchmarks/tests/test_results_validation.py @@ -0,0 +1,508 @@ +""" +Tests for CI-optimized validation helpers. + +Validates fast YAML-only validation, git-aware changed file detection, +random sampling with calculation_type coverage, and hybrid CI workflow timing. + +Target: <6 min CI time for 100 submissions with 10% changed. +""" + +import time +from unittest.mock import patch + +from openfe_benchmarks.results._validation import ( + validate_submission_yaml_fast, + get_all_submission_ids, + get_changed_submission_ids, + select_random_sample, +) +from openfe_benchmarks.results import get_benchmark_results +from openfe_benchmarks.results._benchmark_results import _RESULTS_DIR + + +def test_fast_yaml_validation_all(): + """ + Test fast YAML-only validation for all submissions. + + Success criteria: + - All submissions validate without errors + - Validation completes within reasonable time per submission + """ + # Get all real submission_ids from results directory + all_ids = get_all_submission_ids() + + assert len(all_ids) > 0, "Expected at least one submission in results directory" + + print(f"\n{'=' * 60}") + print(f"Fast YAML Validation: {len(all_ids)} submissions") + print(f"{'=' * 60}") + + invalid_submissions = [] + + for submission_id in all_ids: + yaml_path = _RESULTS_DIR / submission_id / "submission.yaml" + result = validate_submission_yaml_fast(yaml_path) + + status = "✓" if result["valid"] else "✗" + print(f" {status} {submission_id}") + + if not result["valid"]: + invalid_submissions.append((submission_id, result["errors"])) + print(f" Errors: {result['errors']}") + + # Assert all submissions are valid + if invalid_submissions: + error_msg = f"\n{len(invalid_submissions)} invalid submission(s) found:\n" + for submission_id, errors in invalid_submissions: + error_msg += f"\n {submission_id}:\n" + for error in errors: + error_msg += f" - {error}\n" + assert False, error_msg + + +def test_fast_yaml_validation_performance(): + """ + Test performance of YAML validation. + + Success criteria: + - Individual submissions validate in reasonable time (<5s each) + - Average time per submission is tracked for regression detection + """ + all_ids = get_all_submission_ids() + + assert len(all_ids) > 0, "Expected at least one submission" + + print(f"\n{'=' * 60}") + print(f"YAML Validation Performance: {len(all_ids)} submissions") + print(f"{'=' * 60}") + + total_start = time.time() + timings = [] + + for submission_id in all_ids: + yaml_path = _RESULTS_DIR / submission_id / "submission.yaml" + + start = time.time() + _ = validate_submission_yaml_fast(yaml_path) + elapsed = time.time() - start + + timings.append(elapsed) + print(f" {submission_id}: {elapsed:.3f}s") + + # Warn if validation is slow (>1s) but only fail if extremely slow (>5s) + if elapsed > 1.0: + print(f" WARNING: Slower than target 1.0s (actual: {elapsed:.3f}s)") + + assert elapsed < 5.0, ( + f"YAML validation extremely slow for {submission_id}: {elapsed:.3f}s " + f"(failing threshold: 5s, target: 1s)" + ) + + total_elapsed = time.time() - total_start + avg_time = sum(timings) / len(timings) + max_time = max(timings) + + print(f"\n{'=' * 60}") + print("Performance Summary:") + print(f" Total time: {total_elapsed:.3f}s") + print(f" Average per submission: {avg_time:.3f}s") + print(f" Max per submission: {max_time:.3f}s") + print(f"{'=' * 60}\n") + + +def test_fast_yaml_validation_scaling(): + """ + Test that YAML validation scales acceptably for large submission sets. + + Success criteria: + - Extrapolated time for 100 submissions is reasonable (<500s) + """ + all_ids = get_all_submission_ids() + + assert len(all_ids) > 0, "Expected at least one submission" + + # Quick timing sample + timings = [] + for submission_id in all_ids: + yaml_path = _RESULTS_DIR / submission_id / "submission.yaml" + start = time.time() + _ = validate_submission_yaml_fast(yaml_path) + elapsed = time.time() - start + timings.append(elapsed) + + avg_time = sum(timings) / len(timings) + extrapolated_100 = avg_time * 100 + + print(f"\n{'=' * 60}") + print("Scaling Analysis:") + print(f" Current submissions: {len(all_ids)}") + print(f" Average time: {avg_time:.3f}s") + print(f" Extrapolated for 100: {extrapolated_100:.1f}s") + print(" Target: <100s, Failing threshold: <500s") + print(f"{'=' * 60}\n") + + # Use 5x tolerance for CI variability (target 100s, fail at 500s) + if extrapolated_100 > 100: + print( + f" INFO: Extrapolated time ({extrapolated_100:.1f}s) exceeds target of 100s" + ) + + assert extrapolated_100 < 500, ( + f"Fast validation would take {extrapolated_100:.1f}s for 100 submissions " + f"(failing threshold: 500s, target: 100s)" + ) + + +def test_changed_files_detection(): + """ + Test git diff-based changed submission detection. + + Success criteria: + - Correctly extracts submission_ids from git diff output + - Handles both submission.yaml and computational_results.json changes + - Returns empty list gracefully when git unavailable + """ + # Mock git diff output + mock_git_output = """results/2026-03-18-openmm-840-qa-testing/submission.yaml +results/2026-03-18-openmm-840-qa-testing/computational_results.json.bz2 +results/2026-08-06-openff-2.3.0-solvation_set_freesolv/submission.yaml +openfe_benchmarks/data/something_else.py +""" + + # Mock subprocess.run to return our test data + with patch("openfe_benchmarks.results._validation.subprocess.run") as mock_run: + mock_run.return_value.stdout = mock_git_output + mock_run.return_value.returncode = 0 + + changed_ids = get_changed_submission_ids(base_branch="origin/main") + + # Verify correct submission_ids extracted + assert "2026-03-18-openmm-840-qa-testing" in changed_ids + assert "2026-08-06-openff-2.3.0-solvation_set_freesolv" in changed_ids + assert len(changed_ids) == 2 + + # Verify git command called correctly + mock_run.assert_called_once() + call_args = mock_run.call_args[0][0] + assert call_args == ["git", "diff", "--name-only", "origin/main...HEAD"] + + # Test graceful failure when git not available + with patch("openfe_benchmarks.results._validation.subprocess.run") as mock_run: + mock_run.side_effect = FileNotFoundError("git not found") + + changed_ids = get_changed_submission_ids() + assert changed_ids == [] + + +def test_random_sampling_reproducibility(): + """ + Test reproducibility of random sampling with seeds. + + Success criteria: + - Same seed produces identical samples + - Different seeds produce different samples (when sampling is truly random) + """ + all_ids = get_all_submission_ids() + + # Filter to only valid submissions + valid_ids = [] + for submission_id in all_ids: + yaml_path = _RESULTS_DIR / submission_id / "submission.yaml" + result = validate_submission_yaml_fast(yaml_path) + if result["valid"]: + valid_ids.append(submission_id) + + assert len(valid_ids) >= 2, ( + f"Need at least 2 valid submissions, found {len(valid_ids)}" + ) + + # Test 10% sampling reproducibility + sample1 = select_random_sample(valid_ids, sample_rate=0.1, seed=42) + sample2 = select_random_sample(valid_ids, sample_rate=0.1, seed=42) + sample3 = select_random_sample(valid_ids, sample_rate=0.1, seed=99) + + print(f"\n{'=' * 60}") + print("Random Sampling Reproducibility Test") + print(f"{'=' * 60}") + print(f"Total submissions: {len(all_ids)}") + print(f"Valid submissions: {len(valid_ids)}") + print(f"Sample 1 (seed=42): {sample1}") + print(f"Sample 2 (seed=42): {sample2}") + print(f"Sample 3 (seed=99): {sample3}") + print(f"{'=' * 60}\n") + + # Verify reproducibility with same seed + assert sample1 == sample2, "Same seed should produce identical samples" + + # Count calculation types to determine if sampling is deterministic + calc_types = set() + for submission_id in valid_ids: + benchmark = get_benchmark_results(submission_id, load_results=False) + calc_types.add(benchmark.calculation_type) + + n_types = len(calc_types) + target_count = max(int(len(valid_ids) * 0.1), n_types) + + # Only expect different samples if target_count > n_types (true random sampling occurs) + if target_count > n_types: + assert sample1 != sample3 or len(sample1) == 1, ( + "Different seeds should usually produce different samples when target > n_types" + ) + else: + print( + f"Note: Deterministic sampling (target={target_count} == n_types={n_types})" + ) + + +def test_random_sampling_coverage(): + """ + Test that random sampling provides calculation_type coverage. + + Success criteria: + - Sample size is appropriate (at least 1 per calc_type or 10% of valid_ids) + - All calculation_types are represented when multiple types exist + """ + all_ids = get_all_submission_ids() + + # Filter to only valid submissions + valid_ids = [] + for submission_id in all_ids: + yaml_path = _RESULTS_DIR / submission_id / "submission.yaml" + result = validate_submission_yaml_fast(yaml_path) + if result["valid"]: + valid_ids.append(submission_id) + + assert len(valid_ids) >= 2, ( + f"Need at least 2 valid submissions, found {len(valid_ids)}" + ) + + # Get sample + sample = select_random_sample(valid_ids, sample_rate=0.1, seed=42) + + # Count calculation types + calc_types = set() + for submission_id in valid_ids: + benchmark = get_benchmark_results(submission_id, load_results=False) + calc_types.add(benchmark.calculation_type) + + calc_types_in_sample = set() + for submission_id in sample: + benchmark = get_benchmark_results(submission_id, load_results=False) + calc_types_in_sample.add(benchmark.calculation_type) + + print(f"\n{'=' * 60}") + print("Random Sampling Coverage Test") + print(f"{'=' * 60}") + print(f"Total valid submissions: {len(valid_ids)}") + print(f"Sample size (10%): {len(sample)}") + print(f"Calculation types in valid: {sorted(calc_types)}") + print(f"Calculation types in sample: {sorted(calc_types_in_sample)}") + print(f"{'=' * 60}\n") + + # Verify sample size + n_types = len(calc_types) + target_count = max(int(len(valid_ids) * 0.1), n_types) + expected_min = max(1, int(target_count * 0.8)) + expected_max = int(target_count * 1.2) + 1 + + assert expected_min <= len(sample) <= expected_max, ( + f"Sample size {len(sample)} not in expected range [{expected_min}, {expected_max}] " + f"(target: {target_count}, n_types: {n_types})" + ) + + # Verify calculation_type coverage (at least one per type if multiple types exist) + if n_types > 1: + assert len(calc_types_in_sample) >= min(len(sample), n_types), ( + f"Expected coverage of calculation_types, got {calc_types_in_sample}" + ) + + +def test_deep_validation_changed_only(): + """ + Test deep validation (YAML+JSON+FEMap) for changed files only. + + Success criteria: + - Deep validation completes in <5s per submission + - Loads full BenchmarkResults with FEMaps + - Timing reported for regression tracking + """ + + all_ids = get_all_submission_ids() + + # Filter to only valid submissions (YAML validation passes) + valid_ids = [] + for submission_id in all_ids: + yaml_path = _RESULTS_DIR / submission_id / "submission.yaml" + result = validate_submission_yaml_fast(yaml_path) + if result["valid"]: + valid_ids.append(submission_id) + + # Select a few submissions for deep validation (simulate changed files) + test_ids = valid_ids[: min(2, len(valid_ids))] + + assert len(test_ids) > 0, ( + "Need at least one valid submission for deep validation test" + ) + + print(f"\n{'=' * 60}") + print(f"Deep Validation: {len(test_ids)} submissions") + print(f"{'=' * 60}") + + timings = [] + + for submission_id in test_ids: + start = time.time() + + # Full load: YAML + JSON + FEMap generation + result = get_benchmark_results(submission_id, load_results=True) + + # Access FEMaps to trigger generation + _ = result.ddg_femaps + _ = result.dg_femaps + + elapsed = time.time() - start + timings.append(elapsed) + + print(f" {submission_id}: {elapsed:.3f}s") + + # Warn if slow but only fail if extremely slow + if elapsed > 5.0: + print(f" WARNING: Slower than target 5.0s (actual: {elapsed:.3f}s)") + + assert elapsed < 25.0, ( + f"Deep validation extremely slow for {submission_id}: {elapsed:.3f}s " + f"(failing threshold: 25s, target: 5s)" + ) + + avg_time = sum(timings) / len(timings) if timings else 0 + + print(f"\n{'=' * 60}") + print("Summary:") + print(f" Average per submission: {avg_time:.3f}s") + print(f" Extrapolated for 10 changed: {avg_time * 10:.1f}s") + print(f"{'=' * 60}\n") + + +def test_ci_hybrid_workflow(): + """ + Integration test simulating CI build with hybrid validation strategy. + + Success criteria: + - Fast validation for all submissions + - Deep validation for changed submissions only + - Random 10% sample for FEMap validation + - Total time <30s for 8 submissions (extrapolates to <200s for 100) + - Timing breakdown reported + + Note: Uses only valid submissions for deep validation phases. + """ + + all_ids = get_all_submission_ids() + + # Use real data (typically 8 submissions as of 2026-08-18) + assert len(all_ids) >= 1, "Need at least 1 submission for CI workflow test" + + print(f"\n{'=' * 60}") + print("CI Hybrid Workflow Simulation") + print(f"{'=' * 60}") + print(f"Total submissions: {len(all_ids)}") + + workflow_start = time.time() + + # Phase 1: Fast YAML validation for ALL submissions + print(f"\nPhase 1: Fast YAML validation (all {len(all_ids)} submissions)") + fast_start = time.time() + + valid_ids = [] + for submission_id in all_ids: + yaml_path = _RESULTS_DIR / submission_id / "submission.yaml" + result = validate_submission_yaml_fast(yaml_path) + if result["valid"]: + valid_ids.append(submission_id) + else: + print(f" Skipping invalid submission {submission_id} for deep validation") + + fast_elapsed = time.time() - fast_start + print(f" Completed in {fast_elapsed:.3f}s") + print(f" Valid submissions for deep validation: {len(valid_ids)}/{len(all_ids)}") + + # Phase 2: Deep validation for CHANGED submissions (mock 1 changed) + # In real CI, this would use get_changed_submission_ids() + changed_ids = valid_ids[: min(1, len(valid_ids))] + + print( + f"\nPhase 2: Deep validation (changed files only: {len(changed_ids)} submissions)" + ) + deep_start = time.time() + + for submission_id in changed_ids: + result = get_benchmark_results(submission_id, load_results=True) + _ = result.ddg_femaps + _ = result.dg_femaps + + deep_elapsed = time.time() - deep_start + print(f" Completed in {deep_elapsed:.3f}s") + + # Phase 3: Random 10% sample for FEMap validation (only from valid submissions) + sample_ids = select_random_sample(valid_ids, sample_rate=0.1, seed=42) + # Exclude already-validated changed submissions to avoid double-counting + sample_ids = [sid for sid in sample_ids if sid not in changed_ids] + + print(f"\nPhase 3: Random sample validation (10%: {len(sample_ids)} submissions)") + sample_start = time.time() + + for submission_id in sample_ids: + result = get_benchmark_results(submission_id, load_results=True) + _ = result.ddg_femaps + _ = result.dg_femaps + + sample_elapsed = time.time() - sample_start + print(f" Completed in {sample_elapsed:.3f}s") + + # Calculate total workflow time + workflow_elapsed = time.time() - workflow_start + + print(f"\n{'=' * 60}") + print("Timing Breakdown:") + print( + f" Phase 1 (fast all): {fast_elapsed:6.3f}s ({fast_elapsed / workflow_elapsed * 100:5.1f}%)" + ) + print( + f" Phase 2 (deep changed): {deep_elapsed:6.3f}s ({deep_elapsed / workflow_elapsed * 100:5.1f}%)" + ) + print( + f" Phase 3 (random sample): {sample_elapsed:6.3f}s ({sample_elapsed / workflow_elapsed * 100:5.1f}%)" + ) + print(f" {'─' * 40}") + print(f" Total workflow time: {workflow_elapsed:6.3f}s") + print(f"{'=' * 60}") + + # Extrapolate to 100 submissions with 10% changed + # Scale fast validation linearly + fast_100 = fast_elapsed * (100 / len(all_ids)) + # Assume 10 changed (10% of 100) + deep_100 = deep_elapsed * (10 / max(len(changed_ids), 1)) + # Assume 10 in sample (10% of 100) + sample_100 = sample_elapsed * (10 / max(len(sample_ids), 1)) + total_100 = fast_100 + deep_100 + sample_100 + + print("\nExtrapolated for 100 submissions (10% changed):") + print(f" Phase 1 (fast all): {fast_100:6.1f}s") + print(f" Phase 2 (deep changed): {deep_100:6.1f}s") + print(f" Phase 3 (random sample): {sample_100:6.1f}s") + print(f" {'─' * 40}") + print(f" Total: {total_100:6.1f}s ({total_100 / 60:.1f} min)") + print(" Target: <360s (<6 min)") + print(f"{'=' * 60}\n") + + # Assert total time for current test data is reasonable + # For 8 submissions: <30s target (relaxed to allow for deep validation) + max_time = 30.0 if len(all_ids) <= 8 else 30.0 * (len(all_ids) / 8) + assert workflow_elapsed < max_time, ( + f"CI workflow too slow: {workflow_elapsed:.1f}s (target: <{max_time:.1f}s)" + ) + + # Assert extrapolated time meets target + assert total_100 < 360, ( + f"Extrapolated CI time {total_100:.1f}s exceeds 6 min target" + ) From 116a4dc829011872190223e5fd00a466a1cf3c03 Mon Sep 17 00:00:00 2001 From: Jennifer A Clark Date: Wed, 19 Aug 2026 08:04:00 -0400 Subject: [PATCH 05/11] Apply suggestions from code review Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- openfe_benchmarks/results/_benchmark_results.py | 6 ++++++ openfe_benchmarks/results/_validation.py | 16 ++++++++++++---- openfe_benchmarks/scripts/_results_utils.py | 5 ++--- .../tests/test_results_validation.py | 6 +++--- 4 files changed, 23 insertions(+), 10 deletions(-) diff --git a/openfe_benchmarks/results/_benchmark_results.py b/openfe_benchmarks/results/_benchmark_results.py index c543b8f3..fabb658d 100644 --- a/openfe_benchmarks/results/_benchmark_results.py +++ b/openfe_benchmarks/results/_benchmark_results.py @@ -649,6 +649,12 @@ def _get_nested_value(result: dict, nested_key: str) -> Optional[Any]: for key in keys: if isinstance(value, dict): value = value.get(key, None) + elif isinstance(value, list): + # Support list-of-dicts nesting (e.g. protocol_settings is a list of dicts) + value = [item.get(key, None) for item in value if isinstance(item, dict)] + value = [v for v in value if v is not None] + if not value: + return None else: return None return value diff --git a/openfe_benchmarks/results/_validation.py b/openfe_benchmarks/results/_validation.py index 5dc639ca..e68d4bdd 100644 --- a/openfe_benchmarks/results/_validation.py +++ b/openfe_benchmarks/results/_validation.py @@ -166,10 +166,18 @@ def get_changed_submission_ids(base_branch: str = "origin/main") -> list[str]: # Match patterns like: results/SUBMISSION_ID/submission.yaml # or results/SUBMISSION_ID/computational_results.json parts = Path(file_path).parts - if len(parts) >= 2 and parts[0] == "results": - # Check if it's a submission.yaml or results file - if "submission.yaml" in parts or "computational_results" in parts[-1]: - submission_ids.add(parts[1]) + + submission_id = None + if len(parts) >= 3 and parts[0] == "openfe_benchmarks" and parts[1] == "results": + submission_id = parts[2] + elif len(parts) >= 2 and parts[0] == "results": + submission_id = parts[1] + + if submission_id is None: + continue + + if parts[-1] == "submission.yaml" or "computational_results" in parts[-1]: + submission_ids.add(submission_id) return sorted(list(submission_ids)) diff --git a/openfe_benchmarks/scripts/_results_utils.py b/openfe_benchmarks/scripts/_results_utils.py index 7dedd02f..a1035d63 100644 --- a/openfe_benchmarks/scripts/_results_utils.py +++ b/openfe_benchmarks/scripts/_results_utils.py @@ -194,9 +194,8 @@ def build_femap_from_absolute_results( if experimental_key in benchmark_data.reference_data: experimental_file = benchmark_data.reference_data[experimental_key] - experimental_data = json.load( - open(experimental_file), cls=JSON_HANDLER.decoder - ) + with open(experimental_file, "r") as f: + experimental_data = json.load(f, cls=JSON_HANDLER.decoder) n_experimental_points = 0 for result in system_results: diff --git a/openfe_benchmarks/tests/test_results_validation.py b/openfe_benchmarks/tests/test_results_validation.py index eccdf608..3e82da50 100644 --- a/openfe_benchmarks/tests/test_results_validation.py +++ b/openfe_benchmarks/tests/test_results_validation.py @@ -163,9 +163,9 @@ def test_changed_files_detection(): - Returns empty list gracefully when git unavailable """ # Mock git diff output - mock_git_output = """results/2026-03-18-openmm-840-qa-testing/submission.yaml -results/2026-03-18-openmm-840-qa-testing/computational_results.json.bz2 -results/2026-08-06-openff-2.3.0-solvation_set_freesolv/submission.yaml + mock_git_output = """openfe_benchmarks/results/2026-03-18-openmm-840-qa-testing/submission.yaml +openfe_benchmarks/results/2026-03-18-openmm-840-qa-testing/computational_results.json.bz2 +openfe_benchmarks/results/2026-08-06-openff-2.3.0-solvation_set_freesolv/submission.yaml openfe_benchmarks/data/something_else.py """ From 94fc96e9759812bcf2371c837f83f5dc6b35ea32 Mon Sep 17 00:00:00 2001 From: jaclark5 Date: Wed, 19 Aug 2026 08:34:47 -0400 Subject: [PATCH 06/11] Update PR template --- .../results_submission.md | 34 +++++++++++++++++-- 1 file changed, 32 insertions(+), 2 deletions(-) diff --git a/.github/PULL_REQUEST_TEMPLATE/results_submission.md b/.github/PULL_REQUEST_TEMPLATE/results_submission.md index 43b19e6f..0d67e83b 100644 --- a/.github/PULL_REQUEST_TEMPLATE/results_submission.md +++ b/.github/PULL_REQUEST_TEMPLATE/results_submission.md @@ -1,4 +1,34 @@ -# Results Submission Template +# Pull Request Template: Benchmark Results Submission ## Description -[Provide a description of the changes being made.] \ No newline at end of file +[Provide a brief description of this benchmark submission, including what systems were calculated and any notable features] + +## Required Files Checklist + +Please ensure the following files are present in your submission directory: + +- [ ] **`submission.yaml`**: Complete metadata file with all required fields using `openfe_benchmarks/scripts/prepare_metadata_submission.py` +- [ ] **`computational_results.json.bz2`**: Compressed results file using `openfe_benchmarks/scripts/generate_results_archives.py` +- [ ] **Archive DOI**: Results uploaded to long-term archive (Zenodo, etc.) with DOI included in submission.yaml + +## Validation Checklist + +- [ ] **YAML validation**: `submission.yaml` is valid YAML and loads without errors +- [ ] **ID consistency**: `submission_id` in YAML matches directory name +- [ ] **Results file exists**: Compressed results file exists at path specified in `results` field +- [ ] **Archive accessible**: DOI resolves and archive is publicly accessible +- [ ] **Network keys valid**: AlchemicalNetwork keys in `benchmark_data` are valid +- [ ] **Calculation type valid**: Type matches actual calculations performed +- [ ] **No duplicate submission_id**: This submission_id is unique in the repository + +## Testing + +- [ ] CI validation checks pass + +## Additional Notes + +[Any additional context, special considerations, or notes about this submission] + +--- + +Thank you for contributing to the OpenFE Benchmarks! \ No newline at end of file From 3277dcd9d81b687ef3ee02af88dbf2ef089775b9 Mon Sep 17 00:00:00 2001 From: jaclark5 Date: Wed, 19 Aug 2026 09:01:29 -0400 Subject: [PATCH 07/11] Resolve review issues --- .../results/_benchmark_results.py | 29 +++++--- openfe_benchmarks/results/_validation.py | 32 ++++++--- openfe_benchmarks/scripts/_results_utils.py | 9 +-- .../tests/test_benchmark_results.py | 21 +++--- .../tests/test_results_validation.py | 67 +++++++++++++++++-- 5 files changed, 115 insertions(+), 43 deletions(-) diff --git a/openfe_benchmarks/results/_benchmark_results.py b/openfe_benchmarks/results/_benchmark_results.py index fabb658d..745a1ace 100644 --- a/openfe_benchmarks/results/_benchmark_results.py +++ b/openfe_benchmarks/results/_benchmark_results.py @@ -874,6 +874,12 @@ def _compare_values( bool True if comparison succeeds, False otherwise + Raises + ------ + ValueError + If a Quantity comparison is requested with an invalid quantity string, + unsupported filter type, or incompatible dimensions. + Examples -------- >>> _compare_values('2026-01-15', '2026-01-01', '>=', 'date') @@ -947,13 +953,15 @@ def _compare_values( ureg = result_value._REGISTRY filter_val = ureg.Quantity(filter_val) except (ValueError, pint.errors.UndefinedUnitError, AttributeError): - # If parsing fails, convert both to strings for comparison - result_value = str(result_value) - filter_val = str(filter_val) + raise ValueError( + f"Invalid quantity filter value '{filter_val}' for field '{field_name}'. " + "Provide a valid quantity string with units." + ) elif not isinstance(filter_val, pint.Quantity): - # If filter_val is not a string or Quantity, convert both to strings - result_value = str(result_value) - filter_val = str(filter_val) + raise ValueError( + f"Invalid filter type '{type(filter_val).__name__}' for Quantity field '{field_name}'. " + "Provide a quantity string or pint.Quantity value." + ) # Compare Quantities (pint handles unit conversion automatically) try: @@ -967,11 +975,10 @@ def _compare_values( return result_value >= filter_val else: raise ValueError(f"Unknown comparison operator: {operator}") - except (pint.errors.DimensionalityError, ValueError): - # Units are incompatible (e.g., comparing temperature to pressure) - # or different registries - fall back to string comparison - result_value = str(result_value) - filter_val = str(filter_val) + except pint.errors.DimensionalityError as e: + raise ValueError( + f"Incompatible units for Quantity comparison on field '{field_name}': {e}" + ) from e # Try semantic version comparison (for version fields) try: diff --git a/openfe_benchmarks/results/_validation.py b/openfe_benchmarks/results/_validation.py index e68d4bdd..12500981 100644 --- a/openfe_benchmarks/results/_validation.py +++ b/openfe_benchmarks/results/_validation.py @@ -19,11 +19,10 @@ def validate_submission_yaml_fast(yaml_path: Path) -> dict: """ - Fast YAML-only validation using get_benchmark_results(load_results=False). + Fast YAML-only validation for canonical submissions. Validates by attempting to construct BenchmarkResults object without - loading JSON data or generating FEMaps. Delegates validation to the - actual factory function that will be used. + loading JSON data or generating FEMaps, using get_benchmark_results(). Parameters ---------- @@ -63,10 +62,19 @@ def validate_submission_yaml_fast(yaml_path: Path) -> dict: result["errors"].append(f"File not found: {yaml_path}") return result - # Extract submission_id from path + # Extract submission_id from path and enforce canonical location to avoid + # silently validating a different file with the same submission_id. submission_id = yaml_path.parent.name + canonical_yaml_path = (_RESULTS_DIR / submission_id / "submission.yaml").resolve() + if yaml_path.resolve() != canonical_yaml_path: + result["valid"] = False + result["errors"].append( + "Non-canonical submission path. Expected " + f"{canonical_yaml_path}, got {yaml_path.resolve()}" + ) + return result - # Attempt to construct BenchmarkResults without loading data + # Attempt to construct BenchmarkResults without loading data. try: benchmark = get_benchmark_results( submission_id=submission_id, load_results=False @@ -158,7 +166,7 @@ def get_changed_submission_ids(base_branch: str = "origin/main") -> list[str]: check=True, ) - changed_files = result.stdout.strip().split("\n") + changed_files = [line for line in result.stdout.splitlines() if line.strip()] # Extract submission_ids from changed results paths submission_ids = set() @@ -168,7 +176,11 @@ def get_changed_submission_ids(base_branch: str = "origin/main") -> list[str]: parts = Path(file_path).parts submission_id = None - if len(parts) >= 3 and parts[0] == "openfe_benchmarks" and parts[1] == "results": + if ( + len(parts) >= 3 + and parts[0] == "openfe_benchmarks" + and parts[1] == "results" + ): submission_id = parts[2] elif len(parts) >= 2 and parts[0] == "results": submission_id = parts[1] @@ -176,7 +188,11 @@ def get_changed_submission_ids(base_branch: str = "origin/main") -> list[str]: if submission_id is None: continue - if parts[-1] == "submission.yaml" or "computational_results" in parts[-1]: + if not parts: + continue + + filename = parts[-1] + if filename == "submission.yaml" or "computational_results" in filename: submission_ids.add(submission_id) return sorted(list(submission_ids)) diff --git a/openfe_benchmarks/scripts/_results_utils.py b/openfe_benchmarks/scripts/_results_utils.py index a1035d63..cb11e35f 100644 --- a/openfe_benchmarks/scripts/_results_utils.py +++ b/openfe_benchmarks/scripts/_results_utils.py @@ -39,10 +39,10 @@ def build_femap_from_relative_results( results_by_system_key[key].append(result) femaps_by_system_key = {} - unique_ligands = set() for system_key, system_results in results_by_system_key.items(): system_group, system_name = system_key benchmark_data = get_benchmark_data_system(system_group, system_name) + unique_ligands = set() # Check if all edges have valid ddg_uncertainty (not NaN) edges_no_uncertainty = [ @@ -70,7 +70,8 @@ def build_femap_from_relative_results( # add experimental data for each of the ligands in the results experimental_file = benchmark_data.reference_data["experimental_binding_data"] - experimental_data = json.load(open(experimental_file), cls=JSON_HANDLER.decoder) + with open(experimental_file, "r") as f: + experimental_data = json.load(f, cls=JSON_HANDLER.decoder) for ligand in unique_ligands: exp_data = experimental_data.get(ligand, None) @@ -185,11 +186,11 @@ def build_femap_from_absolute_results( # Add experimental data if available # For ASFE: experimental solvation free energy data - # For RBFE: experimental binding free energy data (if available) + # For RBFE: experimental binding data experimental_key = ( "experimental_solvation_free_energy_data" if calculation_type == "asfe" - else "experimental_binding_free_energy_data" + else "experimental_binding_data" ) if experimental_key in benchmark_data.reference_data: diff --git a/openfe_benchmarks/tests/test_benchmark_results.py b/openfe_benchmarks/tests/test_benchmark_results.py index 2aca4e1a..fe7e6eeb 100644 --- a/openfe_benchmarks/tests/test_benchmark_results.py +++ b/openfe_benchmarks/tests/test_benchmark_results.py @@ -745,24 +745,19 @@ def test_filter_quantity_comparison_range(): assert r["dg"].magnitude <= 2.0 -def test_filter_quantity_incompatible_units_fallback(): - """Test that incompatible units fall back to string comparison.""" +def test_filter_quantity_incompatible_units_raises(): + """Test that incompatible units raise ValueError (no silent fallback).""" result = get_benchmark_results(RBFE_SUBMISSION) # Try to compare energy (kcal/mol) with temperature (K) - dimensionally incompatible - # Should fall back to string comparison without error - filtered = filter_results(result, dg=">298 kelvin") - - # Should not raise an error, but may return unexpected results (string comparison) - assert isinstance(filtered, list) + with pytest.raises(ValueError, match="Incompatible units"): + _ = filter_results(result, dg=">298 kelvin") -def test_filter_quantity_invalid_string_fallback(): - """Test that invalid quantity strings fall back to string comparison.""" +def test_filter_quantity_invalid_string_raises(): + """Test that invalid quantity strings raise ValueError (no silent fallback).""" result = get_benchmark_results(RBFE_SUBMISSION) # Use a string that can't be parsed as a quantity - filtered = filter_results(result, dg=">not_a_quantity") - - # Should fall back to string comparison without error - assert isinstance(filtered, list) + with pytest.raises(ValueError, match="Invalid quantity filter value"): + _ = filter_results(result, dg=">not_a_quantity") diff --git a/openfe_benchmarks/tests/test_results_validation.py b/openfe_benchmarks/tests/test_results_validation.py index 3e82da50..e7d6d429 100644 --- a/openfe_benchmarks/tests/test_results_validation.py +++ b/openfe_benchmarks/tests/test_results_validation.py @@ -9,6 +9,7 @@ import time from unittest.mock import patch +import yaml from openfe_benchmarks.results._validation import ( validate_submission_yaml_fast, @@ -20,6 +21,61 @@ from openfe_benchmarks.results._benchmark_results import _RESULTS_DIR +def _trigger_available_femaps(benchmark_result): + """Load only FEMap types that exist in raw_results for this submission.""" + loaded_any = False + + if "ddg" in benchmark_result.raw_results: + _ = benchmark_result.ddg_femaps + loaded_any = True + + if "dg" in benchmark_result.raw_results: + _ = benchmark_result.dg_femaps + loaded_any = True + + assert loaded_any, ( + f"Expected at least one of 'dg' or 'ddg' in raw_results for " + f"{benchmark_result.submission_id}, found keys: " + f"{list(benchmark_result.raw_results.keys())}" + ) + + +def test_fast_yaml_validation_rejects_noncanonical_path(tmp_path): + """Test that validate_submission_yaml_fast rejects non-canonical YAML paths.""" + submission_id = "standalone-submission" + submission_dir = tmp_path / submission_id + submission_dir.mkdir(parents=True, exist_ok=True) + yaml_path = submission_dir / "submission.yaml" + + yaml_data = { + "submission_id": submission_id, + "title": "Standalone Test Submission", + "summary": "Validate explicit path handling", + "calculation_type": "rbfe", + "tags": ["test"], + "authors": [{"name": "Test Author"}], + "date": "2026-01-01", + "results": "results.json", + "archive": {"doi": "10.1234/test", "archive_provider": "test"}, + "license": "MIT", + "openfe_version": "1.0.0", + "openmm_version": "8.0.0", + "openff_toolkit_version": "0.10.0", + "partial_charges": "am1bcc", + "benchmark_data": {}, + "protocol_settings": [], + } + with open(yaml_path, "w") as f: + yaml.dump(yaml_data, f) + + result = validate_submission_yaml_fast(yaml_path) + + assert result["valid"] is False + assert result["submission_id"] is None + assert result["calculation_type"] is None + assert any("Non-canonical submission path" in err for err in result["errors"]) + + def test_fast_yaml_validation_all(): """ Test fast YAML-only validation for all submissions. @@ -356,9 +412,8 @@ def test_deep_validation_changed_only(): # Full load: YAML + JSON + FEMap generation result = get_benchmark_results(submission_id, load_results=True) - # Access FEMaps to trigger generation - _ = result.ddg_femaps - _ = result.dg_femaps + # Access available FEMaps to trigger generation. + _trigger_available_femaps(result) elapsed = time.time() - start timings.append(elapsed) @@ -437,8 +492,7 @@ def test_ci_hybrid_workflow(): for submission_id in changed_ids: result = get_benchmark_results(submission_id, load_results=True) - _ = result.ddg_femaps - _ = result.dg_femaps + _trigger_available_femaps(result) deep_elapsed = time.time() - deep_start print(f" Completed in {deep_elapsed:.3f}s") @@ -453,8 +507,7 @@ def test_ci_hybrid_workflow(): for submission_id in sample_ids: result = get_benchmark_results(submission_id, load_results=True) - _ = result.ddg_femaps - _ = result.dg_femaps + _trigger_available_femaps(result) sample_elapsed = time.time() - sample_start print(f" Completed in {sample_elapsed:.3f}s") From 88db1fb67ebe8e40ccb82bfebafa3d635d27ff3f Mon Sep 17 00:00:00 2001 From: jaclark5 Date: Wed, 19 Aug 2026 13:32:18 -0400 Subject: [PATCH 08/11] Fix filtering --- .gitignore | 1 + examples/4_benchmark_result_plot.ipynb | 714 +++++++----------- .../results/_benchmark_results.py | 244 +++--- .../tests/test_benchmark_results.py | 386 ++++------ 4 files changed, 557 insertions(+), 788 deletions(-) diff --git a/.gitignore b/.gitignore index 1b77cf28..c38b7a8f 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,7 @@ __pycache__/ **/zenodo_description.md # Test dir openfe_benchmarks/scripts/outputs/* +examples/outputs/* # C extensions *.so diff --git a/examples/4_benchmark_result_plot.ipynb b/examples/4_benchmark_result_plot.ipynb index dc383f6f..59d2b734 100644 --- a/examples/4_benchmark_result_plot.ipynb +++ b/examples/4_benchmark_result_plot.ipynb @@ -2,523 +2,380 @@ "cells": [ { "cell_type": "markdown", - "id": "6444fc8c", + "id": "ce1ae864", "metadata": {}, "source": [ - "# BenchmarkResults: Loading, Filtering, and Plotting Results\n", + "# BenchmarkResults Filtering Workflow (Production-Oriented)\n", "\n", - "This notebook demonstrates the `BenchmarkResults` class for loading and filtering computational free energy results.\n", + "This notebook demonstrates the updated `filter_results` behavior:\n", "\n", - "Key features:\n", - "- Load results with `get_benchmark_results()`\n", - "- Filter by tags, systems, and metadata\n", - "- Use comparison operators with pint Quantities (e.g., `dg='>1.0 kilocalories_per_mole'`)\n", - "- Generate FEMaps with lazy `.dg_femaps` and `.ddg_femaps` properties\n", - "- Plot predicted vs experimental values with cinnabar" - ] - }, - { - "cell_type": "markdown", - "id": "18e21df2", - "metadata": {}, - "source": [ - "## Setup" + "- Filtering is **global across all submissions** in `openfe_benchmarks/results`.\n", + "- Return values are `BenchmarkResults` objects for matching submissions.\n", + "- Entry-level filters (for `dg`/`ddg`) still work, but selection happens at submission level.\n", + "\n", + "The workflow below uses practical checks that are useful for CI and analysis pipelines, with assertions that fail fast when behavior changes." ] }, { "cell_type": "code", "execution_count": 1, - "id": "5208611b", + "id": "11fae922", "metadata": {}, "outputs": [], "source": [ - "from openfe_benchmarks.results import get_benchmark_results, filter_results\n", + "from pathlib import Path\n", + "\n", "from cinnabar import plotting\n", - "import matplotlib.pyplot as plt\n", "\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "markdown", - "id": "850481d7", - "metadata": {}, - "source": [ - "## Load a Submission\n", + "from openfe_benchmarks.results._benchmark_results import filter_results\n", + "\n", + "\n", + "def submission_ids(items):\n", + " return {item.submission_id for item in items}\n", + "\n", "\n", - "We'll load an RBFE submission using the `get_benchmark_results()` factory function." + "def flatten(items):\n", + " for item in items:\n", + " if isinstance(item, list):\n", + " yield from flatten(item)\n", + " else:\n", + " yield item\n", + "\n", + "\n", + "def get_nested(obj, path):\n", + " value = obj\n", + " for part in path.split(\"__\"):\n", + " if isinstance(value, dict):\n", + " value = value.get(part)\n", + " elif isinstance(value, list):\n", + " next_values = []\n", + " for entry in value:\n", + " if isinstance(entry, dict):\n", + " nested = entry.get(part)\n", + " else:\n", + " nested = getattr(entry, part, None)\n", + " if nested is not None:\n", + " next_values.append(nested)\n", + " value = next_values if next_values else None\n", + " else:\n", + " value = getattr(value, part, None)\n", + " if value is None:\n", + " return None\n", + " return value" ] }, { "cell_type": "code", "execution_count": 2, - "id": "330933e1", + "id": "ac74c674", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "BenchmarkResults(submission_id='2026-03-18-openmm-840-qa-testing', calculation_type='rbfe')\n" + "Total submissions discovered: 8\n", + "Sample IDs:\n", + " 2026-02-12_sage_230_jacs_set\n", + " 2026-03-18-openmm-840-qa-testing\n", + " 2026-06-22-tyk2-alchemicalarchive-test\n", + " 2026-08-04-openff3.0.0-alpha1b_opc3-jacs\n", + " 2026-08-05-openff3.0.0-alpha1b_tip3p-jacs\n", + " 2026-08-06-openff-2.3.0-solvation_set_freesolv\n", + " 2026_08_05_ff14sb_openff-3.0.0-alpha1b_tip3p_jacs_tyk2_thrombin\n", + " 2026_08_05_openff-3.0.0-alpha0_opc3_jacs\n" ] } ], "source": [ - "# Load results\n", - "results = get_benchmark_results(\"2026-03-18-openmm-840-qa-testing\")\n", - "print(results)" + "all_submissions = filter_results(load_results=False)\n", + "\n", + "print(f\"Total submissions discovered: {len(all_submissions)}\")\n", + "print(\"Sample IDs:\\n \", \"\\n \".join(sorted(submission_ids(all_submissions))))\n", + "\n", + "assert all_submissions, \"Expected at least one submission in results directory\"\n", + "assert all(hasattr(r, \"submission_id\") for r in all_submissions)" ] }, { "cell_type": "markdown", - "id": "24ae15e8", + "id": "409c741a", "metadata": {}, "source": [ - "## Explore Metadata" + "## 1) Production Metadata Filtering\n", + "\n", + "These are fast, metadata-only queries (`load_results=False`) suitable for dashboards, CI checks, and release reports." ] }, { "cell_type": "code", "execution_count": 3, - "id": "c7f91ae8", + "id": "78b4d820", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Submission ID: 2026-03-18-openmm-840-qa-testing\n", - "Title: OpenFE RBFE - Multi-set Benchmark (2 sets, 5 systems) - 2026-03-18-openmm-840-qa-testing\n", - "Calculation Type: rbfe\n", - "Tags: rbfe, ff14SB, phosaa10, tip3p_HFE_multivalent, tip3p_standard, charge_annihilation_set, egfr, irak4_s2, irak4_s3, jacs_set, p38, tyk2, nagl_openff-gnn-am1bcc-1.0.0.pt, charge_change, benchmark, openfe, openmm-840\n", - "Date: 2026-06-19\n", - "OpenFE Version: 1.9.1\n", - "Force field: ['ff14SB', 'phosaa10', 'tip3p_HFE_multivalent', 'tip3p_standard']\n" + "RBFE submissions: 7\n", + "Submissions since 2026-01-01: 8\n", + "Non-pontibus submissions: 7\n" ] } ], "source": [ - "print(f\"Submission ID: {results.submission_id}\")\n", - "print(f\"Title: {results.title}\")\n", - "print(f\"Calculation Type: {results.calculation_type}\")\n", - "print(f\"Tags: {', '.join(results.tags)}\")\n", - "print(f\"Date: {results.date}\")\n", - "print(f\"OpenFE Version: {results.openfe_version}\")\n", - "print(f\"Force field: {results.forcefield}\")" - ] - }, - { - "cell_type": "markdown", - "id": "508165b5", - "metadata": {}, - "source": [ - "## Raw Results Structure\n", + "rbfe_submissions = filter_results(calculation_type=\"rbfe\", load_results=False)\n", + "recent_submissions = filter_results(date=\">=2026-01-01\", load_results=False)\n", + "non_test_submissions = filter_results(\n", + " exclude_tags=[\"pontibus\"], tags_mode=\"all\", load_results=False\n", + ")\n", "\n", - "The `raw_results` attribute contains the computational data as nested dictionaries." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "d04552fe", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Raw results keys: ['dg', 'ddg']\n", - "\n", - "Number of dg results: 56\n", - "Number of ddg results: 80\n", - "\n", - "Sample ddg result keys: ['ligand_a', 'ligand_b', 'system_group', 'system_name', 'ddg', 'ddg_uncertainty', 'dgs_complex', 'dgs_solvent', 'complex_smallest_mbar_overlaps', 'complex_smallest_replica_mixing', 'solvent_smallest_mbar_overlaps', 'solvent_smallest_replica_mixing']\n", - "System: jacs_set/tyk2\n", - "Ligand pair: None -> None\n", - "DDG: -0.31190011815882457 kilocalories_per_mole\n" - ] - } - ], - "source": [ - "print(f\"Raw results keys: {list(results.raw_results.keys())}\")\n", - "print(f\"\\nNumber of dg results: {len(results.raw_results.get('dg', []))}\")\n", - "print(f\"Number of ddg results: {len(results.raw_results.get('ddg', []))}\")\n", - "\n", - "# Show structure of one ddg result\n", - "if \"ddg\" in results.raw_results and results.raw_results[\"ddg\"]:\n", - " sample_result = results.raw_results[\"ddg\"][0]\n", - " print(f\"\\nSample ddg result keys: {list(sample_result.keys())}\")\n", - " print(\n", - " f\"System: {sample_result.get('system_group')}/{sample_result.get('system_name')}\"\n", - " )\n", - " print(\n", - " f\"Ligand pair: {sample_result.get('ligand_i_name')} -> {sample_result.get('ligand_j_name')}\"\n", - " )\n", - " print(f\"DDG: {sample_result.get('ddg')}\")" - ] - }, - { - "cell_type": "markdown", - "id": "4aa17fa8", - "metadata": {}, - "source": [ - "## Filtering Examples\n", + "print(f\"RBFE submissions: {len(rbfe_submissions)}\")\n", + "print(f\"Submissions since 2026-01-01: {len(recent_submissions)}\")\n", + "print(f\"Non-pontibus submissions: {len(non_test_submissions)}\")\n", "\n", - "The `filter_results()` function supports various filtering operations." - ] - }, - { - "cell_type": "markdown", - "id": "01065142", - "metadata": {}, - "source": [ - "### Filter by Tag (Single)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "12ac31bc", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Results with 'rbfe' tag: 136\n" - ] - } - ], - "source": [ - "rbfe_results = filter_results(results, tags=\"rbfe\")\n", - "print(f\"Results with 'rbfe' tag: {len(rbfe_results)}\")" + "assert len(rbfe_submissions) <= len(all_submissions)\n", + "assert len(recent_submissions) <= len(all_submissions)\n", + "assert len(non_test_submissions) <= len(all_submissions)" ] }, { "cell_type": "markdown", - "id": "b5c8c46e", + "id": "c83f91bc", "metadata": {}, "source": [ - "### Filter by Multiple Tags (AND logic, default)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "7bc5fe2f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Results with BOTH 'rbfe' AND 'openfe' tags: 136\n" - ] - } - ], - "source": [ - "# Must have ALL specified tags\n", - "validated_results = filter_results(results, tags=[\"rbfe\", \"openfe\"])\n", - "print(f\"Results with BOTH 'rbfe' AND 'openfe' tags: {len(validated_results)}\")" - ] - }, - { - "cell_type": "markdown", - "id": "343f87bc", - "metadata": {}, - "source": [ - "### Filter by Multiple Tags (OR logic)" + "## 2) Entry-Level Filtering, Submission-Level Return\n", + "\n", + "These queries inspect `dg`/`ddg` entries but return whole `BenchmarkResults` submissions. This is useful in production when downstream steps need both metadata and raw result context." ] }, { "cell_type": "code", - "execution_count": 7, - "id": "4687cb56", + "execution_count": 4, + "id": "02a7305c", "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Results with 'rbfe' OR 'asfe' tag: 136\n" + "2026-08-19 13:20:41 - openfe_benchmarks.results._benchmark_results - WARNING - Skipping submission '2026-08-04-openff3.0.0-alpha1b_opc3-jacs' during filtering: Results file not found: /Users/jenniferclark/bin/openfe-benchmarks/openfe_benchmarks/results/2026-08-04-openff3.0.0-alpha1b_opc3-jacs/computational_results.json\n" ] - } - ], - "source": [ - "# Must have ANY of the specified tags\n", - "any_calc_results = filter_results(results, tags=[\"rbfe\", \"asfe\"], tags_mode=\"any\")\n", - "print(f\"Results with 'rbfe' OR 'asfe' tag: {len(any_calc_results)}\")" - ] - }, - { - "cell_type": "markdown", - "id": "4a52b7ec", - "metadata": {}, - "source": [ - "### Filter by System Group" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "9177a58f", - "metadata": {}, - "outputs": [ + }, { "name": "stdout", "output_type": "stream", "text": [ - "Results from jacs_set: 123\n" + "Submissions containing tyk2-like system names: 6\n", + "Example IDs: ['2026-02-12_sage_230_jacs_set', '2026-03-18-openmm-840-qa-testing', '2026-06-22-tyk2-alchemicalarchive-test', '2026-08-05-openff3.0.0-alpha1b_tip3p-jacs', '2026_08_05_ff14sb_openff-3.0.0-alpha1b_tip3p_jacs_tyk2_thrombin']\n" ] } ], "source": [ - "jacs_results = filter_results(results, system_group=\"jacs_set\")\n", - "print(f\"Results from jacs_set: {len(jacs_results)}\")" + "tyk2_related = filter_results(system_name=\"tyk2\", load_results=True)\n", + "\n", + "print(f\"Submissions containing tyk2-like system names: {len(tyk2_related)}\")\n", + "print(\"Example IDs:\", sorted(submission_ids(tyk2_related))[:5])\n", + "\n", + "assert isinstance(tyk2_related, list)\n", + "assert all(hasattr(r, \"raw_results\") for r in tyk2_related)" ] }, { "cell_type": "markdown", - "id": "7a9dcb4f", + "id": "46864545", "metadata": {}, "source": [ - "### Filter with Wildcard" + "## 3) Double-Underscore Filtering Demonstration\n", + "\n", + "- A query with a real nested value returns submissions that actually exist.\n", + "- A query with an impossible nested value returns no submissions.\n", + "\n", + "This is the production behavior you want when building search/reporting workflows." ] }, { "cell_type": "code", - "execution_count": 9, - "id": "3430e389", + "execution_count": 14, + "id": "935728ac", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Results with 'tyk2' in system name: 38\n" + "Nested key used: protocol_settings__protocol\n", + "Existing value: RelativeHybridTopologyProtocol\n", + "Existing-value matches: 4\n", + "Sample matched IDs: ['2026-02-12_sage_230_jacs_set', '2026-03-18-openmm-840-qa-testing', '2026-06-22-tyk2-alchemicalarchive-test', '2026_08_05_ff14sb_openff-3.0.0-alpha1b_tip3p_jacs_tyk2_thrombin']\n", + "Impossible-value matches: 0\n" ] } ], "source": [ - "tyk2_results = filter_results(results, system_name=\"*tyk2*\")\n", - "print(f\"Results with 'tyk2' in system name: {len(tyk2_results)}\")" + "# Positive case: concrete nested value that should exist.\n", + "chosen_key = \"protocol_settings__protocol\"\n", + "chosen_value = \"RelativeHybridTopologyProtocol\"\n", + "positive_result = filter_results(load_results=False, **{chosen_key: chosen_value})\n", + "positive_ids = submission_ids(positive_result)\n", + "\n", + "# Negative case: concrete nested value that should not exist.\n", + "negative_result = filter_results(\n", + " load_results=False, protocol_settings__protocol=\"ProtocolThatDoesNotExist\"\n", + ")\n", + "negative_ids = submission_ids(negative_result)\n", + "\n", + "print(f\"Nested key used: {chosen_key}\")\n", + "print(f\"Existing value: {chosen_value}\")\n", + "print(f\"Existing-value matches: {len(positive_ids)}\")\n", + "print(\"Sample matched IDs:\", sorted(positive_ids)[:5])\n", + "print(f\"Impossible-value matches: {len(negative_ids)}\")\n", + "\n", + "assert len(positive_ids) > 0, \"Expected nested query to return existing submissions\"\n", + "assert len(negative_ids) == 0, (\n", + " \"Expected impossible nested query to return no submissions\"\n", + ")" ] }, { "cell_type": "markdown", - "id": "013ad50c", + "id": "9c9fec33", "metadata": {}, "source": [ - "### Filter with OR Logic (List Values for Non-Tags)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "c4d0da8f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Results from tyk2 OR thrombin: 38\n" - ] - } - ], - "source": [ - "# Match if system_name is tyk2 OR thrombin\n", - "multi_system = filter_results(results, system_name=[\"tyk2\", \"thrombin\"])\n", - "print(f\"Results from tyk2 OR thrombin: {len(multi_system)}\")" + "## 4) DG/DDG to Cinnabar Plot Demonstration\n", + "\n", + "These examples show how filtered submissions feed directly into cinnabar plotting:\n", + "\n", + "- DG plotting from ASFE submissions via `results.dg_femaps` and `plotting.plot_DGs`\n", + "- DDG plotting from RBFE submissions via `results.ddg_femaps` and `plotting.plot_DDGs`\n", + "\n", + "Plots are written to a local `outputs/` directory." ] }, { "cell_type": "markdown", - "id": "94184e5f", + "id": "66bb14a1", "metadata": {}, "source": [ - "### Filter with NOT Logic (exclude_ prefix)" + "### 4.1 DG Plot Example (ASFE)\n", + "\n", + "Use a real ASFE submission and plot computed vs experimental DG values with cinnabar." ] }, { "cell_type": "code", - "execution_count": 11, - "id": "8515b4a9", + "execution_count": 17, + "id": "5d156d4b", "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Results without 'deprecated' tag: 136\n" + "2026-08-19 13:27:04 - openfe_benchmarks.results._benchmark_results - WARNING - Skipping submission '2026-08-04-openff3.0.0-alpha1b_opc3-jacs' during filtering: Results file not found: /Users/jenniferclark/bin/openfe-benchmarks/openfe_benchmarks/results/2026-08-04-openff3.0.0-alpha1b_opc3-jacs/computational_results.json\n", + "2026-08-19 13:27:04 - openfe_benchmarks.results._benchmark_results - INFO - Computing FEMaps for dg results - first access may be slow\n", + "2026-08-19 13:27:04 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'freesolv' from benchmark set 'solvation_set' with:\n", + " 5 ligand file(s), and 0 cofactor file(s).\n", + " Found protein file: False.\n", + " Found 0 ligand network files with keys: \n" ] - } - ], - "source": [ - "# Exclude results with 'deprecated' tag\n", - "no_deprecated = filter_results(results, exclude_tags=\"deprecated\")\n", - "print(f\"Results without 'deprecated' tag: {len(no_deprecated)}\")" - ] - }, - { - "cell_type": "markdown", - "id": "a63e218a", - "metadata": {}, - "source": [ - "### Complex Filter: Combine Multiple Conditions" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "1d540767", - "metadata": {}, - "outputs": [ + }, { "name": "stdout", "output_type": "stream", "text": [ - "Complex filtered results: 38\n" + "ASFE submission: 2026-08-06-openff-2.3.0-solvation_set_freesolv\n", + "System: solvation_set/freesolv\n", + "Saved DG plot: outputs/2026-08-06-openff-2.3.0-solvation_set_freesolv_solvation_set_freesolv_DG.png\n" ] - } - ], - "source": [ - "# Combine tags AND + system OR + exclude\n", - "complex_filtered = filter_results(\n", - " results,\n", - " tags=[\"rbfe\", \"openfe\"], # has BOTH rbfe AND openfe\n", - " system_name=[\"tyk2\", \"thrombin\"], # AND (tyk2 OR thrombin)\n", - " exclude_tags=[\"test\"], # AND NOT test\n", - ")\n", - "print(f\"Complex filtered results: {len(complex_filtered)}\")" - ] - }, - { - "cell_type": "markdown", - "id": "b5bc1b9b", - "metadata": {}, - "source": [ - "### Filter by Nested Protocol Settings" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "893abdbb", - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Results with lambda_windows='11': 0\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# Use double underscore (__) for nested field access\n", - "# Note: This example may not match anything depending on the submission structure\n", - "nested_results = filter_results(results, protocol_settings__lambda_windows=\"11\")\n", - "print(f\"Results with lambda_windows='11': {len(nested_results)}\")" - ] - }, - { - "cell_type": "markdown", - "id": "5b1bc26d", - "metadata": {}, - "source": [ - "## Comparison Operators with Pint Quantities\n", + "output_dir = Path(\"outputs\")\n", + "output_dir.mkdir(exist_ok=True)\n", "\n", - "The new pint Quantity comparison feature allows filtering by magnitude with automatic unit conversion.\n", + "asfe_submission = filter_results(calculation_type=\"asfe\", load_results=True)[0]\n", "\n", - "**Note**: Direct comparison operators in `filter_results()` are demonstrated here for documentation purposes. The implementation handles unit conversion automatically when comparing pint Quantity objects." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "c7a677ad", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Results with |ddg| > 1.0 kcal/mol: 36\n", - "Total ddg results: 80\n", - "\n", - "Example high-magnitude results:\n", - " None -> None: 1.102046405017669 kilocalories_per_mole\n", - " None -> None: -1.6725148955864118 kilocalories_per_mole\n", - " None -> None: 2.3959460144061424 kilocalories_per_mole\n" - ] - } - ], - "source": [ - "# Example: Filter for high magnitude results\n", - "# In practice, you would filter the raw dg/ddg values directly\n", - "if \"ddg\" in results.raw_results:\n", - " ddg_results = results.raw_results[\"ddg\"]\n", - "\n", - " # Manual filtering showing pint Quantity comparison\n", - " # The comparison automatically handles unit conversion\n", - " high_magnitude = [\n", - " r\n", - " for r in ddg_results\n", - " if abs(r.get(\"ddg\", 0).magnitude) > 1.0 # magnitude in kilocalories_per_mole\n", - " ]\n", - "\n", - " print(f\"\\nResults with |ddg| > 1.0 kcal/mol: {len(high_magnitude)}\")\n", - " print(f\"Total ddg results: {len(ddg_results)}\")\n", - "\n", - " # Show a few examples\n", - " if high_magnitude:\n", - " print(\"\\nExample high-magnitude results:\")\n", - " for r in high_magnitude[:3]:\n", - " print(\n", - " f\" {r.get('ligand_i_name')} -> {r.get('ligand_j_name')}: {r.get('ddg')}\"\n", - " )" + "(system_group, system_name), dg_femap = next(iter(asfe_submission.dg_femaps.items()))\n", + "\n", + "dg_plot_file = (\n", + " output_dir / f\"{asfe_submission.submission_id}_{system_group}_{system_name}_DG.png\"\n", + ")\n", + "plotting.plot_DGs(\n", + " dg_femap,\n", + " source=\"Computational\",\n", + " title=asfe_submission.submission_id,\n", + " figsize=5,\n", + " scatter_kwargs={\"s\": 20, \"marker\": \"o\"},\n", + " filename=dg_plot_file.as_posix(),\n", + ")\n", + "\n", + "print(f\"ASFE submission: {asfe_submission.submission_id}\")\n", + "print(f\"System: {system_group}/{system_name}\")\n", + "print(f\"Saved DG plot: {dg_plot_file}\")" ] }, { "cell_type": "markdown", - "id": "16d91d93", + "id": "8917fe58", "metadata": {}, "source": [ - "## FEMap Generation\n", + "### 4.2 DDG Plot Example (RBFE)\n", "\n", - "FEMaps are generated lazily using the `.ddg_femaps` and `.dg_femaps` properties." + "Use a real RBFE submission and plot computed vs experimental DDG values with cinnabar." ] }, { "cell_type": "code", - "execution_count": 15, - "id": "cd643fea", + "execution_count": 20, + "id": "3df2a51c", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "2026-08-18 19:46:00 - openfe_benchmarks.results._benchmark_results - INFO - Computing FEMaps for ddg results - first access may be slow\n", - "2026-08-18 19:46:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'tyk2' from benchmark set 'jacs_set' with:\n", + "2026-08-19 13:30:55 - openfe_benchmarks.results._benchmark_results - WARNING - Skipping submission '2026-08-04-openff3.0.0-alpha1b_opc3-jacs' during filtering: Results file not found: /Users/jenniferclark/bin/openfe-benchmarks/openfe_benchmarks/results/2026-08-04-openff3.0.0-alpha1b_opc3-jacs/computational_results.json\n", + "2026-08-19 13:30:55 - openfe_benchmarks.results._benchmark_results - INFO - Computing FEMaps for ddg results - first access may be slow\n", + "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'jnk1' from benchmark set 'jacs_set' with:\n", + " 5 ligand file(s), and 0 cofactor file(s).\n", + " Found protein file: True.\n", + " Found 1 ligand network files with keys: industry_benchmarks_network\n", + "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'thrombin' from benchmark set 'jacs_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: True.\n", " Found 1 ligand network files with keys: industry_benchmarks_network\n", - "2026-08-18 19:46:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'p38' from benchmark set 'jacs_set' with:\n", + "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'cdk2' from benchmark set 'jacs_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: True.\n", " Found 1 ligand network files with keys: industry_benchmarks_network\n", - "2026-08-18 19:46:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'irak4_s2' from benchmark set 'charge_annihilation_set' with:\n", + "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'bace' from benchmark set 'jacs_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: True.\n", " Found 1 ligand network files with keys: industry_benchmarks_network\n", - "2026-08-18 19:46:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'irak4_s3' from benchmark set 'charge_annihilation_set' with:\n", + "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'ptp1b' from benchmark set 'jacs_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: True.\n", " Found 1 ligand network files with keys: industry_benchmarks_network\n", - "2026-08-18 19:46:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'egfr' from benchmark set 'charge_annihilation_set' with:\n", + "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'tyk2' from benchmark set 'jacs_set' with:\n", + " 5 ligand file(s), and 0 cofactor file(s).\n", + " Found protein file: True.\n", + " Found 1 ligand network files with keys: industry_benchmarks_network\n", + "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'mcl1' from benchmark set 'jacs_set' with:\n", + " 5 ligand file(s), and 0 cofactor file(s).\n", + " Found protein file: True.\n", + " Found 1 ligand network files with keys: industry_benchmarks_network\n", + "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'p38' from benchmark set 'jacs_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: True.\n", " Found 1 ligand network files with keys: industry_benchmarks_network\n" @@ -528,125 +385,58 @@ "name": "stdout", "output_type": "stream", "text": [ - "Generating FEMaps...\n", - "\n", - "Generated 5 FEMaps:\n", - " - jacs_set/tyk2: 22 edges\n", - " - jacs_set/p38: 51 edges\n", - " - charge_annihilation_set/irak4_s2: 3 edges\n", - " - charge_annihilation_set/irak4_s3: 2 edges\n", - " - charge_annihilation_set/egfr: 2 edges\n" + "RBFE submission: 2026-02-12_sage_230_jacs_set\n", + "System: jacs_set/jnk1\n", + "DDG source used: ''\n", + "Saved DDG plot: outputs/2026-02-12_sage_230_jacs_set_jacs_set_jnk1_DDG.png\n" ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jenniferclark/mamba/envs/openfe-benchmarks-test/lib/python3.13/site-packages/cinnabar/femap.py:556: UserWarning: Graph is not connected enough to compute absolute values\n", - " warnings.warn(\"Graph is not connected enough to compute absolute values\")\n" - ] - } - ], - "source": [ - "# Access ddg_femaps (first access may be slow)\n", - "print(\"Generating FEMaps...\")\n", - "ddg_femaps = results.ddg_femaps\n", - "\n", - "print(f\"\\nGenerated {len(ddg_femaps)} FEMaps:\")\n", - "for (system_group, system_name), femap in ddg_femaps.items():\n", - " # Use to_legacy_graph() to get the networkx graph\n", - " leg_graph = femap.to_legacy_graph()\n", - " n_edges = len(leg_graph.edges())\n", - " print(f\" - {system_group}/{system_name}: {n_edges} edges\")" - ] - }, - { - "cell_type": "markdown", - "id": "cf333bc7", - "metadata": {}, - "source": [ - "## Plotting Example\n", - "\n", - "Use cinnabar to plot predicted vs experimental for one system." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "9b516fe0", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Plotted jacs_set/tyk2 with 22 edges\n" - ] } ], "source": [ - "# Plot the first system\n", - "if ddg_femaps:\n", - " (system_group, system_name), femap = list(ddg_femaps.items())[0]\n", - "\n", - " # Create the plot\n", - " leg_graph = femap.to_legacy_graph()\n", - " fig = plotting.plot_DDGs(\n", - " graph=leg_graph,\n", - " title=f\"{system_group} - {system_name}\",\n", - " figsize=6,\n", - " scatter_kwargs={\"s\": 30, \"marker\": \"o\", \"alpha\": 0.7},\n", - " )\n", - " plt.tight_layout()\n", - " plt.show()\n", - "\n", - " print(f\"\\nPlotted {system_group}/{system_name} with {len(leg_graph.edges())} edges\")" + "output_dir = Path(\"outputs\")\n", + "output_dir.mkdir(exist_ok=True)\n", + "\n", + "rbfe_submission = filter_results(calculation_type=\"rbfe\", load_results=True)[0]\n", + "(system_group, system_name), ddg_femap = next(iter(rbfe_submission.ddg_femaps.items()))\n", + "\n", + "relative_df = ddg_femap.get_relative_dataframe()\n", + "source = sorted(set(relative_df[\"source\"].fillna(\"\")))[0]\n", + "\n", + "ddg_plot_file = (\n", + " output_dir / f\"{rbfe_submission.submission_id}_{system_group}_{system_name}_DDG.png\"\n", + ")\n", + "plotting.plot_DDGs(\n", + " ddg_femap,\n", + " source=source,\n", + " title=rbfe_submission.submission_id,\n", + " figsize=5,\n", + " scatter_kwargs={\"s\": 20, \"marker\": \"o\"},\n", + " filename=ddg_plot_file.as_posix(),\n", + ")\n", + "\n", + "print(f\"RBFE submission: {rbfe_submission.submission_id}\")\n", + "print(f\"System: {system_group}/{system_name}\")\n", + "print(f\"DDG source used: {source!r}\")\n", + "print(f\"Saved DDG plot: {ddg_plot_file}\")" ] }, { - "cell_type": "markdown", - "id": "b0caaadd", + "cell_type": "code", + "execution_count": null, + "id": "eb59b7d4", "metadata": {}, - "source": [ - "## Summary\n", - "\n", - "This notebook demonstrated:\n", - "\n", - "1. **Loading results** with `get_benchmark_results()`\n", - "2. **Filtering** with various conditions:\n", - " - Single and multiple tags (AND/OR logic)\n", - " - System name and group\n", - " - Wildcards and NOT logic\n", - " - Nested protocol settings\n", - "3. **Pint Quantity comparison** for filtering by magnitude\n", - "4. **Lazy FEMap generation** with `.ddg_femaps` property\n", - "5. **Plotting** with cinnabar\n", - "\n", - "Next steps:\n", - "- Explore other submissions with different calculation types (ASFE, RBFE)\n", - "- Use filtering to focus on specific systems or conditions\n", - "- Combine with statistical analysis for benchmark comparisons" - ] + "outputs": [], + "source": [] } ], "metadata": { @@ -665,7 +455,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.2" + "version": "3.12.13" } }, "nbformat": 4, diff --git a/openfe_benchmarks/results/_benchmark_results.py b/openfe_benchmarks/results/_benchmark_results.py index 745a1ace..05f89d67 100644 --- a/openfe_benchmarks/results/_benchmark_results.py +++ b/openfe_benchmarks/results/_benchmark_results.py @@ -118,9 +118,9 @@ class BenchmarkResults: >>> # Fast YAML-only load (for CI validation) >>> results = get_benchmark_results('2026-03-18-openmm-840-qa-testing', load_results=False) >>> - >>> # Filter the results - >>> rbfe_results = filter_results(results, tags='rbfe') - >>> tyk2_results = filter_results(results, system_name='tyk2') + >>> # Filter submissions globally + >>> rbfe_submissions = filter_results(tags='rbfe') + >>> tyk2_submissions = filter_results(system_name='tyk2') """ # Required fields (match submission.yaml structure exactly) @@ -515,119 +515,162 @@ def get_benchmark_results( def filter_results( - benchmark_results: BenchmarkResults, tags_mode: str = "all", **filters -) -> list[dict]: + tags_mode: str = "all", load_results: Optional[bool] = None, **filters +) -> list[BenchmarkResults]: """ - Filter raw computational results by any combination of fields. - - Supports: - - Top-level metadata: tags='rbfe', calculation_type='rbfe' - - Nested fields: protocol_settings__temperature='298.15 K' (use __ for nesting) - - Result fields: system_group='jacs_set', system_name='tyk2' - - Wildcards: system_name='*tyk2*' (uses fnmatch) - - Comparison operators inline notation: date='>=2026-01-01', openfe_version='<1.0.0' - (supports <, <=, >, >= for dates, versions, and pint Quantity objects) - - Pint Quantity comparison: automatically handles unit conversion (e.g., '25 celsius' == '298.15 K') - - OR logic within field: pass list for ANY match (e.g., system_name=['tyk2', 'thrombin']) - - NOT logic: use exclude_ prefix (e.g., exclude_tags=['deprecated']) - - AND logic between fields: all filter conditions must match + Filter submissions by metadata and/or raw result-entry fields. + + This function scans all submission directories under ``openfe_benchmarks/results`` + and returns matching ``BenchmarkResults`` objects. + + Filters targeting ``BenchmarkResults`` fields (e.g. ``tags``, ``date``) are applied + at submission level. Filters targeting raw result entries (e.g. ``system_name``, + ``dg``) are applied to ``dg`` and ``ddg`` entries; a submission matches when any + single result entry satisfies all result-entry filters. Parameters ---------- - benchmark_results : BenchmarkResults - BenchmarkResults instance to filter tags_mode : {'all', 'any'}, default='all' When filtering by multiple tags: - - 'all': result must have ALL specified tags (AND logic, default) - - 'any': result must have ANY specified tag (OR logic) - Ignored if tags filter is not provided or is a single value. + - 'all': submission must have ALL specified tags (AND logic, default) + - 'any': submission must have ANY specified tag (OR logic) + load_results : bool, optional + Whether to load raw computational results while filtering. + If None (default), automatically enabled when result-entry filters are used. **filters : dict Field=value pairs to filter by. Values can be: - Single value: exact match (or wildcard if contains * or ?) - - List: matches if ANY value matches (OR logic) - EXCEPT tags which respects tags_mode - - Use exclude_ prefix for NOT logic (e.g., exclude_tags=['test']) + - List: matches if ANY value matches (OR logic), except ``tags`` honoring + ``tags_mode`` + - Use ``exclude_`` prefix for NOT logic (e.g. ``exclude_tags=['test']``) Returns ------- - list[dict] - Filtered result dictionaries + list[BenchmarkResults] + Matching BenchmarkResults objects + """ + if tags_mode not in {"all", "any"}: + raise ValueError(f"Invalid tags_mode: {tags_mode}. Must be 'all' or 'any'") - Raises - ------ - ValueError - If raw_results is None (load_results=False was used) + if not _RESULTS_DIR.exists(): + raise FileNotFoundError(f"Results directory not found: {_RESULTS_DIR}") - Examples - -------- - >>> results = BenchmarkResults(submission_id='2026-03-18-openmm-840-qa-testing') - >>> - >>> # Exact match - >>> rbfe_results = filter_results(results, tags='rbfe') - >>> - >>> # Tags AND logic (default): must have ALL tags - >>> validated = filter_results(results, tags=['rbfe', 'openfe', 'validation']) - >>> - >>> # Tags OR logic: must have ANY tag - >>> any_calc = filter_results(results, tags=['rbfe', 'asfe'], tags_mode='any') - >>> - >>> # OR within non-tag fields (list = ANY match) - >>> multi_system = filter_results(results, system_name=['tyk2', 'thrombin']) - >>> - >>> # NOT logic (exclude_ prefix) - >>> no_deprecated = filter_results(results, exclude_tags='deprecated') - >>> no_test = filter_results(results, exclude_tags=['deprecated', 'test'], tags_mode='any') - >>> - >>> # Comparison operators (inline notation) - >>> recent = filter_results(results, date='>=2026-01-01') - >>> old_versions = filter_results(results, openfe_version='<1.0.0') - >>> newer_versions = filter_results(results, openmm_version='>=8.0.0') - >>> - >>> # Complex: multiple tags (AND), system OR, exclude - >>> filtered = filter_results( - ... results, - ... tags=['rbfe', 'openfe'], # has BOTH rbfe AND openfe - ... system_name=['tyk2', 'thrombin'], # AND (tyk2 OR thrombin) - ... exclude_tags=['deprecated'] # AND NOT deprecated - ... ) - >>> - >>> # Nested fields and wildcards - >>> lambda11 = filter_results(results, protocol_settings__lambda_windows='11') - >>> tyk2_wildcard = filter_results(results, system_name='*tyk2*') - """ - if benchmark_results.raw_results is None: - raise ValueError( - "Cannot filter results: raw_results is None. " - "Initialize with load_results=True to access computational data." - ) + submission_filters = { + key: value for key, value in filters.items() if _is_submission_filter_key(key) + } + result_entry_filters = { + key: value + for key, value in filters.items() + if not _is_submission_filter_key(key) + } + + if load_results is None: + load_results = bool(result_entry_filters) + + matched_submissions: list[BenchmarkResults] = [] + for submission_dir in sorted(_RESULTS_DIR.iterdir()): + if not submission_dir.is_dir(): + continue + + submission_file = submission_dir / "submission.yaml" + if not submission_file.exists(): + continue + + try: + benchmark_results = get_benchmark_results( + submission_id=submission_dir.name, + load_results=load_results, + ) + except (FileNotFoundError, ValueError) as exc: + logger.warning( + "Skipping submission '%s' during filtering: %s", + submission_dir.name, + exc, + ) + continue + + if not all( + _match_submission_filter(benchmark_results, key, value, tags_mode) + for key, value in submission_filters.items() + ): + continue + + if not result_entry_filters: + matched_submissions.append(benchmark_results) + continue + + if benchmark_results.raw_results is None: + continue + + all_results = [] + if "dg" in benchmark_results.raw_results: + all_results.extend(benchmark_results.raw_results["dg"]) + if "ddg" in benchmark_results.raw_results: + all_results.extend(benchmark_results.raw_results["ddg"]) - # Collect all results (dg + ddg) - all_results = [] - if "dg" in benchmark_results.raw_results: - all_results.extend(benchmark_results.raw_results["dg"]) - if "ddg" in benchmark_results.raw_results: - all_results.extend(benchmark_results.raw_results["ddg"]) - - # Apply filters - filtered = [] - for result in all_results: - # Check all filters (AND logic between different filters) - if all( - _match_filter(result, benchmark_results, key, value, tags_mode) - for key, value in filters.items() + if any( + all( + _match_filter(result, benchmark_results, key, value, tags_mode) + for key, value in result_entry_filters.items() + ) + for result in all_results ): - filtered.append(result) + matched_submissions.append(benchmark_results) + + return matched_submissions + + +def _is_submission_filter_key(filter_key: str) -> bool: + """Return True if filter key targets a BenchmarkResults-level field.""" + if filter_key.startswith("exclude_"): + filter_key = filter_key[len("exclude_") :] + + root_key = filter_key.split("__", 1)[0] + return root_key in BenchmarkResults.__dataclass_fields__ + + +def _match_submission_filter( + benchmark_results: BenchmarkResults, + filter_key: str, + filter_val: Union[str, list, Any], + tags_mode: str, +) -> bool: + """Check if a submission-level field matches a filter predicate.""" + EXCLUDE_PREFIX = "exclude_" + negate = False + if filter_key.startswith(EXCLUDE_PREFIX): + negate = True + filter_key = filter_key[len(EXCLUDE_PREFIX) :] + + comparison_op = None + if isinstance(filter_val, str): + comparison_op, filter_val = _parse_inline_operator(filter_val) - return filtered + if "__" in filter_key: + value = _get_nested_value(benchmark_results, filter_key) + else: + value = getattr(benchmark_results, filter_key, None) + if value is None: + result_matched = False + return not result_matched if negate else result_matched -def _get_nested_value(result: dict, nested_key: str) -> Optional[Any]: + if comparison_op is not None: + result_matched = _compare_values(value, filter_val, comparison_op, filter_key) + else: + result_matched = _match_value(value, filter_val, filter_key, tags_mode) + + return not result_matched if negate else result_matched + + +def _get_nested_value(result: Any, nested_key: str) -> Optional[Any]: """ Extract value from nested dictionary using double-underscore separated keys. Parameters ---------- - result : dict - Result dictionary to extract from + result : Any + Result object or dictionary to extract from nested_key : str Nested key with __ separator (e.g., 'protocol_settings__temperature') @@ -651,12 +694,23 @@ def _get_nested_value(result: dict, nested_key: str) -> Optional[Any]: value = value.get(key, None) elif isinstance(value, list): # Support list-of-dicts nesting (e.g. protocol_settings is a list of dicts) - value = [item.get(key, None) for item in value if isinstance(item, dict)] - value = [v for v in value if v is not None] + next_values = [] + for item in value: + if isinstance(item, dict): + nested = item.get(key, None) + else: + nested = getattr(item, key, None) + + if nested is not None: + next_values.append(nested) + + value = next_values if not value: return None else: - return None + value = getattr(value, key, None) + if value is None: + return None return value diff --git a/openfe_benchmarks/tests/test_benchmark_results.py b/openfe_benchmarks/tests/test_benchmark_results.py index fe7e6eeb..d103a28c 100644 --- a/openfe_benchmarks/tests/test_benchmark_results.py +++ b/openfe_benchmarks/tests/test_benchmark_results.py @@ -15,7 +15,11 @@ from cinnabar import FEMap -from openfe_benchmarks.results import get_benchmark_results, filter_results +from openfe_benchmarks.results import ( + BenchmarkResults, + get_benchmark_results, + filter_results, +) import openfe_benchmarks.results._benchmark_results as br_module @@ -24,6 +28,24 @@ ASFE_SUBMISSION = "2026-08-06-openff-2.3.0-solvation_set_freesolv" +def _all_result_entries(submission: BenchmarkResults) -> list[dict]: + """Collect all dg/ddg entries for a submission.""" + if submission.raw_results is None: + return [] + + entries = [] + if "dg" in submission.raw_results: + entries.extend(submission.raw_results["dg"]) + if "ddg" in submission.raw_results: + entries.extend(submission.raw_results["ddg"]) + return entries + + +def _has_matching_entry(submission: BenchmarkResults, predicate) -> bool: + """Return True if any raw result entry satisfies predicate.""" + return any(predicate(entry) for entry in _all_result_entries(submission)) + + # ========== Fixtures ========== @@ -187,51 +209,47 @@ def test_raw_results_structure(): def test_filter_by_tags(): """Test filtering by exact tag match.""" - result = get_benchmark_results(RBFE_SUBMISSION) - filtered = filter_results(result, tags="rbfe") + filtered = filter_results(tags="rbfe") assert len(filtered) > 0 - # All results should have the tag (check metadata since tags is top-level) - assert "rbfe" in result.tags + assert all(isinstance(submission, BenchmarkResults) for submission in filtered) + assert all("rbfe" in submission.tags for submission in filtered) def test_filter_by_multiple_tags_and(): """Test filtering by multiple tags with AND logic (default).""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Use tags that should exist in the submission - filtered = filter_results(result, tags=["rbfe", "jacs_set"]) + filtered = filter_results(tags=["rbfe", "jacs_set"]) - # Verify it returns a list assert isinstance(filtered, list) - - # Verify tags exist in submission metadata (tags are top-level, not per-result) - assert "rbfe" in result.tags - assert "jacs_set" in result.tags + assert all("rbfe" in submission.tags for submission in filtered) + assert all("jacs_set" in submission.tags for submission in filtered) def test_filter_by_multiple_tags_or(): """Test filtering by multiple tags with OR logic.""" - result = get_benchmark_results(RBFE_SUBMISSION) + filtered = filter_results(tags=["rbfe", "asfe"], tags_mode="any") - # Use tags_mode='any' for OR logic - filtered = filter_results(result, tags=["rbfe", "asfe"], tags_mode="any") - - # Should return results since 'rbfe' tag exists assert len(filtered) > 0 assert isinstance(filtered, list) + assert all( + ("rbfe" in submission.tags) or ("asfe" in submission.tags) + for submission in filtered + ) def test_filter_by_system(): """Test filtering by system_group and system_name.""" - result = get_benchmark_results(RBFE_SUBMISSION) - filtered = filter_results(result, system_group="jacs_set", system_name="tyk2") + filtered = filter_results(system_group="jacs_set", system_name="tyk2") assert len(filtered) > 0 - # Verify all results match - for r in filtered: - assert r["system_group"] == "jacs_set" - assert r["system_name"] == "tyk2" + assert all( + _has_matching_entry( + submission, + lambda entry: entry.get("system_group") == "jacs_set" + and entry.get("system_name") == "tyk2", + ) + for submission in filtered + ) def test_filter_by_nested_field(): @@ -242,118 +260,91 @@ def test_filter_by_nested_field(): so this test verifies that the nested field filtering mechanism works correctly when the field doesn't exist (should return empty list). """ - result = get_benchmark_results(RBFE_SUBMISSION) - - # Test that nested field syntax doesn't crash when field doesn't exist - # Using a hypothetical nested field that doesn't exist in current test data - filtered = filter_results(result, hypothetical__nested__field="value") + filtered = filter_results(hypothetical__nested__field="value") - # Should return empty list (field doesn't exist) assert isinstance(filtered, list) - assert len(filtered) == 0, ( - "Filtering by non-existent nested field should return empty list" - ) + assert len(filtered) == 0 - # Verify regular filtering still works - filtered_normal = filter_results(result, system_group="jacs_set") - assert len(filtered_normal) > 0, "Regular filtering should still work" + filtered_normal = filter_results(system_group="jacs_set") + assert len(filtered_normal) > 0 def test_filter_with_wildcard(): """Test filtering with wildcard pattern matching.""" - result = get_benchmark_results(RBFE_SUBMISSION) - filtered = filter_results(result, system_name="*tyk2*") + filtered = filter_results(system_name="*tyk2*") assert len(filtered) > 0 - # Verify all results match wildcard (case-sensitive by fnmatch) - for r in filtered: - assert "tyk2" in r["system_name"] + assert all( + _has_matching_entry( + submission, + lambda entry: "tyk2" in entry.get("system_name", ""), + ) + for submission in filtered + ) def test_filter_or_logic(): """Test OR logic within a field using list values.""" - result = get_benchmark_results(RBFE_SUBMISSION) - filtered = filter_results(result, system_name=["tyk2", "p38"]) + filtered = filter_results(system_name=["tyk2", "p38"]) assert len(filtered) > 0 - # Verify all results match one of the values - for r in filtered: - assert r["system_name"] in ["tyk2", "p38"] + assert all( + _has_matching_entry( + submission, + lambda entry: entry.get("system_name") in ["tyk2", "p38"], + ) + for submission in filtered + ) def test_filter_not_logic(): """Test NOT logic using exclude_ prefix.""" - result = get_benchmark_results(RBFE_SUBMISSION) + filtered = filter_results(system_group="jacs_set", exclude_system_name="tyk2") - # Test 1: Filter for jacs_set but exclude tyk2 system - filtered = filter_results( - result, system_group="jacs_set", exclude_system_name="tyk2" + assert len(filtered) > 0 + assert all( + _has_matching_entry( + submission, + lambda entry: entry.get("system_group") == "jacs_set" + and entry.get("system_name") != "tyk2", + ) + for submission in filtered ) - assert len(filtered) > 0 - # Verify no tyk2 results - for r in filtered: - assert r["system_group"] == "jacs_set" - assert r["system_name"] != "tyk2" - - # Test 2: Exclude by tags (as specified in plan) - # Note: This tests the mechanism even if 'deprecated' tag doesn't exist - # The filter should return all results (no exclusion) if tag doesn't exist - filtered_tags = filter_results(result, exclude_tags="deprecated") + filtered_tags = filter_results(exclude_tags="deprecated") assert isinstance(filtered_tags, list) def test_filter_complex_logic(): """Test complex filtering combining tags AND + system OR + exclude.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Complex filter: tags AND + system OR + exclude filtered = filter_results( - result, tags=["rbfe", "jacs_set"], system_name=["tyk2", "p38"], exclude_tags="deprecated", ) - # Verify it returns a list assert isinstance(filtered, list) - - # Verify tags exist in metadata (tags are top-level) - assert "rbfe" in result.tags - assert "jacs_set" in result.tags - - # Verify filtering worked correctly - if len(filtered) > 0: - for r in filtered: - # Must match one of the system names (OR logic within field) - assert r["system_name"] in ["tyk2", "p38"], ( - f"Expected system_name in ['tyk2', 'p38'], got {r['system_name']}" - ) - - # Must NOT have 'deprecated' tag (exclude logic) - # Tags are at result level if they exist in the result dict - if "tags" in r: - assert "deprecated" not in r["tags"], ( - f"Result should not have 'deprecated' tag but found it in {r.get('tags')}" - ) - else: - # If no results, ensure the filter criteria could be met - # (i.e., the submission has the required tags) - assert "rbfe" in result.tags and "jacs_set" in result.tags + for submission in filtered: + assert "rbfe" in submission.tags + assert "jacs_set" in submission.tags + assert "deprecated" not in submission.tags + assert _has_matching_entry( + submission, + lambda entry: entry.get("system_name") in ["tyk2", "p38"], + ) def test_filter_multi_and_logic(): """Test multiple predicates with AND logic between fields.""" - result = get_benchmark_results(RBFE_SUBMISSION) - filtered = filter_results(result, system_group="jacs_set", calculation_type="rbfe") + filtered = filter_results(system_group="jacs_set", calculation_type="rbfe") - # Should return results matching both predicates assert len(filtered) > 0 - for r in filtered: - assert r["system_group"] == "jacs_set" - - # Verify calculation_type in metadata (it's a top-level field) - assert result.calculation_type == "rbfe" + for submission in filtered: + assert submission.calculation_type == "rbfe" + assert _has_matching_entry( + submission, + lambda entry: entry.get("system_group") == "jacs_set", + ) # ========== FEMap Tests ========== @@ -484,18 +475,12 @@ def test_unknown_fields_in_yaml(create_test_submission): ) -def test_filter_on_fast_loaded_results(): - """Test that filtering raises error when raw_results is None.""" - result = get_benchmark_results(RBFE_SUBMISSION, load_results=False) - - with pytest.raises(ValueError) as excinfo: - filter_results(result, tags="rbfe") +def test_filter_metadata_with_load_results_false(): + """Test metadata-only filtering without loading raw result JSON files.""" + filtered = filter_results(tags="rbfe", load_results=False) - expected_msg = ( - "Cannot filter results: raw_results is None. " - "Initialize with load_results=True to access computational data." - ) - assert str(excinfo.value) == expected_msg + assert len(filtered) > 0 + assert all(submission.raw_results is None for submission in filtered) def test_femaps_on_fast_loaded_results(): @@ -517,81 +502,48 @@ def test_femaps_on_fast_loaded_results(): def test_filter_date_greater_than_or_equal(): """Test date filtering with >= operator.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Filter for dates >= 2026-03-01 - filtered = filter_results(result, date=">=2026-03-01") + filtered = filter_results(date=">=2026-03-01") - # Should include results (submission date is after 2026-03-01) assert len(filtered) > 0 - # Convert date to string for comparison - assert result.date.isoformat() >= "2026-03-01" + assert all(submission.date.isoformat() >= "2026-03-01" for submission in filtered) def test_filter_date_less_than(): """Test date filtering with < operator.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Filter for dates < 2027-01-01 - filtered = filter_results(result, date="<2027-01-01") + filtered = filter_results(date="<2027-01-01") - # Should include results (submission date is before 2027) assert len(filtered) > 0 - assert result.date.isoformat() < "2027-01-01" + assert all(submission.date.isoformat() < "2027-01-01" for submission in filtered) def test_filter_date_range(): """Test date filtering with range (combining two filters).""" - result = get_benchmark_results(RBFE_SUBMISSION) + filtered_after = filter_results(date=">=2026-01-01") + filtered_before = filter_results(date="<2027-01-01") - # Filter for dates in 2026 (>= 2026-01-01 AND < 2027-01-01) - # Note: This requires applying both filters, but current API doesn't support - # multiple operators on same field, so we test separately - filtered_after = filter_results(result, date=">=2026-01-01") - filtered_before = filter_results(result, date="<2027-01-01") - - # Both should return results assert len(filtered_after) > 0 assert len(filtered_before) > 0 def test_filter_version_less_than(): """Test version filtering with < operator using semantic versioning.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Get the actual version from the submission - actual_version = result.openfe_version + next_version = "99.0.0" + filtered = filter_results(openfe_version=f"<{next_version}") - # Filter for versions < actual_version + 1 (should include all) - major, minor, *rest = actual_version.split(".") - next_version = f"{int(major) + 1}.0.0" - filtered = filter_results(result, openfe_version=f"<{next_version}") - - # Should include results assert len(filtered) > 0 def test_filter_version_greater_than_or_equal(): """Test version filtering with >= operator using semantic versioning.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Filter for versions >= 1.0.0 (should include most versions) - filtered = filter_results(result, openfe_version=">=1.0.0") + filtered = filter_results(openfe_version=">=1.0.0") - # Should include results (openfe_version is likely >= 1.0.0) assert isinstance(filtered, list) def test_filter_version_semantic_comparison(): """Test that version comparison uses semantic versioning, not string comparison.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Semantic: 1.10.0 > 1.9.0 - # String: "1.10.0" < "1.9.0" (would be wrong) - - # Just verify filtering works without error - filtered_gte = filter_results(result, openfe_version=">=1.0.0") - filtered_lt = filter_results(result, openfe_version="<99.0.0") + filtered_gte = filter_results(openfe_version=">=1.0.0") + filtered_lt = filter_results(openfe_version="<99.0.0") assert isinstance(filtered_gte, list) assert isinstance(filtered_lt, list) @@ -599,50 +551,37 @@ def test_filter_version_semantic_comparison(): def test_filter_comparison_with_other_filters(): """Test comparison operators combined with other filter types.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Combine date comparison with system filter - filtered = filter_results(result, date=">=2026-01-01", system_group="jacs_set") + filtered = filter_results(date=">=2026-01-01", system_group="jacs_set") - # Should return results matching both conditions assert isinstance(filtered, list) if len(filtered) > 0: - for r in filtered: - assert r["system_group"] == "jacs_set" - # Date is metadata-level, checked via isoformat - assert result.date.isoformat() >= "2026-01-01" + for submission in filtered: + assert submission.date.isoformat() >= "2026-01-01" + assert _has_matching_entry( + submission, + lambda entry: entry.get("system_group") == "jacs_set", + ) def test_filter_comparison_no_operator(): """Test that values without operators still work as exact match.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Date without operator should be exact match - exact_date = result.date - filtered = filter_results(result, date=exact_date) + exact_date = "2026-03-18" + filtered = filter_results(date=exact_date) - # Should return all results (exact match on metadata) - assert len(filtered) > 0 + assert all(submission.date.isoformat() == exact_date for submission in filtered) def test_filter_comparison_exclude_with_operator(): """Test that exclude_ prefix works with comparison operators.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Exclude dates before 2026 - filtered = filter_results(result, exclude_date="<2026-01-01") + filtered = filter_results(exclude_date="<2026-01-01") - # Should return results (submission date is after 2026-01-01, so not excluded) assert len(filtered) > 0 - assert result.date.isoformat() >= "2026-01-01" + assert all(submission.date.isoformat() >= "2026-01-01" for submission in filtered) def test_filter_comparison_openmm_version(): """Test comparison on openmm_version field.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Filter for OpenMM >= 8.0.0 - filtered = filter_results(result, openmm_version=">=8.0.0") + filtered = filter_results(openmm_version=">=8.0.0") # Should return results if openmm_version >= 8.0.0 assert isinstance(filtered, list) @@ -650,10 +589,7 @@ def test_filter_comparison_openmm_version(): def test_filter_comparison_openff_toolkit_version(): """Test comparison on openff_toolkit_version field.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Filter for OpenFF Toolkit >= 0.10.0 - filtered = filter_results(result, openff_toolkit_version=">=0.10.0") + filtered = filter_results(openff_toolkit_version=">=0.10.0") # Should return results if version matches assert isinstance(filtered, list) @@ -661,14 +597,11 @@ def test_filter_comparison_openff_toolkit_version(): def test_filter_comparison_warning_non_version_field(): """Test that warning is issued when comparison operators used with non-date/version fields.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Using comparison operator with system_name (not a date/version field) should warn with pytest.warns( UserWarning, match="Comparison operator.*system_name.*designed for date and version fields", ): - filtered = filter_results(result, system_name=">=tyk2") + filtered = filter_results(system_name=">=tyk2") # Still returns results (falls back to string comparison) assert isinstance(filtered, list) @@ -676,44 +609,38 @@ def test_filter_comparison_warning_non_version_field(): def test_filter_quantity_comparison_greater_than(): """Test filtering on pint Quantity fields with > operator.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Filter results where dg > 1.0 kcal/mol - # dg values are Quantity objects deserialized from JSON - filtered = filter_results(result, dg=">1.0 kilocalories_per_mole") + filtered = filter_results(dg=">1.0 kilocalories_per_mole") assert isinstance(filtered, list) assert len(filtered) > 0 - - # Verify all results have dg > 1.0 kcal/mol - for r in filtered: - assert r["dg"].magnitude > 1.0 + assert all( + _has_matching_entry( + submission, + lambda entry: "dg" in entry and entry["dg"].magnitude > 1.0, + ) + for submission in filtered + ) def test_filter_quantity_comparison_less_than_or_equal(): """Test filtering on pint Quantity fields with <= operator.""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Filter results where dg <= 2.0 kcal/mol - filtered = filter_results(result, dg="<=2.0 kilocalories_per_mole") + filtered = filter_results(dg="<=2.0 kilocalories_per_mole") assert isinstance(filtered, list) assert len(filtered) > 0 - - # Verify all results have dg <= 2.0 kcal/mol - for r in filtered: - assert r["dg"].magnitude <= 2.0 + assert all( + _has_matching_entry( + submission, + lambda entry: "dg" in entry and entry["dg"].magnitude <= 2.0, + ) + for submission in filtered + ) def test_filter_quantity_comparison_unit_conversion(): """Test that pint Quantity comparison handles unit conversion automatically.""" - - result = get_benchmark_results(RBFE_SUBMISSION) - - # Filter with different but compatible units - # 1 kcal/mol ≈ 4.184 kJ/mol - filtered_kcal = filter_results(result, dg=">1.0 kilocalories_per_mole") - filtered_kj = filter_results(result, dg=">4.184 kilojoules_per_mole") + filtered_kcal = filter_results(dg=">1.0 kilocalories_per_mole") + filtered_kj = filter_results(dg=">4.184 kilojoules_per_mole") # Should get the same results (or very close due to floating point) assert ( @@ -724,40 +651,37 @@ def test_filter_quantity_comparison_unit_conversion(): def test_filter_quantity_comparison_range(): """Test filtering on pint Quantity with range (testing both filters separately).""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Filter for dg >= 0.5 kcal/mol - filtered_gte = filter_results(result, dg=">=0.5 kilocalories_per_mole") - - # Filter for dg <= 2.0 kcal/mol - filtered_lte = filter_results(result, dg="<=2.0 kilocalories_per_mole") + filtered_gte = filter_results(dg=">=0.5 kilocalories_per_mole") + filtered_lte = filter_results(dg="<=2.0 kilocalories_per_mole") assert isinstance(filtered_gte, list) assert isinstance(filtered_lte, list) assert len(filtered_gte) > 0 assert len(filtered_lte) > 0 - # Verify ranges - for r in filtered_gte: - assert r["dg"].magnitude >= 0.5 - - for r in filtered_lte: - assert r["dg"].magnitude <= 2.0 + assert all( + _has_matching_entry( + submission, + lambda entry: "dg" in entry and entry["dg"].magnitude >= 0.5, + ) + for submission in filtered_gte + ) + assert all( + _has_matching_entry( + submission, + lambda entry: "dg" in entry and entry["dg"].magnitude <= 2.0, + ) + for submission in filtered_lte + ) def test_filter_quantity_incompatible_units_raises(): """Test that incompatible units raise ValueError (no silent fallback).""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Try to compare energy (kcal/mol) with temperature (K) - dimensionally incompatible with pytest.raises(ValueError, match="Incompatible units"): - _ = filter_results(result, dg=">298 kelvin") + _ = filter_results(dg=">298 kelvin") def test_filter_quantity_invalid_string_raises(): """Test that invalid quantity strings raise ValueError (no silent fallback).""" - result = get_benchmark_results(RBFE_SUBMISSION) - - # Use a string that can't be parsed as a quantity with pytest.raises(ValueError, match="Invalid quantity filter value"): - _ = filter_results(result, dg=">not_a_quantity") + _ = filter_results(dg=">not_a_quantity") From dede9aeb062dabe1806e7a88a909d50013ad770a Mon Sep 17 00:00:00 2001 From: jaclark5 Date: Wed, 19 Aug 2026 13:47:23 -0400 Subject: [PATCH 09/11] Update rbfe plotting --- openfe_benchmarks/scripts/_example_plot_rbfe.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/openfe_benchmarks/scripts/_example_plot_rbfe.py b/openfe_benchmarks/scripts/_example_plot_rbfe.py index cccf02ba..3fcea1a4 100644 --- a/openfe_benchmarks/scripts/_example_plot_rbfe.py +++ b/openfe_benchmarks/scripts/_example_plot_rbfe.py @@ -41,7 +41,7 @@ def main(): femaps_by_system = results.ddg_femaps print(f"Generated {len(femaps_by_system)} FEMaps:") for (system_group, system_name), femap in femaps_by_system.items(): - n_edges = len(femap.edges) + n_edges = femap.n_edges print(f" - {system_group}/{system_name}: {n_edges} edges") output_dir = pathlib.Path(OUTPUT_DIR) @@ -49,10 +49,10 @@ def main(): print(f"\nGenerating plots in {output_dir}/...") for (system_group, system_name), femap in femaps_by_system.items(): - leg_graph = femap.to_legacy_graph() output_file = output_dir / f"{system_group}_{system_name}_DDG.png" + legacy_graph = femap.to_legacy_graph() plotting.plot_DDGs( - graph=leg_graph, + graph=legacy_graph, title=f"{system_group}-{system_name}", figsize=5, scatter_kwargs={"s": 20, "marker": "o"}, From 248e05e1ea528cac196b7f92c7c9a625b22dca48 Mon Sep 17 00:00:00 2001 From: jaclark5 Date: Wed, 19 Aug 2026 14:25:06 -0400 Subject: [PATCH 10/11] resolve filtering --- examples/4_benchmark_result_plot.ipynb | 32 +++- .../results/_benchmark_results.py | 181 +++++++++--------- .../tests/test_benchmark_results.py | 82 ++++++++ 3 files changed, 202 insertions(+), 93 deletions(-) diff --git a/examples/4_benchmark_result_plot.ipynb b/examples/4_benchmark_result_plot.ipynb index 59d2b734..1173ecb6 100644 --- a/examples/4_benchmark_result_plot.ipynb +++ b/examples/4_benchmark_result_plot.ipynb @@ -12,6 +12,7 @@ "- Filtering is **global across all submissions** in `openfe_benchmarks/results`.\n", "- Return values are `BenchmarkResults` objects for matching submissions.\n", "- Entry-level filters (for `dg`/`ddg`) still work, but selection happens at submission level.\n", + "- When using `load_results=False`, you can load a specific submission later with `load_raw_results()`.\n", "\n", "The workflow below uses practical checks that are useful for CI and analysis pipelines, with assertions that fail fast when behavior changes." ] @@ -66,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 21, "id": "ac74c674", "metadata": {}, "outputs": [ @@ -83,7 +84,9 @@ " 2026-08-05-openff3.0.0-alpha1b_tip3p-jacs\n", " 2026-08-06-openff-2.3.0-solvation_set_freesolv\n", " 2026_08_05_ff14sb_openff-3.0.0-alpha1b_tip3p_jacs_tyk2_thrombin\n", - " 2026_08_05_openff-3.0.0-alpha0_opc3_jacs\n" + " 2026_08_05_openff-3.0.0-alpha0_opc3_jacs\n", + "Before load_raw_results: raw_results is None\n", + "After load_raw_results: raw_results loaded = True\n" ] } ], @@ -94,7 +97,20 @@ "print(\"Sample IDs:\\n \", \"\\n \".join(sorted(submission_ids(all_submissions))))\n", "\n", "assert all_submissions, \"Expected at least one submission in results directory\"\n", - "assert all(hasattr(r, \"submission_id\") for r in all_submissions)" + "assert all(hasattr(r, \"submission_id\") for r in all_submissions)\n", + "\n", + "# With load_results=False, only metadata is loaded initially.\n", + "example_submission = all_submissions[0]\n", + "print(f\"Before load_raw_results: raw_results is {example_submission.raw_results}\")\n", + "\n", + "# Load computational results later, only when needed.\n", + "example_submission.load_raw_results()\n", + "print(\n", + " \"After load_raw_results: raw_results loaded =\",\n", + " example_submission.raw_results is not None,\n", + ")\n", + "\n", + "assert example_submission.raw_results is not None" ] }, { @@ -109,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 25, "id": "78b4d820", "metadata": {}, "outputs": [ @@ -119,6 +135,8 @@ "text": [ "RBFE submissions: 7\n", "Submissions since 2026-01-01: 8\n", + "Submissions on/before 2026-08-01: 3\n", + "Submissions with openfe_version > 2.3.0: 1\n", "Non-pontibus submissions: 7\n" ] } @@ -126,16 +144,22 @@ "source": [ "rbfe_submissions = filter_results(calculation_type=\"rbfe\", load_results=False)\n", "recent_submissions = filter_results(date=\">=2026-01-01\", load_results=False)\n", + "older_submissions = filter_results(date=\"<=2026-08-01\", load_results=False)\n", + "newer_openfe_submissions = filter_results(openfe_version=\">1.8.0\", load_results=False)\n", "non_test_submissions = filter_results(\n", " exclude_tags=[\"pontibus\"], tags_mode=\"all\", load_results=False\n", ")\n", "\n", "print(f\"RBFE submissions: {len(rbfe_submissions)}\")\n", "print(f\"Submissions since 2026-01-01: {len(recent_submissions)}\")\n", + "print(f\"Submissions on/before 2026-08-01: {len(older_submissions)}\")\n", + "print(f\"Submissions with openfe_version > 2.3.0: {len(newer_openfe_submissions)}\")\n", "print(f\"Non-pontibus submissions: {len(non_test_submissions)}\")\n", "\n", "assert len(rbfe_submissions) <= len(all_submissions)\n", "assert len(recent_submissions) <= len(all_submissions)\n", + "assert len(older_submissions) <= len(all_submissions)\n", + "assert len(newer_openfe_submissions) <= len(all_submissions)\n", "assert len(non_test_submissions) <= len(all_submissions)" ] }, diff --git a/openfe_benchmarks/results/_benchmark_results.py b/openfe_benchmarks/results/_benchmark_results.py index 05f89d67..f8dc20b8 100644 --- a/openfe_benchmarks/results/_benchmark_results.py +++ b/openfe_benchmarks/results/_benchmark_results.py @@ -16,6 +16,7 @@ import re import logging import warnings +import operator as py_operator from packaging.version import Version, InvalidVersion import pint @@ -951,84 +952,27 @@ def _compare_values( >>> _compare_values(q1, '25 celsius', '>=') # Unit conversion handled automatically True """ - # Check if field is appropriate for comparison operators - # Don't warn for date/version fields or pint Quantity objects (semantically meaningful) - COMPARISON_ALLOWED_FIELDS = { - "date", - "openfe_version", - "openmm_version", - "openff_toolkit_version", - } - if ( - field_name - and field_name not in COMPARISON_ALLOWED_FIELDS - and not field_name.endswith("_version") - and not isinstance(result_value, pint.Quantity) - ): - warnings.warn( - f"Comparison operator '{operator}' used with field '{field_name}'. " - f"Comparison operators are designed for date and version fields. " - f"Results may not be semantically meaningful for other field types.", - UserWarning, - stacklevel=4, + # For list-valued nested fields, match if any element satisfies the comparison. + if isinstance(result_value, list): + return any( + _compare_values(item, filter_val, operator, field_name) + for item in result_value ) + _warn_if_nonsemantic_comparison(result_value, operator, field_name) + # Handle datetime.date objects (from YAML parsing) if isinstance(result_value, date_type): - # Convert filter value to date if it's a string - if isinstance(filter_val, str): - try: - # Parse ISO format date string YYYY-MM-DD - filter_val = date_type.fromisoformat(filter_val) - except (ValueError, AttributeError): - # If parsing fails, convert both to strings for comparison - result_value = result_value.isoformat() - - # Now compare dates (both should be date objects or both strings) - if operator == "<": - return result_value < filter_val - elif operator == "<=": - return result_value <= filter_val - elif operator == ">": - return result_value > filter_val - elif operator == ">=": - return result_value >= filter_val - else: - raise ValueError(f"Unknown comparison operator: {operator}") + result_value, filter_val = _coerce_date_values(result_value, filter_val) + return _apply_comparison_operator(result_value, filter_val, operator) # Handle pint Quantity objects (from JSON_HANDLER deserialization) if isinstance(result_value, pint.Quantity): - # Convert filter value to Quantity if it's a string - # Use the same UnitRegistry as the result_value to ensure compatibility - if isinstance(filter_val, str): - try: - # Parse quantity string using the result_value's UnitRegistry - # This ensures we can compare quantities from the same registry - ureg = result_value._REGISTRY - filter_val = ureg.Quantity(filter_val) - except (ValueError, pint.errors.UndefinedUnitError, AttributeError): - raise ValueError( - f"Invalid quantity filter value '{filter_val}' for field '{field_name}'. " - "Provide a valid quantity string with units." - ) - elif not isinstance(filter_val, pint.Quantity): - raise ValueError( - f"Invalid filter type '{type(filter_val).__name__}' for Quantity field '{field_name}'. " - "Provide a quantity string or pint.Quantity value." - ) + filter_val = _coerce_quantity_filter_value(result_value, filter_val, field_name) # Compare Quantities (pint handles unit conversion automatically) try: - if operator == "<": - return result_value < filter_val - elif operator == "<=": - return result_value <= filter_val - elif operator == ">": - return result_value > filter_val - elif operator == ">=": - return result_value >= filter_val - else: - raise ValueError(f"Unknown comparison operator: {operator}") + return _apply_comparison_operator(result_value, filter_val, operator) except pint.errors.DimensionalityError as e: raise ValueError( f"Incompatible units for Quantity comparison on field '{field_name}': {e}" @@ -1038,30 +982,89 @@ def _compare_values( try: result_ver = Version(str(result_value)) filter_ver = Version(str(filter_val)) - - if operator == "<": - return result_ver < filter_ver - elif operator == "<=": - return result_ver <= filter_ver - elif operator == ">": - return result_ver > filter_ver - elif operator == ">=": - return result_ver >= filter_ver - else: - raise ValueError(f"Unknown comparison operator: {operator}") + return _apply_comparison_operator(result_ver, filter_ver, operator) except (InvalidVersion, TypeError): # Fall back to string comparison result_str = str(result_value) filter_str = str(filter_val) + return _apply_comparison_operator(result_str, filter_str, operator) - if operator == "<": - return result_str < filter_str - elif operator == "<=": - return result_str <= filter_str - elif operator == ">": - return result_str > filter_str - elif operator == ">=": - return result_str >= filter_str - else: - raise ValueError(f"Unknown comparison operator: {operator}") + +def _warn_if_nonsemantic_comparison( + result_value: Any, operator: str, field_name: str +) -> None: + """Warn when comparison operators are used on fields that may not compare semantically.""" + comparison_allowed_fields = { + "date", + "openfe_version", + "openmm_version", + "openff_toolkit_version", + } + if ( + field_name + and field_name not in comparison_allowed_fields + and not field_name.endswith("_version") + and not isinstance(result_value, pint.Quantity) + ): + warnings.warn( + f"Comparison operator '{operator}' used with field '{field_name}'. " + "Comparison operators are designed for date and version fields. " + "Results may not be semantically meaningful for other field types.", + UserWarning, + stacklevel=4, + ) + + +def _coerce_date_values( + result_value: date_type, filter_val: Any +) -> tuple[date_type | str, Any]: + """Coerce date comparisons, preserving fallback-to-string behavior on parse failure.""" + coerced_result_value: date_type | str = result_value + if isinstance(filter_val, str): + try: + # Parse ISO format date string YYYY-MM-DD + filter_val = date_type.fromisoformat(filter_val) + except (ValueError, AttributeError): + # If parsing fails, compare strings to preserve previous behavior + coerced_result_value = result_value.isoformat() + + return coerced_result_value, filter_val + + +def _coerce_quantity_filter_value( + result_value: pint.Quantity, filter_val: Any, field_name: str +) -> Any: + """Convert quantity filter inputs into pint.Quantity using the result value registry.""" + if isinstance(filter_val, str): + try: + ureg = result_value._REGISTRY + return ureg.Quantity(filter_val) + except (ValueError, pint.errors.UndefinedUnitError, AttributeError) as exc: + raise ValueError( + f"Invalid quantity filter value '{filter_val}' for field '{field_name}'. " + "Provide a valid quantity string with units." + ) from exc + + if isinstance(filter_val, pint.Quantity): + return filter_val + + raise ValueError( + f"Invalid filter type '{type(filter_val).__name__}' for Quantity field '{field_name}'. " + "Provide a quantity string or pint.Quantity value." + ) + + +def _apply_comparison_operator(left: Any, right: Any, operator: str) -> bool: + """Apply one of <, <=, >, >= operators to two comparable values.""" + operator_map = { + "<": py_operator.lt, + "<=": py_operator.le, + ">": py_operator.gt, + ">=": py_operator.ge, + } + compare_func = operator_map.get(operator) + if compare_func is None: + raise ValueError(f"Unknown comparison operator: {operator}") + + return compare_func(left, right) diff --git a/openfe_benchmarks/tests/test_benchmark_results.py b/openfe_benchmarks/tests/test_benchmark_results.py index d103a28c..b73b2083 100644 --- a/openfe_benchmarks/tests/test_benchmark_results.py +++ b/openfe_benchmarks/tests/test_benchmark_results.py @@ -12,6 +12,7 @@ import pytest import yaml import time +import pint from cinnabar import FEMap @@ -685,3 +686,84 @@ def test_filter_quantity_invalid_string_raises(): """Test that invalid quantity strings raise ValueError (no silent fallback).""" with pytest.raises(ValueError, match="Invalid quantity filter value"): _ = filter_results(dg=">not_a_quantity") + + +def test_compare_values_list_of_quantities_inequality(mock_submission_yaml): + """Protocol quantities extracted from BenchmarkResults should compare element-wise.""" + ureg = pint.UnitRegistry() + yaml_data = mock_submission_yaml( + "test-tyk2-protocol-quantity-compare", + benchmark_data={"system_name": "tyk2"}, + protocol_settings=[ + {"system_name": "tyk2", "temperature": ureg.Quantity(298.0, "kelvin")}, + ], + ) + submission = BenchmarkResults(**yaml_data) + temperatures = br_module._get_nested_value( + submission, "protocol_settings__temperature" + ) + system_names = br_module._get_nested_value( + submission, "protocol_settings__system_name" + ) + + assert isinstance(temperatures, list) + assert len(temperatures) == 1 + assert system_names == ["tyk2"] + + assert br_module._compare_values( + temperatures, "290 kelvin", ">", "protocol_settings__temperature" + ) + assert br_module._compare_values( + temperatures, "298 kelvin", ">=", "protocol_settings__temperature" + ) + assert not br_module._compare_values( + temperatures, "280 kelvin", "<=", "protocol_settings__temperature" + ) + assert not br_module._compare_values( + temperatures, "350 kelvin", ">", "protocol_settings__temperature" + ) + + +def test_filter_protocol_settings_quantity_inequality(mock_submission_yaml): + """Nested protocol_settings Quantity filters return predictable pass/fail matches.""" + ureg = pint.UnitRegistry() + yaml_data = mock_submission_yaml( + "test-tyk2-protocol-quantity", + benchmark_data={"system_name": "tyk2"}, + protocol_settings=[ + {"system_name": "tyk2", "temperature": ureg.Quantity(298.0, "kelvin")}, + ], + ) + submission = BenchmarkResults(**yaml_data) + + assert br_module._match_submission_filter( + submission, + "benchmark_data__system_name", + "tyk2", + tags_mode="all", + ) + + assert br_module._match_submission_filter( + submission, + "protocol_settings__temperature", + ">290 kelvin", + tags_mode="all", + ) + assert br_module._match_submission_filter( + submission, + "protocol_settings__temperature", + "<=298 kelvin", + tags_mode="all", + ) + assert not br_module._match_submission_filter( + submission, + "protocol_settings__temperature", + "<298 kelvin", + tags_mode="all", + ) + assert not br_module._match_submission_filter( + submission, + "protocol_settings__temperature", + ">350 kelvin", + tags_mode="all", + ) From 466904bae10c1fa0ac39074da61e2f0ff9fec38c Mon Sep 17 00:00:00 2001 From: jaclark5 Date: Wed, 19 Aug 2026 14:32:58 -0400 Subject: [PATCH 11/11] update_example --- examples/4_benchmark_result_plot.ipynb | 44 +++++++++++++------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/examples/4_benchmark_result_plot.ipynb b/examples/4_benchmark_result_plot.ipynb index 1173ecb6..0e4b996c 100644 --- a/examples/4_benchmark_result_plot.ipynb +++ b/examples/4_benchmark_result_plot.ipynb @@ -67,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 2, "id": "ac74c674", "metadata": {}, "outputs": [ @@ -125,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 3, "id": "78b4d820", "metadata": {}, "outputs": [ @@ -137,7 +137,7 @@ "Submissions since 2026-01-01: 8\n", "Submissions on/before 2026-08-01: 3\n", "Submissions with openfe_version > 2.3.0: 1\n", - "Non-pontibus submissions: 7\n" + "Non-pontibus submissions: 4\n" ] } ], @@ -183,7 +183,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026-08-19 13:20:41 - openfe_benchmarks.results._benchmark_results - WARNING - Skipping submission '2026-08-04-openff3.0.0-alpha1b_opc3-jacs' during filtering: Results file not found: /Users/jenniferclark/bin/openfe-benchmarks/openfe_benchmarks/results/2026-08-04-openff3.0.0-alpha1b_opc3-jacs/computational_results.json\n" + "2026-08-19 14:31:57 - openfe_benchmarks.results._benchmark_results - WARNING - Skipping submission '2026-08-04-openff3.0.0-alpha1b_opc3-jacs' during filtering: Results file not found: /Users/jenniferclark/bin/openfe-benchmarks/openfe_benchmarks/results/2026-08-04-openff3.0.0-alpha1b_opc3-jacs/computational_results.json\n" ] }, { @@ -220,7 +220,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 5, "id": "935728ac", "metadata": {}, "outputs": [ @@ -288,7 +288,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 6, "id": "5d156d4b", "metadata": {}, "outputs": [ @@ -296,9 +296,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026-08-19 13:27:04 - openfe_benchmarks.results._benchmark_results - WARNING - Skipping submission '2026-08-04-openff3.0.0-alpha1b_opc3-jacs' during filtering: Results file not found: /Users/jenniferclark/bin/openfe-benchmarks/openfe_benchmarks/results/2026-08-04-openff3.0.0-alpha1b_opc3-jacs/computational_results.json\n", - "2026-08-19 13:27:04 - openfe_benchmarks.results._benchmark_results - INFO - Computing FEMaps for dg results - first access may be slow\n", - "2026-08-19 13:27:04 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'freesolv' from benchmark set 'solvation_set' with:\n", + "2026-08-19 14:31:57 - openfe_benchmarks.results._benchmark_results - WARNING - Skipping submission '2026-08-04-openff3.0.0-alpha1b_opc3-jacs' during filtering: Results file not found: /Users/jenniferclark/bin/openfe-benchmarks/openfe_benchmarks/results/2026-08-04-openff3.0.0-alpha1b_opc3-jacs/computational_results.json\n", + "2026-08-19 14:31:58 - openfe_benchmarks.results._benchmark_results - INFO - Computing FEMaps for dg results - first access may be slow\n", + "2026-08-19 14:31:58 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'freesolv' from benchmark set 'solvation_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: False.\n", " Found 0 ligand network files with keys: \n" @@ -315,7 +315,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -361,7 +361,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 7, "id": "3df2a51c", "metadata": {}, "outputs": [ @@ -369,37 +369,37 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026-08-19 13:30:55 - openfe_benchmarks.results._benchmark_results - WARNING - Skipping submission '2026-08-04-openff3.0.0-alpha1b_opc3-jacs' during filtering: Results file not found: /Users/jenniferclark/bin/openfe-benchmarks/openfe_benchmarks/results/2026-08-04-openff3.0.0-alpha1b_opc3-jacs/computational_results.json\n", - "2026-08-19 13:30:55 - openfe_benchmarks.results._benchmark_results - INFO - Computing FEMaps for ddg results - first access may be slow\n", - "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'jnk1' from benchmark set 'jacs_set' with:\n", + "2026-08-19 14:31:59 - openfe_benchmarks.results._benchmark_results - WARNING - Skipping submission '2026-08-04-openff3.0.0-alpha1b_opc3-jacs' during filtering: Results file not found: /Users/jenniferclark/bin/openfe-benchmarks/openfe_benchmarks/results/2026-08-04-openff3.0.0-alpha1b_opc3-jacs/computational_results.json\n", + "2026-08-19 14:32:00 - openfe_benchmarks.results._benchmark_results - INFO - Computing FEMaps for ddg results - first access may be slow\n", + "2026-08-19 14:32:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'jnk1' from benchmark set 'jacs_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: True.\n", " Found 1 ligand network files with keys: industry_benchmarks_network\n", - "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'thrombin' from benchmark set 'jacs_set' with:\n", + "2026-08-19 14:32:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'thrombin' from benchmark set 'jacs_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: True.\n", " Found 1 ligand network files with keys: industry_benchmarks_network\n", - "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'cdk2' from benchmark set 'jacs_set' with:\n", + "2026-08-19 14:32:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'cdk2' from benchmark set 'jacs_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: True.\n", " Found 1 ligand network files with keys: industry_benchmarks_network\n", - "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'bace' from benchmark set 'jacs_set' with:\n", + "2026-08-19 14:32:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'bace' from benchmark set 'jacs_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: True.\n", " Found 1 ligand network files with keys: industry_benchmarks_network\n", - "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'ptp1b' from benchmark set 'jacs_set' with:\n", + "2026-08-19 14:32:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'ptp1b' from benchmark set 'jacs_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: True.\n", " Found 1 ligand network files with keys: industry_benchmarks_network\n", - "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'tyk2' from benchmark set 'jacs_set' with:\n", + "2026-08-19 14:32:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'tyk2' from benchmark set 'jacs_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: True.\n", " Found 1 ligand network files with keys: industry_benchmarks_network\n", - "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'mcl1' from benchmark set 'jacs_set' with:\n", + "2026-08-19 14:32:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'mcl1' from benchmark set 'jacs_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: True.\n", " Found 1 ligand network files with keys: industry_benchmarks_network\n", - "2026-08-19 13:30:55 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'p38' from benchmark set 'jacs_set' with:\n", + "2026-08-19 14:32:00 - openfe_benchmarks.data._benchmark_systems - INFO - Loaded system 'p38' from benchmark set 'jacs_set' with:\n", " 5 ligand file(s), and 0 cofactor file(s).\n", " Found protein file: True.\n", " Found 1 ligand network files with keys: industry_benchmarks_network\n" @@ -417,7 +417,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ]