Add OddsPath Property to ScoreRange Data Model

Adds an `OddsPath` property to the score range data model. This property is optional. If it is given, it should contain a `ratios` object with `abnormal` and `normal` (both floats), a `evidenceStrengths` property with `normal` and `abnormal` (both strings), and an optional `source` field.

Uses the PublicationIdentifierBase view model for the OddsPath source. Adds a validator to the score set
record that enforces this publication identifier has been included with the score set as either a primary
or secondary publication identifier. Adds tests for this check and to ensure publications are added successfully.

Author: bencap

src/mavedb/view_models/odds_path.py

@@ -0,0 +1,40 @@
+from typing import Literal, Optional, Sequence
+
+from mavedb.view_models import record_type_validator, set_record_type
+from mavedb.view_models.base.base import BaseModel
+from mavedb.view_models.publication_identifier import PublicationIdentifierBase
+
+
+class OddsPathRatio(BaseModel):
+    normal: float
+    abnormal: float
+
+
+class OddsPathEvidenceStrengths(BaseModel):
+    normal: Literal["BS3_STRONG"]
+    abnormal: Literal["PS3_STRONG"]
+
+
+class OddsPathBase(BaseModel):
+    ratios: OddsPathRatio
+    evidence_strengths: OddsPathEvidenceStrengths
+
+
+class OddsPathModify(OddsPathBase):
+    source: Optional[list[PublicationIdentifierBase]] = None
+
+
+class OddsPathCreate(OddsPathModify):
+    pass
+
+
+class SavedOddsPath(OddsPathBase):
+    record_type: str = None  # type: ignore
+
+    source: Optional[Sequence[PublicationIdentifierBase]] = None
+
+    _record_type_factory = record_type_validator()(set_record_type)
+
+
+class OddsPath(SavedOddsPath):
+    pass

src/mavedb/view_models/score_set.py

@@ -21,6 +21,7 @@
     DoiIdentifierCreate,
     SavedDoiIdentifier,
 )
+from mavedb.view_models.odds_path import OddsPath
 from mavedb.view_models.license import ShortLicense
 from mavedb.view_models.publication_identifier import (
     PublicationIdentifier,
@@ -79,6 +80,7 @@ def ranges_are_not_backwards(cls, field_value: tuple[Any]):
 class ScoreRanges(BaseModel):
     wt_score: Optional[float]
     ranges: list[ScoreRange]  # type: ignore
+    odds_path: Optional[OddsPath] = None
 
 
 class ScoreSetGetter(PublicationIdentifiersGetter):
@@ -292,6 +294,35 @@ def wild_type_score_in_normal_range(cls, field_value: Optional[ScoreRanges]):
             custom_loc=["body", "scoreRanges", "wtScore"],
         )
 
+    @root_validator()
+    def validate_score_range_odds_path_source_in_publication_identifiers(cls, values):
+        score_ranges: Optional[ScoreRanges] = values.get("score_ranges")
+        if values.get("score_ranges") is None or score_ranges.odds_path is None:
+            return values
+
+        if score_ranges.odds_path.source is None or len(score_ranges.odds_path.source) == 0:
+            return values
+
+        for idx, pub in enumerate(score_ranges.odds_path.source):
+            primary_publication_identifiers = (
+                values.get("primary_publication_identifiers", [])
+                if values.get("primary_publication_identifiers")
+                else []
+            )
+            secondary_publication_identifiers = (
+                values.get("secondary_publication_identifiers", [])
+                if values.get("secondary_publication_identifiers")
+                else []
+            )
+            if pub not in [*primary_publication_identifiers, *secondary_publication_identifiers]:
+                raise ValidationError(
+                    f"Odds path source publication identifier at index {idx} is not defined in score set publications. "
+                    "To use a publication identifier in the odds path source, it must be defined in the primary or secondary publication identifiers.",
+                    custom_loc=["body", "scoreRanges", "oddsPath", "source", idx],
+                )
+
+        return values
+
 
 class ScoreSetCreate(ScoreSetModify):
     """View model for creating a new score set."""

tests/helpers/constants.py

@@ -862,12 +862,66 @@
 }
 
 
+TEST_ODDS_PATH = {
+    "ratios": {
+        "normal": 0.5,
+        "abnormal": 5.0,
+    },
+    "evidence_strengths": {
+        "normal": "BS3_STRONG",
+        "abnormal": "PS3_STRONG",
+    },
+    "source": None,
+}
+
+
+TEST_SAVED_ODDS_PATH = {
+    "recordType": "OddsPath",
+    "ratios": {
+        "normal": 0.5,
+        "abnormal": 5.0,
+    },
+    "evidenceStrengths": {
+        "normal": "BS3_STRONG",
+        "abnormal": "PS3_STRONG",
+    },
+}
+
+
+TEST_ODDS_PATH_WITH_SOURCE = {
+    "ratios": {
+        "normal": 0.5,
+        "abnormal": 5.0,
+    },
+    "evidence_strengths": {
+        "normal": "BS3_STRONG",
+        "abnormal": "PS3_STRONG",
+    },
+    "source": [{"identifier": TEST_PUBMED_IDENTIFIER, "db_name": "PubMed"}],
+}
+
+
+TEST_SAVED_ODDS_PATH_WITH_SOURCE = {
+    "recordType": "OddsPath",
+    "ratios": {
+        "normal": 0.5,
+        "abnormal": 5.0,
+    },
+    "evidenceStrengths": {
+        "normal": "BS3_STRONG",
+        "abnormal": "PS3_STRONG",
+    },
+    "source": [{"identifier": TEST_PUBMED_IDENTIFIER, "dbName": "PubMed"}],
+}
+
+
 TEST_SCORE_SET_RANGE = {
     "wt_score": 1.0,
     "ranges": [
         {"label": "test1", "classification": "normal", "range": (0, 2.0)},
         {"label": "test2", "classification": "abnormal", "range": (-2.0, 0)},
     ],
+    "odds_path": None,
 }
 
 
@@ -880,6 +934,46 @@
 }
 
 
+TEST_SCORE_SET_RANGE_WITH_ODDS_PATH = {
+    "wt_score": 1.0,
+    "ranges": [
+        {"label": "test1", "classification": "normal", "range": (0, 2.0)},
+        {"label": "test2", "classification": "abnormal", "range": (-2.0, 0)},
+    ],
+    "odds_path": TEST_ODDS_PATH,
+}
+
+
+TEST_SAVED_SCORE_SET_RANGE_WITH_ODDS_PATH = {
+    "wtScore": 1.0,
+    "ranges": [
+        {"label": "test1", "classification": "normal", "range": [0.0, 2.0]},
+        {"label": "test2", "classification": "abnormal", "range": [-2.0, 0.0]},
+    ],
+    "oddsPath": TEST_SAVED_ODDS_PATH,
+}
+
+
+TEST_SCORE_SET_RANGE_WITH_ODDS_PATH_AND_SOURCE = {
+    "wt_score": 1.0,
+    "ranges": [
+        {"label": "test1", "classification": "normal", "range": (0, 2.0)},
+        {"label": "test2", "classification": "abnormal", "range": (-2.0, 0)},
+    ],
+    "odds_path": TEST_ODDS_PATH_WITH_SOURCE,
+}
+
+
+TEST_SAVED_SCORE_SET_RANGE_WITH_ODDS_PATH_AND_SOURCE = {
+    "wtScore": 1.0,
+    "ranges": [
+        {"label": "test1", "classification": "normal", "range": [0.0, 2.0]},
+        {"label": "test2", "classification": "abnormal", "range": [-2.0, 0.0]},
+    ],
+    "oddsPath": TEST_SAVED_ODDS_PATH_WITH_SOURCE,
+}
+
+
 TEST_SCORE_CALIBRATION = {
     "parameter_sets": [
         {

tests/routers/test_score_set.py

@@ -32,9 +32,11 @@
     TEST_MINIMAL_SEQ_SCORESET_RESPONSE,
     TEST_PUBMED_IDENTIFIER,
     TEST_ORCID_ID,
+    TEST_SAVED_SCORE_SET_RANGE_WITH_ODDS_PATH_AND_SOURCE,
     TEST_SCORE_SET_RANGE,
     TEST_SAVED_SCORE_SET_RANGE,
     TEST_MINIMAL_ACC_SCORESET_RESPONSE,
+    TEST_SCORE_SET_RANGE_WITH_ODDS_PATH_AND_SOURCE,
     TEST_USER,
     TEST_INACTIVE_LICENSE,
     SAVED_DOI_IDENTIFIER,
@@ -45,6 +47,8 @@
     TEST_SAVED_SCORE_CALIBRATION,
     TEST_SAVED_CLINVAR_CONTROL,
     TEST_SAVED_GENERIC_CLINICAL_CONTROL,
+    TEST_SCORE_SET_RANGE_WITH_ODDS_PATH,
+    TEST_SAVED_SCORE_SET_RANGE_WITH_ODDS_PATH,
 )
 from tests.helpers.dependency_overrider import DependencyOverrider
 from tests.helpers.util.common import update_expected_response_for_created_resources
@@ -141,11 +145,18 @@ def test_create_score_set_with_contributor(client, setup_router_db):
     assert response.status_code == 200
 
 
-def test_create_score_set_with_score_range(client, setup_router_db):
+@pytest.mark.parametrize(
+    "score_ranges,saved_score_ranges",
+    [
+        (TEST_SCORE_SET_RANGE, TEST_SAVED_SCORE_SET_RANGE),
+        (TEST_SCORE_SET_RANGE_WITH_ODDS_PATH, TEST_SAVED_SCORE_SET_RANGE_WITH_ODDS_PATH),
+    ],
+)
+def test_create_score_set_with_score_range(client, setup_router_db, score_ranges, saved_score_ranges):
     experiment = create_experiment(client)
     score_set = deepcopy(TEST_MINIMAL_SEQ_SCORESET)
     score_set["experimentUrn"] = experiment["urn"]
-    score_set.update({"score_ranges": TEST_SCORE_SET_RANGE})
+    score_set.update({"score_ranges": score_ranges})
 
     response = client.post("/api/v1/score-sets/", json=score_set)
     assert response.status_code == 200
@@ -157,7 +168,7 @@ def test_create_score_set_with_score_range(client, setup_router_db):
     expected_response = update_expected_response_for_created_resources(
         deepcopy(TEST_MINIMAL_SEQ_SCORESET_RESPONSE), experiment, response_data
     )
-    expected_response["scoreRanges"] = TEST_SAVED_SCORE_SET_RANGE
+    expected_response["scoreRanges"] = saved_score_ranges
 
     assert sorted(expected_response.keys()) == sorted(response_data.keys())
     for key in expected_response:
@@ -167,6 +178,60 @@ def test_create_score_set_with_score_range(client, setup_router_db):
     assert response.status_code == 200
 
 
+@pytest.mark.parametrize("publication_list", ["primary_publication_identifiers", "secondary_publication_identifiers"])
+@pytest.mark.parametrize(
+    "mock_publication_fetch",
+    [({"dbName": "PubMed", "identifier": f"{TEST_PUBMED_IDENTIFIER}"})],
+    indirect=["mock_publication_fetch"],
+)
+def test_create_score_set_with_score_range_and_odds_path_source(
+    client, setup_router_db, publication_list, mock_publication_fetch
+):
+    experiment = create_experiment(client)
+    score_set = deepcopy(TEST_MINIMAL_SEQ_SCORESET)
+    score_set["experimentUrn"] = experiment["urn"]
+    score_set[publication_list] = TEST_SCORE_SET_RANGE_WITH_ODDS_PATH_AND_SOURCE["odds_path"]["source"]
+    score_set.update({"score_ranges": TEST_SCORE_SET_RANGE_WITH_ODDS_PATH_AND_SOURCE})
+
+    response = client.post("/api/v1/score-sets/", json=score_set)
+    assert response.status_code == 200
+    response_data = response.json()
+
+    jsonschema.validate(instance=response_data, schema=ScoreSet.schema())
+    assert isinstance(MAVEDB_TMP_URN_RE.fullmatch(response_data["urn"]), re.Match)
+
+    expected_response = update_expected_response_for_created_resources(
+        deepcopy(TEST_MINIMAL_SEQ_SCORESET_RESPONSE), experiment, response_data
+    )
+    expected_response[camelize(publication_list)] = [SAVED_PUBMED_PUBLICATION]
+    expected_response["scoreRanges"] = TEST_SAVED_SCORE_SET_RANGE_WITH_ODDS_PATH_AND_SOURCE
+
+    assert sorted(expected_response.keys()) == sorted(response_data.keys())
+    for key in expected_response:
+        assert (key, expected_response[key]) == (key, response_data[key])
+
+    response = client.get(f"/api/v1/score-sets/{response_data['urn']}")
+    assert response.status_code == 200
+
+
+def test_cannot_create_score_set_with_score_range_and_odds_path_source_when_publication_not_in_publications(
+    client, setup_router_db
+):
+    experiment = create_experiment(client)
+    score_set = deepcopy(TEST_MINIMAL_SEQ_SCORESET)
+    score_set["experimentUrn"] = experiment["urn"]
+    score_set.update({"score_ranges": TEST_SCORE_SET_RANGE_WITH_ODDS_PATH_AND_SOURCE})
+
+    response = client.post("/api/v1/score-sets/", json=score_set)
+    assert response.status_code == 422
+
+    response_data = response.json()
+    assert (
+        "Odds path source publication identifier at index 0 is not defined in score set publications."
+        in response_data["detail"][0]["msg"]
+    )
+
+
 def test_remove_score_range_from_score_set(client, setup_router_db):
     experiment = create_experiment(client)
     score_set = deepcopy(TEST_MINIMAL_SEQ_SCORESET)
@@ -1166,7 +1231,9 @@ def test_multiple_score_set_meta_analysis_single_experiment(
     )
 
     published_score_set_1_refresh = (client.get(f"/api/v1/score-sets/{published_score_set_1['urn']}")).json()
-    assert meta_score_set["metaAnalyzesScoreSetUrns"] == sorted([published_score_set_1["urn"], published_score_set_2["urn"]])
+    assert meta_score_set["metaAnalyzesScoreSetUrns"] == sorted(
+        [published_score_set_1["urn"], published_score_set_2["urn"]]
+    )
     assert published_score_set_1_refresh["metaAnalyzedByScoreSetUrns"] == [meta_score_set["urn"]]
 
     with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:

tests/view_models/test_score_set.py

@@ -3,7 +3,12 @@
 from mavedb.view_models.publication_identifier import PublicationIdentifierCreate
 from mavedb.view_models.score_set import ScoreSetCreate, ScoreSetModify
 from mavedb.view_models.target_gene import TargetGeneCreate
-from tests.helpers.constants import TEST_MINIMAL_ACC_SCORESET, TEST_MINIMAL_SEQ_SCORESET
+from tests.helpers.constants import (
+    TEST_MINIMAL_ACC_SCORESET,
+    TEST_MINIMAL_SEQ_SCORESET,
+    TEST_SCORE_SET_RANGE_WITH_ODDS_PATH,
+    TEST_SCORE_SET_RANGE_WITH_ODDS_PATH_AND_SOURCE,
+)
 
 
 def test_cannot_create_score_set_without_a_target():
@@ -494,6 +499,35 @@ def test_can_create_score_set_with_any_range_classification(classification):
     ScoreSetModify(**score_set_test)
 
 
+def test_can_create_score_set_with_odds_path_in_score_ranges():
+    score_set_test = TEST_MINIMAL_SEQ_SCORESET.copy()
+    score_set_test["score_ranges"] = TEST_SCORE_SET_RANGE_WITH_ODDS_PATH.copy()
+
+    ScoreSetModify(**score_set_test)
+
+
+def test_can_create_score_set_with_odds_path_and_source_in_score_ranges():
+    score_set_test = TEST_MINIMAL_SEQ_SCORESET.copy()
+    score_set_test["primary_publication_identifiers"] = TEST_SCORE_SET_RANGE_WITH_ODDS_PATH_AND_SOURCE["odds_path"][
+        "source"
+    ]
+    score_set_test["score_ranges"] = TEST_SCORE_SET_RANGE_WITH_ODDS_PATH_AND_SOURCE.copy()
+
+    ScoreSetModify(**score_set_test)
+
+
+def test_cannot_create_score_set_with_odds_path_and_source_in_score_ranges_if_source_not_in_score_set_publications():
+    score_set_test = TEST_MINIMAL_SEQ_SCORESET.copy()
+    score_set_test["score_ranges"] = TEST_SCORE_SET_RANGE_WITH_ODDS_PATH_AND_SOURCE.copy()
+
+    with pytest.raises(ValueError) as exc_info:
+        ScoreSetModify(**score_set_test)
+
+    assert "Odds path source publication identifier at index 0 is not defined in score set publications." in str(
+        exc_info.value
+    )
+
+
 def test_cannot_create_score_set_with_inconsistent_base_editor_flags():
     score_set_test = TEST_MINIMAL_ACC_SCORESET.copy()