Assign meta-analysis score sets to special experiments not created by any user.

**Changes**

- An experiment URL must be provided when the score set is not a meta-analysis, and it must not be provided when the score set is a meta-analysis.
- When creating a meta-analysis, the API looks for any existing meta-analysis with the same set of underlying source score sets.
  - If one exists, it assigns the new meta-analysis to the same experiment.
  - Otherwise, it creates a new experiment using the score set's title, short description, abstract, and methods (but not its extra JSON metadata).

Author: jstone-dev

src/mavedb/lib/score_sets.py

@@ -4,7 +4,7 @@
 import pandas as pd
 from pandas.testing import assert_index_equal
 from sqlalchemy import func, or_
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import Session, aliased
 
 from mavedb.lib.array_comparison import assert_array_equal
 from mavedb.lib.exceptions import ValidationError
@@ -79,6 +79,36 @@ def search_score_sets(db: Session, owner: Optional[User], search: ScoreSetsSearc
     return score_sets  # filter_visible_score_sets(score_sets)
 
 
+def find_meta_analyses_for_score_sets(db: Session, urns: list[str]) -> list[ScoreSet]:
+    """
+    Find all score sets that are meta-analyses for a specified collection of other score sets.
+
+    :param db: An active database session.
+    :param urns: A list of score set URNS.
+    :return: A score set that is a meta-analysis for exactly the collection of score sets specified by urns; or None if
+      there is no such meta-analysis.
+    """
+    # Ensure that URNs are not repeated in the list.
+    urns = list(set(urns))
+
+    # Find all score sets that are meta-analyses for a superset of the specified URNs and are meta-analysises for
+    # exactly len(urns) score sets.
+    score_set_aliases = [aliased(ScoreSet) for urn in urns]
+    analyzed_score_set = aliased(ScoreSet)
+    urn_filters = [
+        ScoreSet.meta_analysis_source_score_sets.of_type(score_set_aliases[i]).any(score_set_aliases[i].urn == urn)
+        for i, urn in enumerate(urns)
+    ]
+    return (
+        db.query(ScoreSet)
+        .join(ScoreSet.meta_analysis_source_score_sets.of_type(analyzed_score_set))
+        .filter(*urn_filters)
+        .group_by(ScoreSet)
+        .having(func.count(analyzed_score_set.id) == len(urns))
+        .all()
+    )
+
+
 def filter_visible_score_sets(items: list[ScoreSet]):
     # TODO Take the user into account.
     return filter(lambda item: not item.private, items or [])

src/mavedb/routers/score_sets.py

@@ -22,7 +22,12 @@
     find_or_create_doi_identifier,
     find_or_create_publication_identifier,
 )
-from mavedb.lib.score_sets import create_variants_data, search_score_sets as _search_score_sets, VariantData
+from mavedb.lib.score_sets import (
+    create_variants_data,
+    search_score_sets as _search_score_sets,
+    VariantData,
+    find_meta_analyses_for_score_sets,
+)
 from mavedb.lib.urns import generate_experiment_set_urn, generate_experiment_urn, generate_score_set_urn
 from mavedb.lib.validation import exceptions
 from mavedb.lib.validation.constants.general import null_values_list
@@ -100,7 +105,9 @@ def search_my_score_sets(
 
 
 @router.get("/score-sets/{urn}", status_code=200, response_model=score_set.ScoreSet, responses={404: {}, 500: {}})
-async def show_score_set(*, urn: str, db: Session = Depends(deps.get_db), user: User = Depends(get_current_user)) -> Any:
+async def show_score_set(
+    *, urn: str, db: Session = Depends(deps.get_db), user: User = Depends(get_current_user)
+) -> Any:
     """
     Fetch a single score set by URN.
     """
@@ -198,9 +205,30 @@ async def create_score_set(
     if item_create is None:
         return None
 
-    experiment = db.query(Experiment).filter(Experiment.urn == item_create.experiment_urn).one_or_none()
-    if not experiment:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Unknown experiment")
+    experiment: Experiment = None
+    if item_create.experiment_urn is not None:
+        experiment = db.query(Experiment).filter(Experiment.urn == item_create.experiment_urn).one_or_none()
+        if not experiment:
+            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Unknown experiment")
+    if (
+        item_create.meta_analysis_source_score_set_urns is not None
+        and len(item_create.meta_analysis_source_score_set_urns) > 0
+    ):
+        # If any existing score set is a meta-analysis for the same set of score sets, use its experiment as the parent
+        # of our new meta-analysis. Otherwise, create a new experiment.
+        existing_meta_analyses = find_meta_analyses_for_score_sets(db, item_create.meta_analysis_source_score_set_urns)
+        if len(existing_meta_analyses) > 0:
+            experiment = existing_meta_analyses[0].experiment
+        else:
+            experiment = Experiment(
+                title=item_create.title,
+                short_description=item_create.short_description,
+                abstract_text=item_create.abstract_text,
+                method_text=item_create.method_text,
+                extra_metadata={},
+                created_by=user,
+                modified_by=user,
+            )
 
     license_ = db.query(License).filter(License.id == item_create.license_id).one_or_none()
     if not license_:
@@ -390,7 +418,9 @@ async def upload_score_set_variant_data(
 def create_variants(db, score_set: ScoreSet, variants_data: list[VariantData], batch_size=None) -> int:
     num_variants = len(variants_data)
     variant_urns = bulk_create_urns(num_variants, score_set, True)
-    variants = (Variant(urn=urn, score_set_id=score_set.id, **kwargs) for urn, kwargs in zip(variant_urns, variants_data))
+    variants = (
+        Variant(urn=urn, score_set_id=score_set.id, **kwargs) for urn, kwargs in zip(variant_urns, variants_data)
+    )
     db.bulk_save_objects(variants)
     db.add(score_set)
     return len(score_set.variants)

src/mavedb/view_models/score_set.py

@@ -4,9 +4,10 @@
 from datetime import date
 from typing import Collection, Dict, Optional
 
-from pydantic import Field
+from pydantic import Field, root_validator
 
 from mavedb.lib.validation import keywords, urn
+from mavedb.lib.validation.exceptions import ValidationError
 from mavedb.view_models import PublicationIdentifiersGetter
 from mavedb.view_models.base.base import BaseModel, validator
 from mavedb.view_models.doi_identifier import (
@@ -53,7 +54,7 @@ def validate_keywords(cls, v):
 class ScoreSetCreate(ScoreSetModify):
     """View model for creating a new score set."""
 
-    experiment_urn: str
+    experiment_urn: Optional[str]
     license_id: int
     superseded_score_set_urn: Optional[str]
     meta_analysis_source_score_set_urns: Optional[list[str]]
@@ -79,6 +80,18 @@ def validate_experiment_urn(cls, v):
         urn.validate_mavedb_urn_experiment(v)
         return v
 
+    @root_validator
+    def validate_experiment_urn_required_except_for_meta_analyses(cls, values):
+        experiment_urn = values["experiment_urn"]
+        meta_analysis_source_score_set_urns = values["meta_analysis_source_score_set_urns"]
+        is_meta_analysis = meta_analysis_source_score_set_urns is None or len(meta_analysis_source_score_set_urns) == 0
+        if experiment_urn is None and is_meta_analysis:
+            raise ValidationError("An experiment URN is required, unless your score set is a meta-analysis.")
+        if experiment_urn is not None and not is_meta_analysis:
+            raise ValidationError("An experiment URN should not be supplied when your score set is a meta-analysis.")
+        return values
+
+
 class ScoreSetUpdate(ScoreSetModify):
     """View model for updating a score set."""