scout-browser 4.102.0__py3-none-any.whl → 4.103.0__py3-none-any.whl

scout/adapter/mongo/case.py

@@ -14,8 +14,6 @@ from werkzeug.datastructures import ImmutableMultiDict
 
 from scout.build.case import build_case
 from scout.constants import (
-    ACMG_MAP,
-    CCV_MAP,
     ID_PROJECTION,
     ORDERED_FILE_TYPE_MAP,
     ORDERED_OMICS_FILE_TYPE_MAP,
@@ -1052,7 +1050,7 @@ class CaseHandler(object):
                 self.update_case_sanger_variants(institute_obj, case_obj, old_sanger_variants)
 
                 if keep_actions and old_evaluated_variants:
-                    self.update_variant_actions(institute_obj, case_obj, old_evaluated_variants)
+                    self.update_variant_actions(case_obj, old_evaluated_variants)
 
         return case_obj
 
@@ -1372,15 +1370,12 @@ class CaseHandler(object):
 
         return case_verif_variants
 
-    def update_variant_actions(self, institute_obj, case_obj, old_eval_variants):
+    def update_variant_actions(
+        self, case_obj: dict, old_eval_variants: List[dict]
+    ) -> Dict[str, List[str]]:
         """Update existing variants of a case according to the tagged status
             (manual_rank, dismiss_variant, mosaic_tags) of its previous variants
 
-        Accepts:
-            institute_obj(dict): an institute object
-            case_obj(dict): a case object
-            old_eval_variants(list(Variant))
-
         Returns:
             updated_variants(dict): a dictionary like this:
                 'manual_rank' : [list of variant ids],
@@ -1391,131 +1386,43 @@ class CaseHandler(object):
                 'ccv_classification': [list of variant ids]
                 'is_commented': [list of variant ids]
         """
-        updated_variants = {
-            "manual_rank": [],
-            "dismiss_variant": [],
-            "mosaic_tags": [],
-            "cancer_tier": [],
-            "acmg_classification": [],
-            "ccv_classification": [],
-            "is_commented": [],
-        }
-
-        update_action_map = {
-            "manual_rank": self.update_manual_rank,
-            "dismiss_variant": self.update_dismiss_variant,
-            "mosaic_tags": self.update_mosaic_tags,
-            "cancer_tier": self.update_cancer_tier,
-        }
-
+        ACTION_KEYS = [
+            "manual_rank",
+            "dismiss_variant",
+            "mosaic_tags",
+            "cancer_tier",
+            "acmg_classification",
+            "ccv_classification",
+            "is_commented",
+        ]
+        updated_variants = {action: [] for action in ACTION_KEYS}
         LOG.debug(
             "Updating action status for {} variants in case:{}".format(
                 len(old_eval_variants), case_obj["_id"]
             )
         )
-
         n_status_updated = 0
         for old_var in old_eval_variants:
             # search for the same variant in newly uploaded vars for this case
             display_name = old_var["display_name"]
-
             new_var = self.variant_collection.find_one(
                 {"case_id": case_obj["_id"], "display_name": display_name}
             )
-
             if new_var is None:  # same var is no more among case variants, skip it
                 LOG.warning(
                     "Trying to propagate manual action from an old variant to a new, but couldn't find same variant any more"
                 )
                 continue
 
-            for action in list(
-                updated_variants.keys()
-            ):  # manual_rank, dismiss_variant, mosaic_tags
-                # collect only the latest associated event:
-                if (
-                    old_var.get(action) is None and action != "is_commented"
-                ):  # tag new variant accordingly
-                    continue
-                verb = action
-                if action == "acmg_classification":
-                    verb = "acmg"
-                if action == "is_commented":
-                    verb = "comment"
-                if action == "ccv_classification":
-                    verb = "ccv"
-
-                old_event = self.event_collection.find_one(
-                    {
-                        "case": case_obj["_id"],
-                        "verb": verb,
-                        "variant_id": old_var["variant_id"],
-                        "category": "variant",
-                    },
-                    sort=[("updated_at", pymongo.DESCENDING)],
-                )
-
-                if old_event is None:
-                    continue
-
-                user_obj = self.user(old_event["user_id"])
-                if user_obj is None:
-                    continue
-
-                updated_variant = None
-
-                if action == "is_commented":
-                    updated_comments = self.comments_reupload(
-                        old_var, new_var, institute_obj, case_obj
-                    )
-                    if updated_comments > 0:
-                        LOG.info(
-                            "Created {} new comments for variant {} after reupload".format(
-                                updated_comments, display_name
-                            )
-                        )
-                        updated_variant = new_var
-
-                # create a link to the new variant for the events
-                link = "/{0}/{1}/{2}".format(
-                    new_var["institute"], case_obj["display_name"], new_var["_id"]
-                )
-
-                if action == "acmg_classification":
-                    str_classif = ACMG_MAP.get(old_var.get("acmg_classification"))
-                    updated_variant = self.update_acmg(
-                        institute_obj=institute_obj,
-                        case_obj=case_obj,
-                        user_obj=user_obj,
-                        link=link,
-                        variant_obj=new_var,
-                        acmg_str=str_classif,
+            for action in ACTION_KEYS:
+                if old_var.get(action):
+                    updated_variant = self.variant_collection.find_one_and_update(
+                        {"_id": new_var["_id"]},
+                        {"$set": {action: old_var.get(action)}},
                     )
-
-                if action == "ccv_classification":
-                    str_classif = CCV_MAP.get(old_var.get("ccv_classification"))
-                    updated_variant = self.update_ccv(
-                        institute_obj=institute_obj,
-                        case_obj=case_obj,
-                        user_obj=user_obj,
-                        link=link,
-                        variant_obj=new_var,
-                        ccv_str=str_classif,
-                    )
-
-                if action in update_action_map.keys():
-                    updated_variant = update_action_map[action](
-                        institute_obj,
-                        case_obj,
-                        user_obj,
-                        link,
-                        new_var,
-                        old_var.get(action),
-                    )
-
-                if updated_variant is not None:
-                    n_status_updated += 1
-                    updated_variants[action].append(updated_variant["_id"])
+                    if updated_variant:
+                        n_status_updated += 1
+                        updated_variants[action].append(new_var["_id"])
 
         LOG.info("Variant actions updated {} times".format(n_status_updated))
         return updated_variants
@@ -1591,14 +1498,11 @@ class CaseHandler(object):
 
                 else:
                     # old variant had Sanger validation ordered
-                    # check old event to collect user_obj that ordered the verification:
                     # set sanger ordered status for the new variant as well:
-                    updated_var = self.order_verification(
-                        institute=institute_obj,
-                        case=case_obj,
-                        user=user_obj,
-                        link=link,
-                        variant=new_var,
+                    updated_var = self.variant_collection.find_one_and_update(
+                        {"_id": new_var["_id"]},
+                        {"$set": {"sanger_ordered": True}},
+                        return_document=pymongo.ReturnDocument.AFTER,
                     )
                     if updated_var:
                         updated_variants["updated_ordered"].append(updated_var["_id"])

scout/adapter/mongo/clinvar.py

@@ -2,20 +2,22 @@
 import logging
 import re
 from datetime import datetime
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 import pymongo
 from bson.objectid import ObjectId
 from pymongo import ReturnDocument
 
+from scout.constants.clinvar import ASSERTION_CRITERIA_ONC_ID, ASSERTION_ONC_ONC_DB
+
 LOG = logging.getLogger(__name__)
 
 
 class ClinVarHandler(object):
     """Class to handle clinvar submissions for the mongo adapter"""
 
-    def create_submission(self, institute_id: str, user_id: str) -> ObjectId:
-        """Create an open ClinVar submission for an institute."""
+    def create_germline_submission(self, institute_id: str, user_id: str) -> ObjectId:
+        """Create an open ClinVar germline submission for an institute."""
 
         submission_obj = {
             "status": "open",
@@ -23,7 +25,24 @@ class ClinVarHandler(object):
             "institute_id": institute_id,
             "created_by": user_id,
         }
-        LOG.info("Creating a new ClinVar submission for institute %s", institute_id)
+        LOG.info("Creating a new ClinVar germline submission for institute %s", institute_id)
+        result = self.clinvar_submission_collection.insert_one(submission_obj)
+        return result.inserted_id
+
+    def create_oncogenicity_submission(self, institute_id: str, user_id: str) -> ObjectId:
+        """Create an open ClinVar oncogenicity submission for an institute."""
+
+        submission_obj = {
+            "status": "open",
+            "type": "oncogenicity",
+            "created_at": datetime.now(),
+            "updated_at": datetime.now(),
+            "institute_id": institute_id,
+            "created_by": user_id,
+            "assertionCriteria": {"db": ASSERTION_ONC_ONC_DB, "id": ASSERTION_CRITERIA_ONC_ID},
+            "oncogenicitySubmission": [],
+        }
+        LOG.info("Creating a new ClinVar oncogenicity submission for institute %s", institute_id)
         result = self.clinvar_submission_collection.insert_one(submission_obj)
         return result.inserted_id
 
@@ -65,18 +84,31 @@ class ClinVarHandler(object):
         # return deleted_count, deleted_submissions
         return deleted_objects, deleted_submissions
 
-    def get_open_clinvar_submission(self, institute_id: str, user_id: str) -> dict:
-        """Retrieve the database id of an open ClinVar submission for an institute,
+    def get_open_germline_clinvar_submission(self, institute_id: str, user_id: str) -> dict:
+        """Retrieve the database id of an open ClinVar germline submission for an institute,
         if none is available then creates a new submission dictionary and returns it.
         """
 
-        LOG.info("Retrieving an open clinvar submission for institute %s", institute_id)
         query = dict(institute_id=institute_id, status="open")
         submission = self.clinvar_submission_collection.find_one(query)
 
         # If there is no open submission for this institute, create one
         if submission is None:
-            submission_id = self.create_submission(institute_id, user_id)
+            submission_id = self.create_germline_submission(institute_id, user_id)
+            submission = self.clinvar_submission_collection.find_one({"_id": submission_id})
+
+        return submission
+
+    def get_open_onc_clinvar_submission(self, institute_id: str, user_id: str) -> dict:
+        """Retrieve the database id of an open ClinVar oncogenicity submission for an institute,
+        if none is available then creates a new submission dictionary and returns it.
+        """
+
+        query = dict(institute_id=institute_id, status="open", type="oncogenicity")
+        submission = self.clinvar_submission_collection.find_one(query)
+        # If there is no open submission for this institute, create one
+        if submission is None:
+            submission_id = self.create_oncogenicity_submission(institute_id, user_id)
             submission = self.clinvar_submission_collection.find_one({"_id": submission_id})
 
         return submission
@@ -230,9 +262,14 @@ class ClinVarHandler(object):
             "updated_at": result.get("updated_at"),
         }
 
-    def clinvar_submissions(self, institute_id: str) -> List[dict]:
-        """Collect all open and closed clinvar submissions for an institute"""
-        query = dict(institute_id=institute_id)
+    def get_clinvar_onc_submissions(self, institute_id: str) -> pymongo.cursor.Cursor:
+        """Collect all open and closed ClinVar oncogenocity submissions for an institute."""
+        query = {"institute_id": institute_id, "type": "oncogenicity"}
+        return self.clinvar_submission_collection.find(query).sort("updated_at", pymongo.DESCENDING)
+
+    def get_clinvar_germline_submissions(self, institute_id: str) -> List[dict]:
+        """Collect all open and closed ClinVar germline submissions for an institute."""
+        query = {"institute_id": institute_id, "type": {"$exists": False}}
         results = list(
             self.clinvar_submission_collection.find(query).sort("updated_at", pymongo.DESCENDING)
         )
@@ -298,8 +335,8 @@ class ClinVarHandler(object):
             criteria = {"assertionCriteriaDB": amc_db, "assertionCriteriaID": amc_id}
             return criteria
 
-    def clinvar_objs(self, submission_id, key_id):
-        """Collects a list of objects from the clinvar collection (variants of case data) as specified by the key_id in the clinvar submission
+    def clinvar_objs(self, submission_id: str, key_id: str) -> list:
+        """Collects a list of objects from the ClinVar collection (variants of case data) as specified by the key_id in the submission.
 
         Args:
             submission_id(str): the _id key of a clinvar submission
@@ -308,8 +345,8 @@ class ClinVarHandler(object):
 
         Returns:
             clinvar_objects(list) : a list of clinvar objects (either variants of casedata)
-
         """
+
         # Get a submission object
         submission = self.clinvar_submission_collection.find_one({"_id": ObjectId(submission_id)})
 
@@ -319,7 +356,7 @@ class ClinVarHandler(object):
             clinvar_objects = self.clinvar_collection.find({"_id": {"$in": clinvar_obj_ids}})
             return list(clinvar_objects)
 
-        return None
+        return []
 
     def rename_casedata_samples(self, submission_id, case_id, old_name, new_name):
         """Rename all samples associated to a clinVar submission
@@ -403,20 +440,22 @@ class ClinVarHandler(object):
             return_document=ReturnDocument.AFTER,
         )
 
-    def case_to_clinVars(self, case_id):
-        """Get all variants included in clinvar submissions for a case
-
-        Args:
-            case_id(str): a case _id
+    def delete_clinvar_onc_var(self, submission: str, variant_id: str) -> dict:
+        """Removes an oncogenicity submission or one or its variants."""
 
-        Returns:
-            submission_variants(dict): keys are variant ids and values are variant submission objects
+        return self.clinvar_submission_collection.find_one_and_update(
+            {"_id": ObjectId(submission)},
+            {"$pull": {"oncogenicitySubmission": {"variant_id": variant_id}}},
+            return_document=pymongo.ReturnDocument.AFTER,
+        )
 
-        """
+    def case_to_clinvars(self, case_id: str) -> Dict[str, dict]:
+        """Get all variants included in ClinVar submissions for a case. Returns a dictionary with variant IDs as keys and submissions as values."""
         query = dict(case_id=case_id, csv_type="variant")
-        clinvar_objs = list(self.clinvar_collection.find(query))
+        germline_clinvar_objs = list(self.clinvar_collection.find(query))
+        oncogenic_clinvar_objs = []
         submitted_vars = {}
-        for clinvar in clinvar_objs:
+        for clinvar in germline_clinvar_objs + oncogenic_clinvar_objs:
             submitted_vars[clinvar.get("local_id")] = clinvar
 
         return submitted_vars
@@ -454,3 +493,30 @@ class ClinVarHandler(object):
         for clinvar_var in clinvar_vars_for_case:
             if variant_id in clinvar_var["link"]:
                 return clinvar_var["user_name"]
+
+    def get_onc_submission_json(self, submission: str) -> Optional[dict]:
+        """Returns a json oncogenicity submission file, as a json."""
+
+        submission_dict = self.clinvar_submission_collection.find_one(
+            {"_id": ObjectId(submission), "type": "oncogenicity"}
+        )
+        if not submission_dict:
+            return
+
+        for key in [
+            "_id",
+            "clinvar_subm_id",
+            "status",
+            "type",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "institute_id",
+        ]:
+            submission_dict.pop(key, None)
+
+        for var in submission_dict.get("oncogenicitySubmission", []):
+            for key in ["institute_id", "case_id", "case_name", "variant_id"]:
+                var.pop(key, None)
+
+        return submission_dict

scout/adapter/mongo/event.py

@@ -552,50 +552,3 @@ class EventHandler(CaseEventHandler, VariantEventHandler):
         )
         self.event_collection.insert_one(event)
         return updated_comment
-
-    def comments_reupload(self, old_var, new_var, institute_obj, case_obj):
-        """Creates comments for a new variant after variant reupload
-
-        Accepts:
-            old_var(Variant): the deleted variant
-            new_var(Variant): the new variant replacing old_var
-            institute_obj(dict): an institute object
-            case_obj(dict): a case object
-
-        Returns:
-            new_comments(int): the number of created comments
-        """
-        new_comments = 0
-
-        if new_var["_id"] == old_var["_id"]:
-            return new_comments
-
-        link = "/{0}/{1}/{2}".format(new_var["institute"], case_obj["display_name"], new_var["_id"])
-
-        # collect all comments for the old variant
-        comments_query = self.events(
-            variant_id=old_var["variant_id"],
-            comments=True,
-            institute=institute_obj,
-            case=case_obj,
-        )
-
-        # and create the same comment for the new variant
-        for old_comment in comments_query:
-            comment_user = self.user(old_comment["user_id"])
-            if comment_user is None:
-                continue
-
-            updated_comment = self.comment(
-                institute=institute_obj,
-                case=case_obj,
-                user=comment_user,
-                link=link,
-                variant=new_var,
-                content=old_comment.get("content"),
-                comment_level=old_comment.get("level"),
-            )
-            if updated_comment:
-                new_comments += 1
-
-        return new_comments

scout/adapter/mongo/variant_loader.py

@@ -657,14 +657,18 @@ class VariantLoader(object):
             if vcf_dict["category"] != category:
                 continue
 
-            LOG.info(f"Loading'{vcf_file_key}' variants")
             variant_file = (
                 case_obj["vcf_files"].get(vcf_file_key) if case_obj.get("vcf_files") else None
             )
 
-            if not variant_file or not self._has_variants_in_file(variant_file):
+            if variant_file:
+                LOG.info(f"Loading {vcf_file_key} variants")
+            else:
+                continue
+
+            if not self._has_variants_in_file(variant_file):
                 LOG.warning(
-                    f"File '{variant_file}' not found on disk. Please update case {case_obj['_id']} with a valid file path for variant category: '{category}'."
+                    f"File '{variant_file}' not found on disk. Please update case {case_obj['_id']} with a valid file path for the {category} variant category ."
                 )
                 continue
 

scout/build/variant/variant.py

@@ -190,6 +190,7 @@ def build_variant(
     variant_obj["position"] = int(variant["position"])
     variant_obj["quality"] = float(variant["quality"]) if variant["quality"] else None
     variant_obj["rank_score"] = float(variant["rank_score"])
+    variant_obj["norm_rank_score"] = float(variant["norm_rank_score"])
     variant_obj["simple_id"] = variant["ids"].get("simple_id")
     variant_obj["sub_category"] = variant.get("sub_category")
 

scout/commands/load/variants.py

@@ -274,4 +274,4 @@ def variants(
     adapter.update_case_sanger_variants(institute_obj, case_obj, old_sanger_variants)
 
     if keep_actions and old_evaluated_variants:
-        adapter.update_variant_actions(institute_obj, case_obj, old_evaluated_variants)
+        adapter.update_variant_actions(case_obj, old_evaluated_variants)

scout/commands/update/user.py

@@ -1,72 +1,110 @@
 import logging
+from typing import List, Optional, Tuple
 
 import click
 from flask.cli import with_appcontext
 
+from scout.adapter import MongoAdapter
 from scout.server.extensions import store
 
 LOG = logging.getLogger(__name__)
+USER_ROLES = ["admin", "mme_submitter", "beacon_submitter"]
 
 
 @click.command("user", short_help="Update a user")
-@click.option("--user-id", "-u", help="A email adress that identifies the user", required=True)
-@click.option(
-    "--update-role",
-    "-r",
-    # There will be more roles in the future
-    type=click.Choice(["admin", "mme_submitter", "beacon_submitter"]),
-    help="Add a role to the user",
-)
-@click.option("--remove-admin", is_flag=True, help="Remove admin rights from user")
-@click.option("--add-institute", "-i", multiple=True, help="Specify the institutes to add")
-@click.option("--remove-institute", multiple=True, help="Specify the institutes to remove")
+@click.option("--user-id", "-u", required=True, help="An email address that identifies the user")
+@click.option("--update-role", "-r", type=click.Choice(USER_ROLES), help="Add a role to the user")
+@click.option("--remove-admin", is_flag=True, help="(Deprecated) Remove admin role from the user")
+@click.option("--remove-role", multiple=True, help="Specify roles to remove from the user")
+@click.option("--add-institute", "-i", multiple=True, help="Specify institutes to add")
+@click.option("--remove-institute", multiple=True, help="Specify institutes to remove")
 @with_appcontext
-def user(user_id, update_role, add_institute, remove_admin, remove_institute):
-    """
-    Update a user in the database
-    """
+def user(
+    user_id: str,
+    update_role: Optional[str],
+    remove_admin: bool,
+    remove_role: Tuple[str, ...],
+    add_institute: Tuple[str, ...],
+    remove_institute: Tuple[str, ...],
+) -> None:
+    """Update roles and institutes for a user in the database."""
     adapter = store
-
     user_obj = adapter.user(user_id)
-
     if not user_obj:
         LOG.warning("User %s could not be found", user_id)
         raise click.Abort()
 
-    existing_roles = set(user_obj.get("roles", []))
-    if update_role:
-        if not update_role in user_obj["roles"]:
-            existing_roles = set(user_obj["roles"])
-            existing_roles.add(update_role)
-            LOG.info("Adding role %s to user", update_role)
+    user_obj["roles"] = process_roles(
+        current_roles=user_obj.get("roles", []),
+        add_role=update_role,
+        remove_roles=remove_role,
+        remove_admin=remove_admin,
+        user_id=user_id,
+    )
+    user_obj["institutes"] = process_institutes(
+        current_institutes=user_obj.get("institutes", []),
+        add_institutes=add_institute,
+        remove_institutes=remove_institute,
+        adapter=adapter,
+        user_id=user_id,
+    )
+    adapter.update_user(user_obj)
+
+
+def process_roles(
+    current_roles: List[str],
+    add_role: Optional[str],
+    remove_roles: Tuple[str, ...],
+    remove_admin: bool,
+    user_id: str,
+) -> List[str]:
+    """Define the list of roles for a user in the database."""
+    roles = set(current_roles)
+
+    if add_role:
+        if add_role in roles:
+            LOG.warning("User already has role '%s'", add_role)
         else:
-            LOG.warning("User already have role %s", update_role)
-
-    if remove_admin:
-        try:
-            existing_roles.remove("admin")
-            LOG.info("Removing admin rights from user %s", user_id)
-        except KeyError as err:
-            LOG.info("User %s does not have admin rights", user_id)
-
-    user_obj["roles"] = list(existing_roles)
-
-    existing_institutes = set(user_obj.get("institutes", []))
-    for institute_id in add_institute:
-        institute_obj = adapter.institute(institute_id)
-        if not institute_obj:
-            LOG.warning("Institute %s could not be found", institute_id)
+            roles.add(add_role)
+            LOG.info("Adding role '%s' to user '%s'", add_role, user_id)
+
+    all_remove = set(remove_roles)
+    if remove_admin and "admin" not in all_remove:
+        click.echo("⚠️ --remove-admin is deprecated. Use --remove-role admin instead.")
+        all_remove.add("admin")
+
+    for role in all_remove:
+        if role in roles:
+            roles.remove(role)
+            LOG.info("Removing role '%s' from user '%s'", role, user_id)
         else:
-            existing_institutes.add(institute_id)
-            LOG.info("Adding institute %s to user", institute_id)
+            LOG.info("User does not have role '%s'", role)
 
-    for institute_id in remove_institute:
-        try:
-            existing_institutes.remove(institute_id)
-            LOG.info("Removing institute %s from user", institute_id)
-        except KeyError as err:
-            LOG.info("User does not have access to institute %s", institute_id)
+    return list(roles)
 
-    user_obj["institutes"] = list(existing_institutes)
 
-    adapter.update_user(user_obj)
+def process_institutes(
+    current_institutes: List[str],
+    add_institutes: Tuple[str, ...],
+    remove_institutes: Tuple[str, ...],
+    adapter: MongoAdapter,
+    user_id: str,
+) -> List[str]:
+    """Define the list of institutes for a user in the database."""
+    institutes = set(current_institutes)
+
+    for inst in add_institutes:
+        if adapter.institute(inst):
+            institutes.add(inst)
+            LOG.info("Adding institute '%s' to user '%s'", inst, user_id)
+        else:
+            LOG.warning("Institute '%s' could not be found", inst)
+
+    for inst in remove_institutes:
+        if inst in institutes:
+            institutes.remove(inst)
+            LOG.info("Removing institute '%s' from user '%s'", inst, user_id)
+        else:
+            LOG.info("User does not have access to institute '%s'", inst)
+
+    return list(institutes)