fix: robust synthetic property handling for score calibrations

- Refactored ScoreCalibration view models to ensure robust handling of synthetic and required fields for both ORM and dict contexts.
- Made the source fields non-optional to enforce required data integrity.
- Added tests to verify all key attributes and synthetic properties are correctly handled in both construction modes.
- Ensured creation from both dict and ORM contexts, mirroring the approach used for other models.

Author: bencap

src/mavedb/view_models/score_calibration.py

@@ -184,9 +184,9 @@ class ScoreCalibrationBase(BaseModel):
     notes: Optional[str] = None
 
     functional_ranges: Optional[Sequence[FunctionalRangeBase]] = None
-    threshold_sources: Optional[Sequence[PublicationIdentifierBase]] = None
-    classification_sources: Optional[Sequence[PublicationIdentifierBase]] = None
-    method_sources: Optional[Sequence[PublicationIdentifierBase]] = None
+    threshold_sources: Sequence[PublicationIdentifierBase]
+    classification_sources: Sequence[PublicationIdentifierBase]
+    method_sources: Sequence[PublicationIdentifierBase]
     calibration_metadata: Optional[dict] = None
 
     @field_validator("functional_ranges")
@@ -278,18 +278,18 @@ class ScoreCalibrationModify(ScoreCalibrationBase):
     score_set_urn: Optional[str] = None
 
     functional_ranges: Optional[Sequence[FunctionalRangeModify]] = None
-    threshold_sources: Optional[Sequence[PublicationIdentifierCreate]] = None
-    classification_sources: Optional[Sequence[PublicationIdentifierCreate]] = None
-    method_sources: Optional[Sequence[PublicationIdentifierCreate]] = None
+    threshold_sources: Sequence[PublicationIdentifierCreate]
+    classification_sources: Sequence[PublicationIdentifierCreate]
+    method_sources: Sequence[PublicationIdentifierCreate]
 
 
 class ScoreCalibrationCreate(ScoreCalibrationModify):
     """Model used to create a new score calibration."""
 
     functional_ranges: Optional[Sequence[FunctionalRangeCreate]] = None
-    threshold_sources: Optional[Sequence[PublicationIdentifierCreate]] = None
-    classification_sources: Optional[Sequence[PublicationIdentifierCreate]] = None
-    method_sources: Optional[Sequence[PublicationIdentifierCreate]] = None
+    threshold_sources: Sequence[PublicationIdentifierCreate]
+    classification_sources: Sequence[PublicationIdentifierCreate]
+    method_sources: Sequence[PublicationIdentifierCreate]
 
 
 class SavedScoreCalibration(ScoreCalibrationBase):
@@ -307,9 +307,9 @@ class SavedScoreCalibration(ScoreCalibrationBase):
     private: bool = True
 
     functional_ranges: Optional[Sequence[SavedFunctionalRange]] = None
-    threshold_sources: Optional[Sequence[SavedPublicationIdentifier]] = None
-    classification_sources: Optional[Sequence[SavedPublicationIdentifier]] = None
-    method_sources: Optional[Sequence[SavedPublicationIdentifier]] = None
+    threshold_sources: Sequence[SavedPublicationIdentifier]
+    classification_sources: Sequence[SavedPublicationIdentifier]
+    method_sources: Sequence[SavedPublicationIdentifier]
 
     created_by: Optional[SavedUser] = None
     modified_by: Optional[SavedUser] = None
@@ -327,9 +327,6 @@ class Config:
     @field_validator("threshold_sources", "classification_sources", "method_sources", mode="before")
     def publication_identifiers_validator(cls, value: Any) -> Optional[list[PublicationIdentifier]]:
         """Coerce association proxy collections to plain lists."""
-        if value is None:
-            return None
-
         assert isinstance(value, Collection), "Publication identifier lists must be a collection"
         return list(value)
 
@@ -354,29 +351,23 @@ def primary_calibrations_may_not_be_private(self: "SavedScoreCalibration") -> "S
 
         return self
 
+    # These 'synthetic' fields are generated from other model properties. Transform data from other properties as needed, setting
+    # the appropriate field on the model itself. Then, proceed with Pydantic ingestion once fields are created. Only perform these
+    # transformations if the relevant attributes are present on the input data (i.e., when creating from an ORM object).
     @model_validator(mode="before")
     def generate_threshold_classification_and_method_sources(cls, data: Any):  # type: ignore[override]
         """Populate threshold/classification/method source fields from association objects if missing."""
-        association_keys = {
-            "threshold_sources",
-            "thresholdSources",
-            "classification_sources",
-            "classificationSources",
-            "method_sources",
-            "methodSources",
-        }
-
-        if not any(hasattr(data, key) for key in association_keys):
+        if hasattr(data, "publication_identifier_associations"):
             try:
                 publication_identifiers = transform_score_calibration_publication_identifiers(
                     data.publication_identifier_associations
                 )
                 data.__setattr__("threshold_sources", publication_identifiers["threshold_sources"])
                 data.__setattr__("classification_sources", publication_identifiers["classification_sources"])
                 data.__setattr__("method_sources", publication_identifiers["method_sources"])
-            except AttributeError as exc:
+            except (AttributeError, KeyError) as exc:
                 raise ValidationError(
-                    f"Unable to create {cls.__name__} without attribute: {exc}."  # type: ignore
+                    f"Unable to coerce publication associations for {cls.__name__}: {exc}."  # type: ignore
                 )
         return data
 
@@ -385,9 +376,9 @@ class ScoreCalibration(SavedScoreCalibration):
     """Complete score calibration model returned by the API."""
 
     functional_ranges: Optional[Sequence[FunctionalRange]] = None
-    threshold_sources: Optional[Sequence[PublicationIdentifier]] = None
-    classification_sources: Optional[Sequence[PublicationIdentifier]] = None
-    method_sources: Optional[Sequence[PublicationIdentifier]] = None
+    threshold_sources: Sequence[PublicationIdentifier]
+    classification_sources: Sequence[PublicationIdentifier]
+    method_sources: Sequence[PublicationIdentifier]
     created_by: Optional[User] = None
     modified_by: Optional[User] = None
 
@@ -399,11 +390,11 @@ class ScoreCalibrationWithScoreSetUrn(SavedScoreCalibration):
 
     @model_validator(mode="before")
     def generate_score_set_urn(cls, data: Any):
-        if not hasattr(data, "score_set_urn"):
+        if hasattr(data, "score_set"):
             try:
                 data.__setattr__("score_set_urn", transform_score_set_to_urn(data.score_set))
-            except AttributeError as exc:
+            except (AttributeError, KeyError) as exc:
                 raise ValidationError(
-                    f"Unable to create {cls.__name__} without attribute: {exc}."  # type: ignore
+                    f"Unable to coerce score set urn for {cls.__name__}: {exc}."  # type: ignore
                 )
         return data

tests/helpers/constants.py

@@ -1561,8 +1561,8 @@
         TEST_FUNCTIONAL_RANGE_ABNORMAL,
     ],
     "threshold_sources": [{"identifier": TEST_PUBMED_IDENTIFIER, "db_name": "PubMed"}],
-    "classification_sources": None,
-    "method_sources": None,
+    "classification_sources": [],
+    "method_sources": [],
     "calibration_metadata": {},
 }
 
@@ -1578,8 +1578,8 @@
         TEST_SAVED_FUNCTIONAL_RANGE_ABNORMAL,
     ],
     "thresholdSources": [SAVED_PUBMED_PUBLICATION],
-    "classificationSources": None,
-    "methodSources": None,
+    "classificationSources": [],
+    "methodSources": [],
     "id": 2,
     "investigatorProvided": True,
     "primary": False,

tests/view_models/test_score_calibration.py

@@ -392,13 +392,20 @@ def test_can_create_valid_score_calibration_from_attributed_object(valid_calibra
 
 def test_cannot_create_score_calibration_when_publication_information_is_missing():
     invalid_data = deepcopy(TEST_SAVED_BRNICH_SCORE_CALIBRATION)
+
     # Add publication identifiers with missing information
     invalid_data.pop("thresholdSources", None)
     invalid_data.pop("classificationSources", None)
     invalid_data.pop("methodSources", None)
-    with pytest.raises(ValidationError, match="Unable to create ScoreCalibration without attribute"):
+
+    with pytest.raises(ValidationError) as exc_info:
         ScoreCalibration.model_validate(dummy_attributed_object_from_dict(invalid_data))
 
+    assert "Field required" in str(exc_info.value)
+    assert "thresholdSources" in str(exc_info.value)
+    assert "classificationSources" in str(exc_info.value)
+    assert "methodSources" in str(exc_info.value)
+
 
 def test_can_create_score_calibration_from_association_style_publication_identifiers_against_attributed_object():
     orig_data = TEST_SAVED_BRNICH_SCORE_CALIBRATION
@@ -480,6 +487,24 @@ def test_primary_score_calibration_cannot_be_private():
         ScoreCalibration.model_validate(dummy_attributed_object_from_dict(invalid_data))
 
 
+def test_can_create_score_calibration_from_non_orm_context():
+    data = deepcopy(TEST_SAVED_BRNICH_SCORE_CALIBRATION)
+
+    sc = ScoreCalibration.model_validate(data)
+
+    assert sc.title == data["title"]
+    assert sc.research_use_only == data.get("researchUseOnly", False)
+    assert sc.primary == data.get("primary", False)
+    assert sc.investigator_provided == data.get("investigatorProvided", False)
+    assert sc.baseline_score == data.get("baselineScore")
+    assert sc.baseline_score_description == data.get("baselineScoreDescription")
+    assert len(sc.functional_ranges) == len(data["functionalRanges"])
+    assert len(sc.threshold_sources) == len(data["thresholdSources"])
+    assert len(sc.classification_sources) == len(data["classificationSources"])
+    assert len(sc.method_sources) == len(data["methodSources"])
+    assert sc.calibration_metadata == data.get("calibrationMetadata")
+
+
 def test_score_calibration_with_score_set_urn_can_be_created_from_attributed_object():
     data = deepcopy(TEST_SAVED_BRNICH_SCORE_CALIBRATION)
     data["score_set"] = dummy_attributed_object_from_dict({"urn": "urn:mavedb:00000000-0000-0000-0000-000000000001"})
@@ -493,5 +518,15 @@ def test_score_calibration_with_score_set_urn_can_be_created_from_attributed_obj
 def test_score_calibration_with_score_set_urn_cannot_be_created_without_score_set_urn():
     invalid_data = deepcopy(TEST_SAVED_BRNICH_SCORE_CALIBRATION)
     invalid_data["score_set"] = dummy_attributed_object_from_dict({})
-    with pytest.raises(ValidationError, match="Unable to create ScoreCalibrationWithScoreSetUrn without attribute"):
+    with pytest.raises(ValidationError, match="Unable to coerce score set urn for ScoreCalibrationWithScoreSetUrn"):
         ScoreCalibrationWithScoreSetUrn.model_validate(dummy_attributed_object_from_dict(invalid_data))
+
+
+def test_score_calibration_with_score_set_urn_can_be_created_from_non_orm_context():
+    data = deepcopy(TEST_SAVED_BRNICH_SCORE_CALIBRATION)
+    data["score_set_urn"] = "urn:mavedb:00000000-0000-0000-0000-000000000001"
+
+    sc = ScoreCalibrationWithScoreSetUrn.model_validate(data)
+
+    assert sc.title == data["title"]
+    assert sc.score_set_urn == data["score_set_urn"]