scout-browser 4.91.2__py3-none-any.whl → 4.93.1__py3-none-any.whl

scout/server/blueprints/variant/views.py

@@ -13,13 +13,26 @@ from flask import (
 from flask_login import current_user
 from markupsafe import Markup
 
-from scout.constants import ACMG_CRITERIA, ACMG_MAP, ACMG_OPTIONS
-from scout.server.blueprints.variant.controllers import check_reset_variant_classification
+from scout.constants import (
+    ACMG_CRITERIA,
+    ACMG_MAP,
+    ACMG_OPTIONS,
+    CCV_CRITERIA,
+    CCV_MAP,
+    CCV_OPTIONS,
+)
+from scout.server.blueprints.variant.controllers import ccv_evaluation as ccv_evaluation_controller
+from scout.server.blueprints.variant.controllers import (
+    check_reset_variant_ccv_classification,
+    check_reset_variant_classification,
+)
 from scout.server.blueprints.variant.controllers import evaluation as evaluation_controller
 from scout.server.blueprints.variant.controllers import observations, str_variant_reviewer
 from scout.server.blueprints.variant.controllers import variant as variant_controller
 from scout.server.blueprints.variant.controllers import variant_acmg as acmg_controller
 from scout.server.blueprints.variant.controllers import variant_acmg_post
+from scout.server.blueprints.variant.controllers import variant_ccv as ccv_controller
+from scout.server.blueprints.variant.controllers import variant_ccv_post
 from scout.server.blueprints.variant.verification_controllers import (
     MissingVerificationRecipientError,
     variant_verification,
@@ -27,6 +40,7 @@ from scout.server.blueprints.variant.verification_controllers import (
 from scout.server.extensions import loqusdb, store
 from scout.server.utils import institute_and_case, public_endpoint, templated
 from scout.utils.acmg import get_acmg, get_acmg_conflicts, get_acmg_temperature
+from scout.utils.ccv import get_ccv, get_ccv_conflicts, get_ccv_temperature
 from scout.utils.ensembl_rest_clients import EnsemblRestApiClient
 
 LOG = logging.getLogger(__name__)
@@ -205,9 +219,40 @@ def variant_acmg(institute_id, case_name, variant_id):
     )
 
 
+@variant_bp.route("/<institute_id>/<case_name>/<variant_id>/ccv", methods=["GET", "POST"])
+@templated("variant/ccv.html")
+def variant_ccv(institute_id, case_name, variant_id):
+    """ClinGen-CCG-VICC classification form."""
+    if request.method == "GET":
+        data = ccv_controller(store, institute_id, case_name, variant_id)
+        return data
+
+    criteria = []
+    criteria_terms = request.form.getlist("criteria")
+    for term in criteria_terms:
+        criteria.append(
+            dict(
+                term=term,
+                comment=request.form.get("comment-{}".format(term)),
+                links=[request.form.get("link-{}".format(term))],
+            )
+        )
+    ccv = variant_ccv_post(store, institute_id, case_name, variant_id, current_user.email, criteria)
+    flash("classified as: {}".format(ccv), "info")
+    return redirect(
+        url_for(
+            ".variant",
+            institute_id=institute_id,
+            case_name=case_name,
+            variant_id=variant_id,
+        )
+    )
+
+
 @variant_bp.route("/<institute_id>/<case_name>/<variant_id>/update", methods=["POST"])
 def variant_update(institute_id, case_name, variant_id):
-    """Update user-defined information about a variant: manual rank & ACMG."""
+    """Update user-defined information about a variant: manual rank, cancer tier,
+    CLinGen-CGC-VICC classification, dismissal & mosaic tags."""
     institute_obj, case_obj = institute_and_case(store, institute_id, case_name)
     variant_obj = store.variant(variant_id)
     user_obj = store.user(current_user.email)
@@ -250,6 +295,7 @@ def variant_update(institute_id, case_name, variant_id):
             flash("Variant tag was updated", "info")
         else:
             flash("Variant tag was reset", "info")
+
     elif request.form.get("acmg_classification"):
         new_acmg = request.form["acmg_classification"]
         acmg_classification = variant_obj.get("acmg_classification")
@@ -268,6 +314,24 @@ def variant_update(institute_id, case_name, variant_id):
         )
         flash("updated ACMG classification: {}".format(new_acmg), "info")
 
+    elif request.form.get("ccv_classification"):
+        new_ccv = request.form["ccv_classification"]
+        ccv_classification = variant_obj.get("ccv_classification")
+        # If there already is a classification and the same one is sent again this means that
+        # We want to remove the classification
+        if isinstance(ccv_classification, int) and (new_ccv == CCV_MAP[ccv_classification]):
+            new_ccv = None
+
+        store.submit_ccv_evaluation(
+            variant_obj=variant_obj,
+            user_obj=user_obj,
+            institute_obj=institute_obj,
+            case_obj=case_obj,
+            link=link,
+            classification=new_ccv,
+        )
+        flash("updated ClinGen-CGC-VIGG classification: {}".format(new_ccv), "info")
+
     new_dismiss = request.form.getlist("dismiss_variant")
     if new_dismiss:
         store.update_dismiss_variant(
@@ -353,6 +417,53 @@ def acmg():
     return jsonify({"classification": classification, "conflicts": acmg_conflicts, **acmg_bayesian})
 
 
+@variant_bp.route("/ccv_evaluations/<evaluation_id>", methods=["GET", "POST"])
+@templated("variant/ccv.html")
+def ccv_evaluation(evaluation_id):
+    """Show, edit or delete an ClinGen-CGC-VIGG evaluation."""
+
+    evaluation_obj = store.get_ccv_evaluation(evaluation_id)
+    if evaluation_obj is None:
+        flash("Evaluation was not found in database", "warning")
+        return redirect(request.referrer)
+    ccv_evaluation_controller(store, evaluation_obj)
+    if request.method == "POST":
+        link = url_for(
+            ".variant",
+            institute_id=evaluation_obj["institute"]["_id"],
+            case_name=evaluation_obj["case"]["display_name"],
+            variant_id=evaluation_obj["variant_specific"],
+        )
+        store.delete_ccv_evaluation(evaluation_obj)
+
+        if check_reset_variant_ccv_classification(store, evaluation_obj, link):
+            flash("Cleared ClinGen-CGC-VIGG classification.", "info")
+
+        return redirect(link)
+
+    return dict(
+        evaluation=evaluation_obj,
+        edit=bool(request.args.get("edit")),
+        institute=evaluation_obj["institute"],
+        case=evaluation_obj["case"],
+        variant=evaluation_obj["variant"],
+        CRITERIA=CCV_CRITERIA,
+        CCV_OPTIONS=CCV_OPTIONS,
+    )
+
+
+@variant_bp.route("/api/v1/ccv")
+@public_endpoint
+def ccv():
+    """Calculate an ClinGen-CVC-VIGG classification from submitted criteria."""
+    criteria = request.args.getlist("criterion")
+    classification = get_ccv(criteria)
+
+    ccv_bayesian = get_ccv_temperature(criteria)
+    ccv_conflicts = get_ccv_conflicts(criteria)
+    return jsonify({"classification": classification, "conflicts": ccv_conflicts, **ccv_bayesian})
+
+
 @variant_bp.route(
     "/<institute_id>/<case_name>/<variant_id>/<order>",
     methods=["POST"],

scout/server/blueprints/variants/controllers.py

@@ -17,6 +17,8 @@ from scout.constants import (
     CANCER_EXPORT_HEADER,
     CANCER_SPECIFIC_VARIANT_DISMISS_OPTIONS,
     CANCER_TIER_OPTIONS,
+    CCV_COMPLETE_MAP,
+    CCV_MAP,
     CHROMOSOMES,
     CHROMOSOMES_38,
     CLINSIG_MAP,
@@ -362,6 +364,7 @@ def get_manual_assessments(variant_obj):
     ## display manual input of interest: classified, commented, tagged, mosaicism or dismissed.
     assessment_keywords = [
         "acmg_classification",
+        "ccv_classification",
         "manual_rank",
         "cancer_tier",
         "dismiss_variant",
@@ -402,6 +405,16 @@ def get_manual_assessments(variant_obj):
                 assessment["label"] = classification["short"]
                 assessment["display_class"] = classification["color"]
 
+            if assessment_type == "ccv_classification":
+                ccv_classification = variant_obj[assessment_type]
+                if isinstance(ccv_classification, int):
+                    ccv_code = CCV_MAP[ccv_classification]
+                    ccv_classification = CCV_COMPLETE_MAP[ccv_code]
+
+                assessment["title"] = "ClinGen-CGC-VIGG: {}".format(ccv_classification["label"])
+                assessment["label"] = ccv_classification["short"]
+                assessment["display_class"] = ccv_classification["color"]
+
             if assessment_type == "dismiss_variant":
                 dismiss_variant_options = {
                     **DISMISS_VARIANT_OPTIONS,
@@ -918,6 +931,11 @@ def parse_variant(
         acmg_code = ACMG_MAP[variant_obj["acmg_classification"]]
         variant_obj["acmg_classification"] = ACMG_COMPLETE_MAP[acmg_code]
 
+    ccv_classification = variant_obj.get("ccv_classification")
+    if isinstance(ccv_classification, int):
+        ccv_code = CCV_MAP[variant_obj["ccv_classification"]]
+        variant_obj["ccv_classification"] = CCV_COMPLETE_MAP[ccv_code]
+
     # convert length for SV variants
     variant_length = variant_obj.get("length")
     variant_obj["length"] = {100000000000: "inf", -1: "n.d."}.get(variant_length, variant_length)
@@ -1409,6 +1427,19 @@ def cancer_variants(store, institute_id, case_name, variants_query, variant_coun
                     secondary_gene = gene
         variant_obj["second_rep_gene"] = secondary_gene
         variant_obj["clinical_assessments"] = get_manual_assessments(variant_obj)
+
+        evaluations = []
+        # Get previous ClinGen-CGC-VIGG evaluations of the variant from other cases
+        for evaluation_obj in store.get_ccv_evaluations(variant_obj):
+            if evaluation_obj["case_id"] == case_obj["_id"]:
+                continue
+
+            ccv_classification = evaluation_obj["ccv_classification"]
+
+            evaluation_obj["ccv_classification"] = CCV_COMPLETE_MAP.get(ccv_classification)
+            evaluations.append(evaluation_obj)
+        variant_obj["ccv_evaluations"] = evaluations
+
         variants_list.append(variant_obj)
 
     data = dict(

scout/server/blueprints/variants/templates/variants/cancer-variants.html

@@ -2,7 +2,7 @@
 
 {% from "variants/components.html" import external_scripts, external_stylesheets, gene_cell, frequency_cell_general, observed_cell_general, variant_funct_anno_cell %}
 {% from "variants/utils.html" import cancer_filters, cell_rank, pagination_footer, pagination_hidden_div, dismiss_variants_block, filter_form_footer, filter_script_main, update_stash_filter_button_status, callers_cell %}
-{% from "variants/indicators.html" import pin_indicator, causative_badge, clinical_assessments_badge, comments_badge, dismissals_badge, evaluations_badge, group_assessments_badge, matching_manual_rank, other_tiered_variants, research_assessments_badge %}
+{% from "variants/indicators.html" import pin_indicator, causative_badge, clinical_assessments_badge, comments_badge, dismissals_badge, evaluations_badge, ccv_evaluations_badge, group_assessments_badge, matching_manual_rank, other_tiered_variants, research_assessments_badge %}
 
 {% block title %}
   {{ variant_type|capitalize }} somatic variants
@@ -109,6 +109,7 @@
               {{ comments_badge(case, institute, variant) }}
               {{ causative_badge(variant, case) }}
               {{ other_tiered_variants(variant) }}
+              {{ ccv_evaluations_badge(variant) }}
             </td>
             <td>{{ rank_cell(variant) }}</td>
             <td>{{ cadd_cell(variant) }}</td>

scout/server/blueprints/variants/templates/variants/components.html

@@ -161,94 +161,84 @@
 
 {% macro gene_cell(variant, inherit_palette) %}
   <div class="align-items-center">
-    {% if variant.category == "cancer" or variant.category == "sv_cancer" %}
-      <a data-bs-toggle="tooltip" data-bs-html="true" title="
+
+    {% macro gene_tooltip(gene) %}
+      <div>
         <div>
+          <strong>{{ gene.hgnc_symbol }}</strong>: {{ gene.description }}
+        </div>
+        {% if gene.inheritance %}
           <div>
-            <strong>{{ variant.first_rep_gene.hgnc_symbol }}</strong>: {{ variant.first_rep_gene.description }}
+            <strong>Models</strong>: {{ gene.inheritance|join(',') }}
           </div>
-          {% if variant.first_rep_gene.inheritance %}
-            <div>
-              <strong>Models</strong>: {{ variant.first_rep_gene.inheritance|join(',') }}
-            </div>
-          {% endif %}
-        {% if variant.first_rep_gene.phenotypes %}
+        {% endif %}
+        {% if gene.phenotypes %}
           <div><strong>OMIM disease</strong>
-          {% for disease in variant.first_rep_gene.phenotypes %}
-            <div>
-                {{ disease.description }}
-            </div>
+          {% for disease in gene.phenotypes %}
+            <div>{{ disease.description }}</div>
           {% endfor %}
           </div>
         {% endif %}
-        </div>"
-        {% if variant.first_rep_gene %}
-          href="{{ url_for('genes.gene', hgnc_id=variant.first_rep_gene.hgnc_id) }}"
-        {% endif %}>
-        {{ variant.first_rep_gene.hgnc_symbol or variant.first_rep_gene.hgnc_id }}
-        {% if variant.secondary_gene %}
-          <span class="text-muted">
-            ({{ variant.second_rep_gene.hgnc_symbol or variant.second_rep_gene.hgnc_id }})
-          </span>
-        {% endif %}
+      </div>
+    {% endmacro %}
+
+    {% macro gene_link(gene) %}
+      <a
+        data-bs-toggle="tooltip"
+        data-bs-html="true"
+        title="{{ gene_tooltip(gene) }}"
+        href="{{ url_for('genes.gene', hgnc_id=gene.hgnc_id) }}"
+      >
+        {{ gene.hgnc_symbol or gene.hgnc_id }}
       </a>
+    {% endmacro %}
+
+    {% macro panel_badge(variant, gene_id=0) %}
+
+      {% set matching_panels = [] %}
+      {% for panel in variant.case_panels|rejectattr('removed')|list %}
+        {% if gene_id in panel.hgnc_ids %}
+           {% set _ = matching_panels.append(panel) %}
+        {% endif %}
+      {% endfor %}
 
-      {% set panel_count = variant.case_panels|rejectattr('removed')|list|length %}
-      {% if panel_count > 0%}
-          <a
-            class="badge bg-secondary text-white"
-            data-bs-toggle="popover"
-            data-bs-html="true"
-            data-bs-trigger="hover click"
-            title="Overlapping gene panels"
-            data-bs-content="{% for panel in variant.case_panels|sort(attribute='panel_name',case_sensitive=False)|rejectattr('removed') %}
-              {{ panel.panel_name|safe }}<br>
-              {% endfor %}"
-            >{{panel_count}}
-          </a>
+      {% set panel_count = matching_panels|length %}
+      <a
+        class="badge bg-secondary text-white"
+        data-bs-toggle="popover"
+        data-bs-html="true"
+        data-bs-trigger="hover click"
+        title="Overlapping gene panels"
+        data-bs-content="{% for panel in matching_panels %}
+          {{ panel.panel_name|safe }}<br>
+        {% endfor %}"
+      >{{ panel_count }}</a>
+    {% endmacro %}
+
+    {% if variant.category in ["cancer", "sv_cancer"] %}
+      {% if variant.first_rep_gene %}
+        {{ gene_link(variant.first_rep_gene) }}
+      {% endif %}
+      {% if variant.secondary_gene %}
+        <span class="text-muted">
+          ({{ variant.second_rep_gene.hgnc_symbol or variant.second_rep_gene.hgnc_id }})
+        </span>
+      {% endif %}
+      {% if variant.first_rep_gene or variant.second_rep_gene %}
+        {{ panel_badge(variant, variant.first_rep_gene.hgnc_id or variant.second_rep_gene.hgnc_id) }}
       {% endif %}
     {% else %}
-      {% set panel_count = variant.case_panels|rejectattr('removed')|list|count %}
       {% for gene in variant.genes %}
         <div>
-        <a data-bs-toggle="tooltip" data-bs-html="true" title="
-        <div>
-          <div>
-            <strong>{{ gene.hgnc_symbol }}</strong>: {{ gene.description }}
-          </div>
-          {% if gene.inheritance %}
-            <div>
-              <strong>Models</strong>: {{ gene.inheritance|join(',') }}
-            </div>
-          {% endif %}
-          {% if gene.phenotypes %}
-            <div><strong>OMIM disease</strong>
-            {% for disease in gene.phenotypes %}
-              <div>
-                  {{ disease.description }}
-              </div>
-            {% endfor %}
-            </div>
-          {% endif %}
-        </div>"
-          href="{{ url_for('genes.gene', hgnc_id=gene.hgnc_id) }}">{{ gene.hgnc_symbol or gene.hgnc_id }}
-        {% for model in gene.inheritance %} {{ inheritance_badge(model,inherit_palette) }}{% endfor %}</a>
-        {% if panel_count > 0 %}
-          <a
-            class="badge bg-secondary text-white"
-            data-bs-toggle="popover"
-            data-bs-html="true"
-            data-bs-trigger="hover click"
-            data-bs-content="{% for panel in variant.case_panels|sort(attribute='panel_name',case_sensitive=False)|rejectattr('removed') %}
-              {{ panel.panel_name|safe }}<br>
-              {% endfor %}"
-            title="Overlapping gene panels">{{panel_count}}
-          </a>
-        {% endif %}
-      </div>
+          {{ gene_link(gene) }}
+          {% for model in gene.inheritance %}
+            {{ inheritance_badge(model, inherit_palette) }}
+          {% endfor %}
+          {{ panel_badge(variant, gene.hgnc_id) }}
+        </div>
       {% endfor %}
-
     {% endif %}
+
   </div>
 {% endmacro %}
 

scout/server/blueprints/variants/templates/variants/indicators.html

@@ -74,6 +74,17 @@
   {% endif %}
 {% endmacro %}
 
+{% macro ccv_evaluations_badge(variant) %}
+  {% if variant.ccv_evaluations %}
+    {% for evaluation in (variant.ccv_evaluations or []) %}
+      <span class="badge bg-secondary" style="margin-left:1px" data-bs-toggle="tooltip" data-bs-placement="right"
+        title="Previously classified as {{ evaluation.ccv_classification.label }}">
+        {{ evaluation.ccv_classification.short }}
+      </span>
+    {% endfor %}
+  {% endif %}
+{% endmacro %}
+
 {% macro dismissals_badge(variant) %}
   {% if variant.dismissals %}
       <span class="badge bg-secondary" style="margin-left:1px" data-bs-toggle="tooltip" data-bs-html="true" data-bs-placement="top"

scout/server/extensions/panelapp_extension.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Optional
+from typing import List, Optional
 
 import requests
 
@@ -41,7 +41,7 @@ class PanelAppClient:
             for type in panel.get("types", []):
                 self.panel_types.add(type["slug"])
 
-    def get_panel_ids(self, signed_off: bool) -> list[int]:
+    def get_panel_ids(self, signed_off: bool) -> List[int]:
         """Returns a list of panel ids contained in a json document with gene panels data."""
 
         def get_ids(json_panels):

scout/server/static/custom_images.js

@@ -1,3 +1,11 @@
+const imgMaxWidth = window.innerWidth*0.7;
+const imgMaxHeight = window.innerHeight*0.7;
+
+function calculateAspectRatioFit(srcWidth, srcHeight, maxWidth, maxHeight) {
+    let ratio = Math.min(maxWidth / srcWidth, maxHeight / srcHeight);
+    return [srcWidth*ratio, srcHeight*ratio];
+}
+
 /**
  * This function fetches an image from disk and displays it in a specified div
  * @param {string} imageUrl - The URL of the image to fetch
@@ -9,15 +17,24 @@
 		 .then(blob => {
 				 const img = document.createElement("img");
 				 img.src = URL.createObjectURL(blob);
+				 if (width > imgMaxWidth || height > imgMaxHeight) {
+				 		const resized_pixels = calculateAspectRatioFit(width, height, imgMaxWidth, imgMaxHeight);
+				 		width = resized_pixels[0];
+				 		height = resized_pixels[1];
+				 }
 				 if (width) {
 				 	img.style.width = width+'px';
 				 }
 				 if (height) {
 				 	img.style.height = height+'px';
 				 }
-				 // Display the image in the specified div
+				 // Add the image to a link and add the link to the div
+				 const link = document.createElement('a');
+				 link.appendChild(img);
+				 link.href = img.src;
+				 link.setAttribute('target', "_blank");
 				 const div = document.getElementById(divId);
-				 div.appendChild(img);
+				 div.appendChild(link);
 		})
 		.catch(error => console.error(error));
 }

scout/utils/ccv.py

@@ -0,0 +1,201 @@
+# coding=UTF-8
+from typing import Optional
+
+from scout.constants.ccv import CCV_COMPLETE_MAP, CCV_POTENTIAL_CONFLICTS
+
+
+def get_ccv_points(ccv_terms: set) -> int:
+    """
+    Use the algorithm described in Clingen-CGC-VIGG classification paper (Horak 2022)
+    Given a set of CCV evidence criteria terms
+    for each term,
+      check prefixes if no suffix match or stand-alone criteria match
+
+    O positive, SB negative.
+    VS 8 points, S 4, M 2, P 1.
+
+    If no terms return None
+
+    Args:
+        ccv_terms(set(str)): A collection of prediction terms
+    Returns:
+        points(int):"""
+
+    ovs_terms = []
+    os_terms = []
+    om_terms = []
+    op_terms = []
+    sbvs_terms = []
+    sbs_terms = []
+    sbm_terms = []
+    sbp_terms = []
+
+    prefix_map = {
+        "OVS": ovs_terms,
+        "OS": os_terms,
+        "OM": om_terms,
+        "OP": op_terms,
+        "SBVS": sbvs_terms,
+        "SBS": sbs_terms,
+        "SBM": sbm_terms,
+        "SBP": sbp_terms,
+    }
+
+    suffix_map = {
+        "_Strong": {"O": os_terms, "SB": sbs_terms},
+        "_Moderate": {"O": om_terms, "SB": sbm_terms},
+        "_Supporting": {"O": op_terms, "SB": sbp_terms},
+    }
+
+    for term in ccv_terms:
+        for suffix, prefix_dict in suffix_map.items():
+            if term.endswith(suffix):
+                for prefix, term_list in prefix_dict.items():
+                    if term.startswith(prefix):
+                        term_list.append(term)
+                        break
+                else:
+                    continue
+                break
+        else:
+            for prefix, term_list in prefix_map.items():
+                if term.startswith(prefix):
+                    term_list.append(term)
+                    break
+    points = (
+        8 * len(ovs_terms)
+        + 4 * len(os_terms)
+        + 2 * len(om_terms)
+        + len(op_terms)
+        - 8 * len(sbvs_terms)
+        - 4 * len(sbs_terms)
+        - 2 * len(sbm_terms)
+        - len(sbp_terms)
+    )
+    return points
+
+
+def get_ccv(ccv_terms: set) -> Optional[str]:
+    """Use the algorithm described in Clingen-CGC-VIGG classification paper (Horak 2022)
+
+    If no terms return None
+
+    O >= 10
+    OP 6 <= p <= 9
+    VUS 0 <= p <= 5
+    LB -1 <= p <= -6
+    B <= -7
+
+    Args:
+        ccv_terms(set(str)): A collection of prediction terms
+
+    Returns:
+        prediction(str): in ['uncertain_significance','benign','likely_benign',
+                             'likely_oncogenic','oncogenic']
+
+    """
+    if not ccv_terms:
+        return None
+
+    points = get_ccv_points(ccv_terms)
+
+    if points <= -7:
+        prediction = "benign"
+    elif points <= -1:
+        prediction = "likely_benign"
+    elif points <= 5:
+        prediction = "uncertain_significance"
+    elif points <= 9:
+        prediction = "likely_oncogenic"
+    elif points >= 10:
+        prediction = "oncogenic"
+
+    return prediction
+
+
+def get_ccv_temperature(ccv_terms: set) -> Optional[dict]:
+    """
+    Use the algorithm described in Clingen-CGC-VIGG classification paper (Horak 2022)
+
+    O >= 10
+    OP 6 <= p <= 9
+    VUS 0 <= p <= 5
+    LB -1 <= p <= -6
+    B <= -7
+
+    If no terms return None
+
+    Args:
+        ccv_terms(set(str)): A collection of prediction terms
+
+    Returns:
+        dict:
+            temperature:
+        (points, temperature, point_classification)
+
+    """
+    TEMPERATURE_STRINGS = {
+        -1: {"label": "B/LB", "color": "success", "icon": "fa-times"},
+        0: {"label": "Ice cold", "color": "info", "icon": "fa-icicles"},
+        1: {"label": "Cold", "color": "info", "icon": "fa-snowman"},
+        2: {"label": "Cold", "color": "info", "icon": "fa-snowflake"},
+        3: {"label": "Tepid", "color": "yellow", "icon": "fa-temperature-half"},
+        4: {"label": "Warm", "color": "orange", "icon": "fa-mug-hot"},
+        5: {"label": "Hot", "color": "red", "icon": "fa-pepper-hot"},
+        6: {"label": "LO/O", "color": "danger", "icon": "fa-stethoscope"},
+    }
+
+    if not ccv_terms:
+        points = 0
+        point_classification = "uncertain_significance"
+        return {
+            "points": points,
+            "temperature": TEMPERATURE_STRINGS[points].get("label"),
+            "temperature_class": TEMPERATURE_STRINGS[points].get("color"),
+            "temperature_icon": TEMPERATURE_STRINGS[points].get("icon"),
+            "point_classification": CCV_COMPLETE_MAP[point_classification].get("short"),
+        }
+
+    points = get_ccv_points(ccv_terms)
+
+    if points <= -7:
+        point_classification = "benign"
+        temperature_icon = TEMPERATURE_STRINGS[-1].get("icon")
+    elif points <= -1:
+        point_classification = "likely_benign"
+        temperature_icon = TEMPERATURE_STRINGS[-1].get("icon")
+    elif points <= 5:
+        point_classification = "uncertain_significance"
+    elif points <= 9:
+        point_classification = "likely_oncogenic"
+        temperature_icon = TEMPERATURE_STRINGS[6].get("icon")
+    elif points >= 10:
+        point_classification = "oncogenic"
+        temperature_icon = TEMPERATURE_STRINGS[6].get("icon")
+
+    temperature_class = CCV_COMPLETE_MAP[point_classification].get("color")
+    temperature = CCV_COMPLETE_MAP[point_classification].get("label")
+
+    if point_classification == "uncertain_significance":
+        temperature_class = TEMPERATURE_STRINGS[points].get("color")
+        temperature = TEMPERATURE_STRINGS[points].get("label")
+        temperature_icon = TEMPERATURE_STRINGS[points].get("icon")
+
+    return {
+        "points": points,
+        "temperature": temperature,
+        "temperature_class": temperature_class,
+        "temperature_icon": temperature_icon,
+        "point_classification": CCV_COMPLETE_MAP[point_classification].get("short"),
+    }
+
+
+def get_ccv_conflicts(ccv_terms: set) -> list:
+    """Check potential conflict paris, return list of reference strings."""
+
+    conflicts = []
+    for t1, t2, reference in CCV_POTENTIAL_CONFLICTS:
+        if t1 in ccv_terms and t2 in ccv_terms:
+            conflicts.append(reference)
+
+    return conflicts