scout-browser 4.101.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

@@ -1,29 +1,48 @@
 # -*- coding: utf-8 -*-
 import logging
+import re
 from datetime import datetime
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 import pymongo
-from bson import ObjectId
 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",
+            "created_at": datetime.now(),
+            "institute_id": institute_id,
+            "created_by": user_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 submission for institute %s", institute_id)
+        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
@@ -393,30 +430,32 @@ class ClinVarHandler(object):
             self.clinvar_collection.delete_one({"_id": object_id})
 
         # in any case remove reference to it in the submission object 'case_data' list field
-        self.clinvar_submission_collection.find_one_and_update(
-            {"_id": ObjectId(submission_id)}, {"$pull": {"case_data": object_id}}
-        )
 
         return self.clinvar_submission_collection.find_one_and_update(
-            {"_id": submission_id},
-            {"$set": {"updated_at": datetime.now()}},
-            return_document=pymongo.ReturnDocument.AFTER,
+            {"_id": ObjectId(submission_id)},
+            {
+                "$set": {"updated_at": datetime.now()},
+                "$pull": {"case_data": {"$regex": f"^{re.escape(object_id)}"}},
+            },
+            return_document=ReturnDocument.AFTER,
         )
 
-    def case_to_clinVars(self, case_id):
-        """Get all variants included in clinvar submissions for a case
+    def delete_clinvar_onc_var(self, submission: str, variant_id: str) -> dict:
+        """Removes an oncogenicity submission or one or its variants."""
 
-        Args:
-            case_id(str): a case _id
-
-        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/hgnc.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, Set
+from typing import Dict, Optional, Set
 
 import intervaltree
 from pymongo.errors import BulkWriteError, DuplicateKeyError
@@ -44,7 +44,9 @@ class GeneHandler(object):
 
         return result
 
-    def hgnc_gene_caption(self, hgnc_identifier, build=None):
+    def hgnc_gene_caption(
+        self, hgnc_identifier: Optional[int] = None, build: Optional[str] = None
+    ) -> Optional[dict]:
         """Fetch the current hgnc gene symbol and similar caption info for a gene in a lightweight dict
         Avoid populating transcripts, exons etc that would be added on a full gene object. Use hgnc_gene() if
         you need to use those.
@@ -57,6 +59,9 @@ class GeneHandler(object):
             gene_caption(dict): light pymongo document with keys "hgnc_symbol", "description", "chromosome", "start", "end".
         """
 
+        if not hgnc_identifier:
+            return
+
         query = {"hgnc_id": int(hgnc_identifier)}
 
         if build in ["37", "38"]:

scout/adapter/mongo/omics_variant.py

@@ -1,4 +1,5 @@
 import logging
+import os
 from typing import Dict, Iterable, List, Optional
 
 from pymongo import ASCENDING, DESCENDING
@@ -130,6 +131,13 @@ class OmicsVariantHandler:
 
         nr_inserted = 0
 
+        file_path = case_obj["omics_files"].get(file_type) if case_obj.get("omics_files") else None
+        if file_path is None or os.path.exists(file_path) is False:
+            LOG.warning(
+                f"File '{file_path}' not found on disk. Please update case {case_obj['_id']} with a valid file path for {file_type}."
+            )
+            return
+
         file_handle = open(case_obj["omics_files"].get(file_type), "r")
 
         for omics_info in parse_omics_file(file_handle, omics_file_type=omics_file_type):

scout/adapter/mongo/variant_loader.py

@@ -642,7 +642,6 @@ class VariantLoader(object):
         Returns:
             nr_inserted(int)
         """
-
         institute_id = case_obj["owner"]
 
         nr_inserted = 0
@@ -658,10 +657,19 @@ 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)
+            variant_file = (
+                case_obj["vcf_files"].get(vcf_file_key) if case_obj.get("vcf_files") else None
+            )
+
+            if variant_file:
+                LOG.info(f"Loading {vcf_file_key} variants")
+            else:
+                continue
 
-            if not variant_file or not self._has_variants_in_file(variant_file):
+            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 the {category} variant category ."
+                )
                 continue
 
             vcf_obj = VCF(variant_file)

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)