scout-browser 4.97.0__py3-none-any.whl → 4.99.0__py3-none-any.whl

scout/server/blueprints/cases/templates/cases/utils.html

@@ -325,21 +325,21 @@
 
   {% if variant.category in ("mei", "str", "snv", "cancer") %}
     {% if variant.category == "cancer" %}
-    <a href="{{ url_for('variant.cancer_variant',
+    <a href='{{ url_for('variant.cancer_variant',
                    institute_id=variant.institute,
                    case_name=case.display_name,
-                   variant_id=variant._id) }}" target="_blank">
+                   variant_id=variant._id) }}' target='_blank'>
     {% else %}
-    <a href="{{ url_for('variant.variant',
+    <a href='{{ url_for('variant.variant',
                    institute_id=variant.institute,
                    case_name=case.display_name,
-                   variant_id=variant._id) }}" target="_blank">
+                   variant_id=variant._id) }}' target='_blank'>
     {% endif %}
   {% else %} <!-- structural variants -->
-    <a href="{{ url_for('variant.sv_variant',
+    <a href='{{ url_for('variant.sv_variant',
                               institute_id=variant.institute,
                               case_name=case.display_name,
-                              variant_id=variant._id) }}" target="_blank">
+                              variant_id=variant._id) }}' target='_blank'>
   {% endif %}
     {{ pretty_variant(variant) }}
   </a>

scout/server/blueprints/clinvar/controllers.py

@@ -28,30 +28,45 @@ LOG = logging.getLogger(__name__)
 
 
 def _get_var_tx_hgvs(case_obj: dict, variant_obj: dict) -> List[Tuple[str, str]]:
-    """Retrieve all transcripts / hgvs for a given variant."""
+    """Retrieve all transcripts / HGVS for a given variant."""
 
     build = str(case_obj.get("genome_build", "37"))
     tx_hgvs_list = [("", "Do not specify")]
+    case_has_build_37 = "37" in case_obj.get("genome_build", "37")
+
     add_gene_info(store, variant_obj, genome_build=build)
+
     for gene in variant_obj.get("genes", []):
-        for tx in gene.get("transcripts", []):
+        transcripts = gene.get("transcripts", [])
+
+        for tx in transcripts:
+
+            refseq_id = tx.get("refseq_id")
+            coding_seq_name = tx.get("coding_sequence_name")
+            if not (refseq_id and coding_seq_name):
+                continue  # Skip transcripts missing required fields
+
             mane_select = tx.get("mane_select_transcript")
-            if all([tx.get("refseq_id"), tx.get("coding_sequence_name")]):
-                for refseq in tx.get("refseq_identifiers"):
-                    refseq_version = fetch_refseq_version(refseq)  # adds version to a refseq ID
-                    hgvs_simple = ":".join([refseq_version, tx["coding_sequence_name"]])
+            mane_plus_clinical = tx.get("mane_plus_clinical_transcript")
+
+            for refseq in tx.get("refseq_identifiers", []):
+                refseq_version = fetch_refseq_version(refseq)  # Adds version to a RefSeq ID
+                hgvs_simple = f"{refseq_version}:{coding_seq_name}"
+
+                refseq_is_mane_select = mane_select == refseq_version
+                refseq_is_mane_plus_clinical = mane_plus_clinical == refseq_version
 
-                    # Validate descriptor using VariantValidator
-                    validated = validate_hgvs(build, hgvs_simple)
+                # Transcript is validate only when conditions are met
+                validated = (
+                    validate_hgvs(build, hgvs_simple)
+                    if (case_has_build_37 or refseq_is_mane_select or refseq_is_mane_plus_clinical)
+                    else ""
+                )
 
-                    label = hgvs_simple
-                    if validated:
-                        label += "_validated_"
+                label = f"{hgvs_simple}{'_validated_' if validated else ''}{'_mane-select_' if refseq_is_mane_select else ''}{'_mane-plus-clinical_' if refseq_is_mane_plus_clinical else ''}"
 
-                    if mane_select and mane_select == refseq_version:
-                        label += "_mane-select_"
+                tx_hgvs_list.append((hgvs_simple, label))
 
-                    tx_hgvs_list.append((hgvs_simple, label))
     return tx_hgvs_list
 
 

scout/server/blueprints/clinvar/templates/clinvar/multistep_add_variant.html

@@ -92,7 +92,7 @@
                   {% if var_category == 'snv' %}
                     <br><br>
                     <!-- Transcripts & HGVS:(optional) -->
-                    {{variant_data.var_form.tx_hgvs.label(class="fw-bold, text-dark")}}
+                    {{ variant_data.var_form.tx_hgvs.label(class="fw-bold, text-dark") }}
 
                     <span class="text-danger" data-bs-toggle='tooltip' title="If you do not provide any HGVS expression, chromosome coordinates will be used to describe this variant instead (automatic). HGVS expressions were validated using VariantValidator"><strong>?</strong></span>
                     <span class="badge bg-primary float-end"><a class="text-white" href="https://variantvalidator.org/service/validate/" target="_blank" rel="noopener">VariantValidator</a></span>
@@ -101,7 +101,7 @@
                     {% with messages = get_flashed_messages() %}
                       {% if messages %}
                         {% for message in messages %}
-                          <span class="ml-3" style="color:red">{{ message }}</span><br>
+                          <span class="ml-3">{{ message }}</span><br>
                         {% endfor %}
                         <br><br>
                       {% endif %}
@@ -113,14 +113,17 @@
                     {% for item_row in variant_data.var_form.tx_hgvs | batch(3) %}
                       <tr>
                       {% for item in item_row %}
-                        {% set ns = namespace(label='', validated=false, mane_select=false) %}
-
+                        {% set ns = namespace(label='', validated=false, mane_select=false, mane_plus_clinical=false) %}
                         {% if "_validated_" in item.label.text %}
                           {% set ns.validated = true %}
                         {% endif %}
                         {% if "_mane-select_" in item.label.text %}
                           {% set ns.mane_select = true %}
                         {% endif %}
+                        {% if "_mane-plus-clinical_" in item.label.text %}
+                           {% set ns.mane_plus_clinical = true %}
+                        {% endif %}
+
                         {% set ns.label = item.label.text | replace("_validated_", "") | replace("_mane-select_", "")  %}
 
                         <td style="width: 3%; text-align: right; vertical-align: baseline;">
@@ -138,6 +141,9 @@
                           {% if ns.mane_select %}
                             <span class='badge bg-dark'>MANE SELECT</span>
                           {% endif %}
+                          {% if ns.mane_plus_clinical %}
+                            <span class='badge bg-dark'>MANE PLUS CLINICAL</span>
+                          {% endif %}
                           {% if ns.validated %}
                             <em class="fa fa-check text-success" aria-hidden="true" data-bs-toggle="tooltip" title="Verified by VariantValidator"></em>
                           {% endif %}
@@ -147,6 +153,9 @@
                       </tr>
                     {% endfor %}
                     </table>
+
+                    <span class="text-danger">HGVS validation is performed only for variants in build GRCh37 or MANE Select and MANE Plus Clinical transcripts. For any other available HGVS present in this list, manual validation can be performed using the VariantValidator link above.</span>
+
                     <br><br>
                     <!-- dbSNP identifier -->
                     {{variant_data.var_form.variations_ids.label(class="fw-bold, text-dark")}}

scout/server/blueprints/clinvar/views.py

@@ -3,10 +3,22 @@ from json import dumps
 from tempfile import NamedTemporaryFile
 from typing import List, Tuple
 
-from flask import Blueprint, flash, redirect, render_template, request, send_file, url_for
+from flask import (
+    Blueprint,
+    flash,
+    redirect,
+    render_template,
+    request,
+    send_file,
+    url_for,
+)
 from flask_login import current_user
 
-from scout.constants.clinvar import CASEDATA_HEADER, CLINVAR_HEADER, GERMLINE_CLASSIF_TERMS
+from scout.constants.clinvar import (
+    CASEDATA_HEADER,
+    CLINVAR_HEADER,
+    GERMLINE_CLASSIF_TERMS,
+)
 from scout.server.extensions import clinvar_api, store
 from scout.server.utils import institute_and_case
 

scout/server/blueprints/institutes/controllers.py

@@ -391,8 +391,16 @@ def update_institute_settings(store: MongoAdapter, institute_obj: Dict, form: Mu
     updated_institute = store.update_institute(
         internal_id=institute_obj["_id"],
         sanger_recipients=get_sanger_recipients(form),
-        coverage_cutoff=int(form.get("coverage_cutoff")),
-        frequency_cutoff=float(form.get("frequency_cutoff")),
+        coverage_cutoff=(
+            int(form["coverage_cutoff"])
+            if form.get("coverage_cutoff")
+            else form.get("coverage_cutoff")
+        ),
+        frequency_cutoff=(
+            float(form["frequency_cutoff"])
+            if form.get("frequency_cutoff")
+            else form.get("frequency_cutoff")
+        ),
         show_all_cases_status=form.getlist("show_all_cases_status"),
         display_name=form.get("display_name"),
         phenotype_groups=phenotype_groups,

scout/server/blueprints/institutes/templates/overview/filters.html

@@ -34,8 +34,21 @@
   <div class="row" id="body-row"> <!--sidebar and main container are on the same row-->
     {{ institute_actionbar(institute) }} <!-- This is the sidebar -->
     <div class="col">
+
       <div class="card">
-        <div class="card-header"><b>Filters created for institute on variants pages</b></div>
+        <div class="card-header"><b>Soft filters created by an admin on the institute's settings page</b></div>
+        <div class="card-body">
+          {% for filter_tag in institute.soft_filters %}
+            <span class="badge bg-secondary">{{filter_tag}}</span>
+          {% else%}
+            No soft filters available
+          {% endfor %}
+
+        </div>
+      </div>
+
+      <div class="card mt-3">
+        <div class="card-header"><b>Custom filters created for institute on variants pages</b></div>
         <div class="card-body">
           <ul class="list-group">
            <li class="list-group-item list-group-item-heading">

scout/server/blueprints/login/controllers.py

@@ -1,22 +1,20 @@
 import logging
+from datetime import datetime
+from typing import Optional
 
-from flask import current_app, flash
+import requests
+from flask import Response, current_app, flash, redirect, session, url_for
+from flask_login import login_user
 
-from scout.server.extensions import ldap_manager
-
-LOG = logging.getLogger(__name__)
+from scout.server.extensions import ldap_manager, oauth_client, store
 
+from .models import LoginUser
 
-def ldap_authorized(userid, password):
-    """Log in a LDAP user
+LOG = logging.getLogger(__name__)
 
-    Args:
-        userid(str): user id provided in ldap login form (usually and email)
-        password(str): user passord provided in ldap loding form
 
-    Returns:
-        authorized(bool): True or False
-    """
+def ldap_authorized(userid: str, password: str) -> bool:
+    """Log in an LDAP user."""
     authorized = False
     try:
         authorized = ldap_manager.authenticate(
@@ -63,3 +61,105 @@ def users(store):
     return dict(
         users=sorted(user_objs, key=lambda user: -user["events"]),
     )
+
+
+def user_has_consented(user_consent: Optional[str]) -> bool:
+    """Check if user has given consent for activity logging."""
+    if not current_app.config.get("USERS_ACTIVITY_LOG_PATH"):
+        return True
+
+    if user_consent is None and "consent_given" not in session:
+        flash(
+            "Logging user activity is a requirement for using this site and accessing your account. Without consent to activity logging, you will not be able to log in into Scout.",
+            "warning",
+        )
+        return False
+    return True
+
+
+def ldap_login(ldap_user: Optional[str], ldap_password: Optional[str]) -> Optional[str]:
+    """Authenticate user via LDAP and return user ID if authorized."""
+
+    if not ldap_user or not ldap_password:
+        return None
+
+    authorized: bool = ldap_authorized(ldap_user, ldap_password)
+
+    if authorized:
+        return ldap_user
+
+    flash("User not authorized by LDAP server", "warning")
+
+
+def google_login() -> Optional[Response]:
+    """Authenticate user via Google OIDC and redirect to the redirect URI. The name of this endpoint should be present on the Google login settings."""
+    if "email" in session:
+        return redirect(url_for("public.login"))  # Redirect to the login route with session info
+
+    redirect_uri: str = url_for("login.authorized", _external=True)
+    try:
+        return oauth_client.google.authorize_redirect(redirect_uri)
+    except Exception:
+        flash("An error has occurred while logging in user using Google OAuth", "warning")
+        return None
+
+
+def keycloak_login() -> Optional[Response]:
+    """Authenticate user via Keycloak OIDC and redirect to the redirect URI. The name of this endpoint should be present on the Keycloak login settings."""
+
+    redirect_uri: str = url_for("login.authorized", _external=True)
+    try:
+        return oauth_client.keycloak.authorize_redirect(redirect_uri)
+    except Exception:
+        flash("An error has occurred while logging in user using Keycloak", "warning")
+        return None
+
+
+def database_login(user_mail: Optional[str]) -> Optional[str]:
+    """Authenticate user against the Scout database and return email if successful."""
+    return user_mail
+
+
+def validate_and_login_user(user_mail: Optional[str], user_id: Optional[str]) -> Response:
+    """Validate user in Scout database and log them in."""
+    user_obj: Optional[dict] = store.user(email=user_mail, user_id=user_id)
+
+    if user_obj is None:
+        flash("User not found in Scout database", "warning")
+        session.pop("email", None)
+        return redirect(url_for("public.index"))
+
+    user_obj["accessed_at"] = datetime.now()
+
+    if session.get("name"):  # Set name & locale if available (Google Auth)
+        user_obj["name"] = session.get("name")
+        user_obj["locale"] = session.get("locale")
+
+    store.update_user(user_obj)
+    return perform_flask_login(LoginUser(user_obj))
+
+
+def perform_flask_login(user_dict: "LoginUser") -> Response:
+    """Login user using Flask-Login."""
+    if login_user(user_dict, remember=True):
+        flash(f"Welcome {user_dict.name}", "success")
+        return redirect(url_for("cases.index"))
+
+    flash("Sorry, you could not log in", "warning")
+    return redirect(url_for("public.index"))
+
+
+def logout_oidc_user(session, provider: str):
+    """Log out a user from an OIDC login provider-"""
+    logout_url = current_app.config[provider].get("logout_url")
+    if not logout_url or not session.get("token_response"):
+        return
+    refresh_token = session["token_response"]["refresh_token"]
+    requests.post(
+        logout_url,
+        data={
+            "client_id": current_app.config[provider]["client_id"],
+            "client_secret": current_app.config[provider]["client_secret"],
+            "refresh_token": refresh_token,
+        },
+    )

scout/server/blueprints/login/views.py

@@ -1,9 +1,10 @@
 # -*- coding: utf-8 -*-
 import logging
-from datetime import datetime
+from typing import Optional
 
 from flask import (
     Blueprint,
+    Response,
     current_app,
     flash,
     redirect,
@@ -45,82 +46,67 @@ def load_user(user_id):
 
 @login_bp.route("/login", methods=["GET", "POST"])
 @public_endpoint
-def login():
+def login() -> Response:
     """Login a user if they have access."""
 
-    if current_app.config.get("USERS_ACTIVITY_LOG_PATH"):
-        if request.form.get("consent_checkbox") is None and "consent_given" not in session:
-            flash(
-                "Logging user activity is a requirement for using this site and accessing your account. Without consent to activity logging, you will not be able to log in into Scout.",
-                "warning",
-            )
-            return redirect(url_for("public.index"))
-        session["consent_given"] = True
+    if controllers.user_has_consented(user_consent=request.form.get("consent_checkbox")) is False:
+        return redirect(url_for("public.index"))
 
-    user_id = None
-    user_mail = None
+    user_id: Optional[str] = None
+    user_mail: Optional[str] = None
 
     if current_app.config.get("LDAP_HOST", current_app.config.get("LDAP_SERVER")):
-        ldap_authorized = controllers.ldap_authorized(
-            request.form.get("ldap_user"), request.form.get("ldap_password")
+        user_id = controllers.ldap_login(
+            ldap_user=request.form.get("ldap_user"), ldap_password=request.form.get("ldap_password")
         )
-        if ldap_authorized is True:
-            user_id = request.form.get("ldap_user")
-        else:
-            flash("User not authorized by LDAP server", "warning")
+        if user_id is None:
             return redirect(url_for("public.index"))
 
     elif current_app.config.get("GOOGLE"):
         if session.get("email"):
             user_mail = session["email"]
-            session.pop("email", None)
         else:
-            redirect_uri = url_for(".authorized", _external=True)
-            try:
-                return oauth_client.google.authorize_redirect(redirect_uri)
-            except Exception as ex:
-                flash("An error has occurred while logging in user using Google OAuth")
-
-    elif request.form.get("email"):  # log in against Scout database
-        user_mail = request.form["email"]
-        LOG.info("Validating user %s email %s against Scout database", user_id, user_mail)
-
-    user_obj = store.user(email=user_mail, user_id=user_id)
-    if user_obj is None:
-        flash("User not found in Scout database", "warning")
-        return redirect(url_for("public.index"))
+            # Redirect to Google OAuth if not completed
+            return controllers.google_login()
+
+    elif current_app.config.get("KEYCLOAK"):
+        if session.get("email"):
+            user_mail = session["email"]
+        else:
+            return controllers.keycloak_login()
 
-    user_obj["accessed_at"] = datetime.now()
-    if session.get("name"):  # These args come from google auth
-        user_obj["name"] = session.get("name")
-        user_obj["locale"] = session.get("locale")
-    store.update_user(user_obj)
+    elif request.form.get("email"):
+        user_mail = controllers.database_login(user_mail=request.form.get("email"))
 
-    user_dict = LoginUser(user_obj)
-    return perform_login(user_dict)
+    return controllers.validate_and_login_user(user_mail=user_mail, user_id=user_id)
 
 
 @login_bp.route("/authorized")
 @public_endpoint
 def authorized():
-    """Google auth callback function"""
-
-    token = oauth_client.google.authorize_access_token()
-    google_user = oauth_client.google.parse_id_token(token, None)
-    session["email"] = google_user.get("email").lower()
-    session["name"] = google_user.get("name")
-    session["locale"] = google_user.get("locale")
+    """OIDC callback function."""
+    if current_app.config.get("GOOGLE"):
+        client = oauth_client.google
+    if current_app.config.get("KEYCLOAK"):
+        client = oauth_client.keycloak
+    token = client.authorize_access_token()
+    user = client.parse_id_token(token, None)
+
+    session["email"] = user.get("email").lower()
+    session["name"] = user.get("name")
+    session["locale"] = user.get("locale")
+    session["token_response"] = token
 
     return redirect(url_for(".login"))
 
 
 @login_bp.route("/logout")
 def logout():
-    logout_user()
-    session.pop("email", None)
-    session.pop("name", None)
-    session.pop("locale", None)
-    session.pop("consent_given", None)
+    logout_user()  # logs out user from scout
+    for provider in ["GOOGLE", "KEYCLOAK"]:
+        if current_app.config.get(provider):
+            controllers.logout_oidc_user(session, provider)
+    session.clear()
     flash("you logged out", "success")
     return redirect(url_for("public.index"))
 
@@ -130,11 +116,3 @@ def users():
     """Show all users in the system."""
     data = controllers.users(store)
     return render_template("login/users.html", **data)
-
-
-def perform_login(user_dict):
-    if login_user(user_dict, remember=True):
-        flash("you logged in as: {}".format(user_dict.name), "success")
-        return redirect(url_for("cases.index"))
-    flash("sorry, you could not log in", "warning")
-    return redirect(url_for("public.index"))

scout/server/blueprints/public/templates/public/index.html

@@ -21,7 +21,11 @@
       </p>
     {% else %}
       <form class="row" method="POST" action="{{ url_for('login.login') }}">
-        {% if config.GOOGLE %}
+        {% if config.KEYCLOAK %}
+          <button name="googleLogin" class="btn btn-primary btn-lg text-white" href="{{ url_for('login.login') }}" type="submit">
+            Login with Keycloak
+          </button>
+        {% elif config.GOOGLE %}
           <button name="googleLogin" class="btn btn-primary btn-lg text-white" href="{{ url_for('login.login') }}" type="submit">
             Login with Google
           </button>

scout/server/blueprints/variant/controllers.py

@@ -369,7 +369,7 @@ def variant(
 
     overlapping_vars = []
     if get_overlapping:
-        for var in store.overlapping(variant_obj):
+        for var in store.hgnc_overlapping(variant_obj):
             var.update(predictions(var.get("genes", [])))
             overlapping_vars.append(var)
     variant_obj["end_chrom"] = variant_obj.get("end_chrom", variant_obj["chromosome"])

scout/server/blueprints/variant/templates/variant/acmg.html

@@ -79,7 +79,11 @@
                       <div class="row">
                         <select {{ 'disabled' if evaluation and edit is false}} id="modifier-{{ criterion_code }}" name="modifier-{{ criterion_code }}" class="form-control form-select">
                           <option value="" {% if not modifier %}selected{% endif %}>Strength modifier...</option>
-                          {% for level in "Strong", "Moderate", "Supporting" %}
+                          {% set sa_level = "Stand-alone" %}
+                          {% if category == "pathogenicity" %}
+                            {% set sa_level = "Very Strong" %}
+                          {% endif %}
+                          {% for level in sa_level, "Strong", "Moderate", "Supporting" %}
                             {% if(level != evidence) %}
                               <option id="{{ criterion_code }}-{{ level }}" value="{{ level }}" {% if modifier == level %}selected{% endif %}>{{ level }}</option>
                             {% endif %}
@@ -148,7 +152,7 @@
 
     function update_classification() {
       var criteria = $(':checked').map(function(idx, elem) {
-        const modifiers = ["Strong", "Moderate", "Supporting"];
+        const modifiers = ["Stand-alone", "Very Strong", "Strong", "Moderate", "Supporting"];
         for (possible_modifier of modifiers) {
           var modifier_option;
           if(elem.value !== null && elem.value !== '') {

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

@@ -32,6 +32,25 @@
       </tbody>
     </table>
   {% endif %}
+
+  {% if variant.clnsig_onc %}
+    <table id='clinsig_table' class="table table-bordered table-sm">
+      <thead>
+        <th>Oncogenicity</th>
+        <th>Disease name</th>
+        <th>Revstat</th>
+      </thead>
+      <tbody>
+        {% for classif in variant.clnsig_onc %}
+          <tr>
+            <td>{{ classif.value|capitalize }}</td>
+            <td>{{ classif.dn|replace("_", " ")|replace(",", ", ") }}</td>
+            <td>{{ classif.revstat }}</td>
+          </tr>
+        {% endfor %}
+      </tbody>
+    </table>
+  {% endif %}
 {% endmacro %}
 
 {% macro acmg_classification_item(variant, data) %}

scout/server/blueprints/variant/templates/variant/utils.html

@@ -118,10 +118,10 @@
 
 {% macro overlapping_panel(variant, overlapping_vars, case, institute) %}
   <div class="card panel-default">
-    {% if variant.category == 'sv' %}
-      <div class="panel-heading">Overlapping SNVs</div>
+    {% if variant.category != "snv" %}
+      <div class="panel-heading">Gene overlapping variants</div>
     {% else %}
-      <div class="panel-heading">Overlapping SVs</div>
+      <div class="panel-heading">Gene overlapping non-SNVs</div>
     {% endif %}
     <div class="card-body">
       <div class="table-responsive">

scout/server/blueprints/variants/controllers.py

@@ -137,7 +137,7 @@ def variants(
 
     variants = []
     for variant_obj in variant_res:
-        overlapping_svs = list(store.overlapping(variant_obj))
+        overlapping_svs = list(store.hgnc_overlapping(variant_obj))
         variant_obj["overlapping"] = overlapping_svs or None
 
         evaluations = []
@@ -233,6 +233,9 @@ def sv_variants(store, institute_obj, case_obj, variants_query, variant_count, p
     case_dismissed_vars = store.case_dismissed_variants(institute_obj, case_obj)
 
     for variant_obj in variants_query.skip(skip_count).limit(per_page):
+        overlapping_svs = list(store.hgnc_overlapping(variant_obj))
+        variant_obj["overlapping"] = overlapping_svs or None
+
         # show previous classifications for research variants
         clinical_var_obj = variant_obj
         if variant_obj["variant_type"] == "research":
@@ -279,6 +282,9 @@ def mei_variants(
     case_dismissed_vars = store.case_dismissed_variants(institute_obj, case_obj)
 
     for variant_obj in variants_query.skip(skip_count).limit(per_page):
+        overlapping = list(store.hgnc_overlapping(variant_obj))
+        variant_obj["overlapping"] = overlapping or None
+
         # show previous classifications for research variants
         clinical_var_obj = variant_obj
         if variant_obj["variant_type"] == "research":
@@ -1448,6 +1454,9 @@ def cancer_variants(store, institute_id, case_name, variants_query, variant_coun
         variant_obj["second_rep_gene"] = secondary_gene
         variant_obj["clinical_assessments"] = get_manual_assessments(variant_obj)
 
+        overlapping = list(store.hgnc_overlapping(variant_obj))
+        variant_obj["overlapping"] = overlapping or None
+
         evaluations = []
         # Get previous ClinGen-CGC-VIGG evaluations of the variant from other cases
         for evaluation_obj in store.get_ccv_evaluations(variant_obj):