scout-browser 4.82.2__py3-none-any.whl → 4.83__py3-none-any.whl

scout/commands/update/case.py

@@ -94,7 +94,6 @@ def case(
     """
     Update a case in the database
     """
-    adapter = store
 
     if not case_id:
         if not (case_name and institute):
@@ -104,7 +103,7 @@ def case(
             raise click.Abort()
 
     # Check if the case exists
-    case_obj = adapter.case(case_id=case_id, institute_id=institute, display_name=case_name)
+    case_obj = store.case(case_id=case_id, institute_id=institute, display_name=case_name)
 
     if not case_obj:
         LOG.warning("Case %s could not be found", case_id)
@@ -112,7 +111,7 @@ def case(
 
     case_changed = False
     if collaborator:
-        if not adapter.institute(collaborator):
+        if not store.institute(collaborator):
             LOG.warning("Institute %s could not be found", collaborator)
             return
         if not collaborator in case_obj["collaborators"]:
@@ -139,7 +138,8 @@ def case(
         case_changed = True
 
     if case_changed:
-        adapter.update_case(case_obj)
+        institute_obj = store.institute(case_obj["owner"])
+        store.update_case_cli(case_obj, institute_obj)
 
     if reupload_sv:
         LOG.info("Set needs_check to True for case %s", case_id)
@@ -151,7 +151,7 @@ def case(
         if vcf_sv:
             updates["vcf_files.vcf_sv_research"] = vcf_sv_research
 
-        updated_case = adapter.case_collection.find_one_and_update(
+        updated_case = store.case_collection.find_one_and_update(
             {"_id": case_id},
             {"$set": updates},
             return_document=pymongo.ReturnDocument.AFTER,
@@ -159,8 +159,8 @@ def case(
         rankscore_treshold = rankscore_treshold or updated_case.get("rank_score_threshold", 5)
         # Delete and reload the clinical SV variants
         if updated_case["vcf_files"].get("vcf_sv"):
-            adapter.delete_variants(case_id, variant_type="clinical", category="sv")
-            adapter.load_variants(
+            store.delete_variants(case_id, variant_type="clinical", category="sv")
+            store.load_variants(
                 updated_case,
                 variant_type="clinical",
                 category="sv",
@@ -168,13 +168,13 @@ def case(
             )
         # Delete and reload research SV variants
         if updated_case["vcf_files"].get("vcf_sv_research"):
-            adapter.delete_variants(case_id, variant_type="research", category="sv")
+            store.delete_variants(case_id, variant_type="research", category="sv")
             if updated_case.get("is_research"):
-                adapter.load_variants(
+                store.load_variants(
                     updated_case,
                     variant_type="research",
                     category="sv",
                     rank_threshold=int(rankscore_treshold),
                 )
         # Update case variants count
-        adapter.case_variants_count(case_obj["_id"], case_obj["owner"], force_update_case=True)
+        store.case_variants_count(case_obj["_id"], case_obj["owner"], force_update_case=True)

scout/commands/update/individual.py

@@ -1,5 +1,6 @@
 """Code for updating information on individuals
 """
+
 from pathlib import Path
 
 import click
@@ -95,4 +96,8 @@ def individual(case_id, ind, key, value):
 
             ind_obj[key] = value
 
-    store.update_case(case_obj)
+    link = f"/{case_obj['owner']}/{case_obj['display_name']}"
+    institute_obj = store.institute(case_obj["owner"])
+    store.update_case_individual(
+        case_obj, user_obj=None, institute_obj=institute_obj, link=link, keep_date=False
+    )

scout/constants/file_types.py

@@ -8,9 +8,13 @@ FILE_TYPE_MAP = {
     "vcf_fusion": {"category": "fusion", "variant_type": "clinical"},
     "vcf_fusion_research": {"category": "fusion", "variant_type": "research"},
     "vcf_snv": {"category": "snv", "variant_type": "clinical"},
+    "vcf_snv_mt": {"category": "snv", "variant_type": "clinical"},
     "vcf_snv_research": {"category": "snv", "variant_type": "research"},
+    "vcf_snv_research_mt": {"category": "snv", "variant_type": "research"},
     "vcf_sv": {"category": "sv", "variant_type": "clinical"},
+    "vcf_sv_mt": {"category": "sv", "variant_type": "clinical"},
     "vcf_sv_research": {"category": "sv", "variant_type": "research"},
+    "vcf_sv_research_mt": {"category": "sv", "variant_type": "research"},
     "vcf_str": {"category": "str", "variant_type": "clinical"},
     "vcf_mei": {"category": "mei", "variant_type": "clinical"},
     "vcf_mei_research": {"category": "mei", "variant_type": "research"},

scout/load/__init__.py

@@ -1,5 +1,4 @@
 from .all import load_scout
-from .case import load_case
 from .cytoband import load_cytobands
 from .exon import load_exons
 from .hgnc_gene import load_hgnc_genes

scout/load/all.py

@@ -54,11 +54,11 @@ def load_region(adapter, case_id, hgnc_id=None, chrom=None, start=None, end=None
         start = gene_caption["start"]
         end = gene_caption["end"]
 
-    case_file_types = []
+    case_file_types = set()
 
     for file_type in FILE_TYPE_MAP:
         if case_obj.get("vcf_files", {}).get(file_type):
-            case_file_types.append(
+            case_file_types.add(
                 (FILE_TYPE_MAP[file_type]["variant_type"], FILE_TYPE_MAP[file_type]["category"])
             )
 
@@ -84,13 +84,12 @@ def load_region(adapter, case_id, hgnc_id=None, chrom=None, start=None, end=None
     adapter.case_variants_count(case_obj["_id"], case_obj["owner"], force_update_case=True)
 
 
-def load_scout(adapter, config, ped=None, update=False):
+def load_scout(adapter, config, update=False):
     """Load a new case from a Scout config.
 
     Args:
         adapter(MongoAdapter)
         config(dict): loading info
-        ped(Iterable(str)): Pedigree ingformation
         update(bool): If existing case should be updated
 
     DEPRECATED method, historically used by the CG monolith, which has since switched to call the Scout CLI instead.

scout/load/panel.py

@@ -7,6 +7,7 @@ functions to load panels into the database
 import logging
 import math
 from datetime import datetime
+from typing import Dict, List
 
 from click import Abort
 from flask.cli import current_app
@@ -110,7 +111,7 @@ def load_panel(panel_path, adapter, **kwargs):
         raise err
 
 
-def _panelapp_panel_ids():
+def _panelapp_panel_ids() -> List[str]:
     """Fetch all PanelApp panel IDs"""
     json_lines = fetch_resource(PANELAPP_BASE_URL.format("list_panels"), json=True)
     return [panel_info["Panel_Id"] for panel_info in json_lines.get("result", [])]
@@ -129,11 +130,14 @@ def _parse_panelapp_panel(adapter, panel_id, institute, confidence):
             {'version': 3.3, 'date': datetime.datetime(2023, 1, 31, 16, 43, 37, 521719), 'display_name': 'Diabetes - neonatal onset - [GREEN]', 'institute': 'cust000', 'panel_type': 'clinical', 'genes': [list of genes], 'panel_id': '55a9041e22c1fc6711b0c6c0'}
 
     """
-    hgnc_map = adapter.ensembl_to_hgnc_mapping()
+    ensembl_gene_hgnc_id_map: Dict[str, int] = adapter.ensembl_to_hgnc_id_mapping()
+    hgnc_symbol_ensembl_gene_map: Dict[str, str] = adapter.hgnc_symbol_ensembl_id_mapping()
+
     json_lines = fetch_resource(PANELAPP_BASE_URL.format("get_panel") + panel_id, json=True)
     parsed_panel = parse_panel_app_panel(
         panel_info=json_lines["result"],
-        hgnc_map=hgnc_map,
+        ensembl_gene_hgnc_id_map=ensembl_gene_hgnc_id_map,
+        hgnc_symbol_ensembl_gene_map=hgnc_symbol_ensembl_gene_map,
         institute=institute,
         confidence=confidence,
     )
@@ -160,7 +164,7 @@ def load_panelapp_panel(adapter, panel_id=None, institute="cust000", confidence=
 
     if not panel_id:
         LOG.info("Fetching all panel app panels")
-        panel_ids = _panelapp_panel_ids()
+        panel_ids: List[str] = _panelapp_panel_ids()
 
     for _ in panel_ids:
         parsed_panel = _parse_panelapp_panel(adapter, _, institute, confidence)

scout/load/setup.py

@@ -5,6 +5,7 @@ This means add a default institute, a user and the internal definitions such as
 transcripts, hpo terms etc
 
 """
+
 import logging
 
 import yaml

scout/models/case/case_loading_models.py

@@ -15,7 +15,7 @@ except ImportError:
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 
-from scout.constants import ANALYSIS_TYPES
+from scout.constants import ANALYSIS_TYPES, FILE_TYPE_MAP
 from scout.exceptions import PedigreeError
 from scout.utils.date import get_date
 
@@ -58,21 +58,7 @@ CASE_FILE_PATH_CHECKS = [
     "RNAfusion_report_research",
 ]
 
-VCF_FILE_PATH_CHECKS = [
-    "vcf_cancer",
-    "vcf_cancer_research",
-    "vcf_cancer_sv",
-    "vcf_cancer_sv_research",
-    "vcf_fusion",
-    "vcf_fusion_research",
-    "vcf_snv",
-    "vcf_snv_research",
-    "vcf_mei",
-    "vcf_mei_research",
-    "vcf_str",
-    "vcf_sv",
-    "vcf_sv_research",
-]
+VCF_FILE_PATH_CHECKS = FILE_TYPE_MAP.keys()
 
 GENOME_BUILDS = ["37", "38"]
 TRACKS = ["rare", "cancer"]
@@ -110,12 +96,16 @@ class VcfFiles(BaseModel):
     vcf_cancer_sv: Optional[str] = None
     vcf_cancer_sv_research: Optional[str] = None
     vcf_snv: Optional[str] = None
+    vcf_snv_mt: Optional[str] = None
     vcf_snv_research: Optional[str] = None
+    vcf_snv_research_mt: Optional[str] = None
     vcf_mei: Optional[str] = None
     vcf_mei_research: Optional[str] = None
     vcf_str: Optional[str] = None
     vcf_sv: Optional[str] = None
+    vcf_sv_mt: Optional[str] = None
     vcf_sv_research: Optional[str] = None
+    vcf_sv_research_mt: Optional[str] = None
     vcf_fusion: Optional[str] = None
     vcf_fusion_research: Optional[str] = None
 

scout/parse/case.py

@@ -86,7 +86,6 @@ def parse_case_data(**kwargs):
         config_dict["case_id"] = config_dict["family"]
 
     if config_dict.get("smn_tsv"):
-        LOG.info("Adding SMN info from {}.".format(config_dict["smn_tsv"]))
         add_smn_info_case(config_dict)
 
     return remove_none_recursive(config_dict)

scout/parse/disease_terms.py

@@ -1,4 +1,5 @@
 """Code for parsing disease terms from OMIM and ORPHA data"""
+
 import logging
 from typing import Dict, List
 

scout/parse/omim.py

@@ -1,4 +1,5 @@
 """Code for parsing OMIM formatted files"""
+
 import logging
 from typing import Any, Dict, Iterable
 

scout/parse/panel.py

@@ -1,6 +1,8 @@
 """Code to parse panel information"""
+
 import logging
 from datetime import datetime
+from typing import Dict, List, Optional
 
 from scout.constants import (
     INCOMPLETE_PENETRANCE_MAP,
@@ -233,7 +235,12 @@ def parse_genes(gene_lines):
 
 
 def parse_gene_panel(
-    path, institute="cust000", panel_id="test", panel_type="clinical", genes=None, **kwargs
+    path,
+    institute="cust000",
+    panel_id="test",
+    panel_type="clinical",
+    genes=None,
+    **kwargs,
 ):
     """Parse the panel info and return a gene panel
 
@@ -268,17 +275,14 @@ def parse_gene_panel(
     return gene_panel
 
 
-def parse_panel_app_gene(app_gene, hgnc_map, confidence):
-    """Parse a panel app formatted gene.
+def parse_panel_app_gene(
+    app_gene: dict,
+    ensembl_gene_hgnc_id_map: Dict[str, int],
+    hgnc_symbol_ensembl_gene_map: Dict[str, str],
+    confidence: str,
+) -> dict:
+    """Parse a panel app-formatted gene."""
 
-    Args:
-        app_gene(dict): dict with panel app info, where Ensembl ids are present as a loist with key "EnsembleGeneIds"
-        hgnc_map(dict): a dictionary with Ensembl IDs as keys and HGNC ids as values
-        confidence(str): enum green|amber|red
-
-    Returns:
-        gene_info(dict): Scout infromation
-    """
     gene_info = {}
     confidence_level = app_gene["LevelOfConfidence"]
     # Return empty gene if not confident gene
@@ -288,8 +292,22 @@ def parse_panel_app_gene(app_gene, hgnc_map, confidence):
     hgnc_symbol = app_gene["GeneSymbol"]
 
     ensembl_ids = app_gene["EnsembleGeneIds"]
+
+    if not ensembl_ids:  # This gene is probably tagged as ensembl_ids_known_missing on PanelApp
+        if hgnc_symbol in hgnc_symbol_ensembl_gene_map:
+            LOG.warning(
+                f"PanelApp gene {hgnc_symbol} does not contain Ensembl IDs. Using Ensembl IDs from internal gene collection instead."
+            )
+            ensembl_ids = [hgnc_symbol_ensembl_gene_map[hgnc_symbol]]
+        else:
+            LOG.warning(
+                f"PanelApp gene {hgnc_symbol} does not contain Ensembl IDs and gene symbol does not correspond to a gene in scout."
+            )
+
     hgnc_ids = set(
-        hgnc_map.get(ensembl_id) for ensembl_id in ensembl_ids if hgnc_map.get(ensembl_id)
+        ensembl_gene_hgnc_id_map.get(ensembl_id)
+        for ensembl_id in ensembl_ids
+        if ensembl_gene_hgnc_id_map.get(ensembl_id)
     )
     if not hgnc_ids:
         LOG.warning("Gene %s does not exist in database. Skipping gene...", hgnc_symbol)
@@ -314,8 +332,13 @@ def parse_panel_app_gene(app_gene, hgnc_map, confidence):
 
 
 def parse_panel_app_panel(
-    panel_info, hgnc_map, institute="cust000", panel_type="clinical", confidence="green"
-):
+    panel_info: dict,
+    ensembl_gene_hgnc_id_map: Dict[str, int],
+    hgnc_symbol_ensembl_gene_map: Dict[str, str],
+    institute: Optional[str] = "cust000",
+    panel_type: Optional[str] = "clinical",
+    confidence: Optional[str] = "green",
+) -> dict:
     """Parse a PanelApp panel
 
     Args:
@@ -346,7 +369,9 @@ def parse_panel_app_panel(
     nr_excluded = 0
     nr_genes = 0
     for nr_genes, gene in enumerate(panel_info["Genes"], 1):
-        gene_info = parse_panel_app_gene(gene, hgnc_map, confidence)
+        gene_info = parse_panel_app_gene(
+            gene, ensembl_gene_hgnc_id_map, hgnc_symbol_ensembl_gene_map, confidence
+        )
         if not gene_info:
             nr_excluded += 1
             continue

scout/resources/__init__.py

@@ -12,3 +12,6 @@ cytoband_files = {
     "37": cytobands_37_path,
     "38": cytobands_38_path,
 }
+
+# Custom IGV tracks
+mane_igv_track_path = str(files(BASE_PATH).joinpath("custom_igv_tracks", "mane.bb"))

scout/server/app.py

@@ -8,7 +8,6 @@ from urllib.parse import parse_qsl, unquote, urlsplit
 
 import coloredlogs
 from flask import Flask, current_app, redirect, request, url_for
-from flask_babel import Babel
 from flask_cors import CORS
 from flask_login import current_user
 from markdown import markdown as python_markdown
@@ -36,16 +35,6 @@ from .blueprints import (
 
 LOG = logging.getLogger(__name__)
 
-try:
-    from chanjo_report.server.app import configure_template_filters
-    from chanjo_report.server.blueprints import report_bp
-    from chanjo_report.server.extensions import api as chanjo_api
-except ImportError:
-    chanjo_api = None
-    report_bp = None
-    configure_template_filters = None
-    LOG.info("chanjo report not installed!")
-
 
 def create_app(config_file=None, config=None):
     """Flask app factory function."""
@@ -111,8 +100,8 @@ def configure_extensions(app):
     extensions.mail.init_app(app)
 
     if app.config.get("SQLALCHEMY_DATABASE_URI"):
+        extensions.chanjo_report.init_app(app)
         LOG.info("Chanjo extension enabled")
-        configure_coverage(app)
 
     if app.config.get("LOQUSDB_SETTINGS"):
         LOG.info("LoqusDB enabled")
@@ -157,9 +146,9 @@ def configure_extensions(app):
         # setup connection to google oauth2
         configure_oauth_login(app)
 
-    if app.config.get("CLOUD_IGV_TRACKS"):
-        LOG.info("Collecting IGV tracks from cloud resources")
-        extensions.cloud_tracks.init_app(app)
+    if app.config.get("CUSTOM_IGV_TRACKS") or app.config.get("CLOUD_IGV_TRACKS"):
+        LOG.info("Collecting IGV tracks from cloud or local resources")
+        extensions.config_igv_tracks.init_app(app)
 
     if app.config.get("PHENOPACKET_API_URL"):
         LOG.info("Enable Phenopacket API")
@@ -319,38 +308,3 @@ def configure_email_logging(app):
         )
     )
     app.logger.addHandler(mail_handler)
-
-
-def configure_coverage(app):
-    """Setup coverage related extensions."""
-    # setup chanjo report
-    app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = True if app.debug else False
-    if chanjo_api:
-        chanjo_api.init_app(app)
-        configure_template_filters(app)
-        # register chanjo report blueprint
-        app.register_blueprint(report_bp, url_prefix="/reports")
-
-    babel = Babel()
-
-    def get_locale():
-        """Determine locale to use for translations."""
-        accept_languages = current_app.config.get("ACCEPT_LANGUAGES", ["en"])
-
-        # first check request args
-        session_language = Markup.escape(request.args.get("lang"))
-        if session_language in accept_languages:
-            current_app.logger.info("using session language: %s", session_language)
-            return session_language
-
-        # language can be forced in config
-        user_language = current_app.config.get("REPORT_LANGUAGE")
-        if user_language:
-            return user_language
-
-        # try to guess the language from the user accept header that
-        # the browser transmits.  We support de/fr/en in this example.
-        # The best match wins.
-        return request.accept_languages.best_match(accept_languages)
-
-    babel.init_app(app, locale_selector=get_locale)

scout/server/blueprints/alignviewers/controllers.py

@@ -7,7 +7,7 @@ from flask import flash, session
 from flask_login import current_user
 
 from scout.constants import CASE_SPECIFIC_TRACKS, HUMAN_REFERENCE, IGV_TRACKS
-from scout.server.extensions import cloud_tracks, store
+from scout.server.extensions import config_igv_tracks, store
 from scout.server.utils import case_append_alignments, find_index
 from scout.utils.ensembl_rest_clients import EnsemblRestApiClient
 
@@ -34,15 +34,16 @@ def check_session_tracks(resource):
     return True
 
 
-def set_session_tracks(display_obj):
+def set_session_tracks(display_obj: dict):
     """Save igv tracks as a session object. This way it's easy to verify that a user is requesting one of these files from remote_static view endpoint
 
     Args:
         display_obj(dict): A display object containing case name, list of genes, locus and tracks
     """
+
     session_tracks = list(display_obj.get("reference_track", {}).values())
     for key, track_items in display_obj.items():
-        if key not in ["tracks", "custom_tracks", "sample_tracks", "cloud_public_tracks"]:
+        if key not in ["tracks", "custom_tracks", "sample_tracks", "config_custom_tracks"]:
             continue
         for track_item in track_items:
             session_tracks += list(track_item.values())
@@ -107,7 +108,7 @@ def make_igv_tracks(case_obj, variant_id, chrom=None, start=None, stop=None):
         set_case_specific_tracks(display_obj, case_obj)
 
     # Set up custom cloud public tracks, if available
-    set_cloud_public_tracks(display_obj, build)
+    set_config_custom_tracks(display_obj, build)
 
     display_obj["display_center_guide"] = True
 
@@ -295,23 +296,20 @@ def set_case_specific_tracks(display_obj, case_obj):
         display_obj[track] = track_info
 
 
-def set_cloud_public_tracks(display_obj, build):
-    """Set up custom public tracks stored in a cloud bucket, according to the user preferences
-
-    Args:
-        display_obj(dict) dictionary containing all tracks info
-        build(string) "37" or "38"
-    """
+def set_config_custom_tracks(display_obj: dict, build: str):
+    """Set up custom public or private tracks stored in a cloud bucket or locally. These tracks were those specified in the Scout config file.
+    Respect user's preferences."""
     user_obj = store.user(email=current_user.email)
     custom_tracks_names = user_obj.get("igv_tracks")
 
-    cloud_public_tracks = []
-    if hasattr(cloud_tracks, "public_tracks"):
-        build_tracks = cloud_tracks.public_tracks.get(build, [])
+    config_custom_tracks = []
+
+    if hasattr(config_igv_tracks, "tracks"):
+        build_tracks = config_igv_tracks.tracks.get(build, [])
         for track in build_tracks:
             # Do not display track if user doesn't want to see it
             if custom_tracks_names and track["name"] not in custom_tracks_names:
                 continue
-            cloud_public_tracks.append(track)
-    if cloud_public_tracks:
-        display_obj["cloud_public_tracks"] = cloud_public_tracks
+            config_custom_tracks.append(track)
+    if config_custom_tracks:
+        display_obj["config_custom_tracks"] = config_custom_tracks

scout/server/blueprints/alignviewers/templates/alignviewers/igv_viewer.html

@@ -64,13 +64,23 @@
                             {% endif %}
                         },
                       {% endfor %}
-                      {% for custTrack in cloud_public_tracks %}
+                      {% for custTrack in config_custom_tracks %}
                         {
                           name: "{{ custTrack.name }}",
                           type: "{{ custTrack.type }}",
                           format: "{{ custTrack.format }}",
-                          url: "{{ url_for('alignviewers.remote_cors', remote_url=custTrack.url) }}",
-                          indexURL: "{{ url_for('alignviewers.remote_cors', remote_url=custTrack.indexURL) }}"
+                          height: 70,
+                          {% if "http" in custTrack.url %}
+                            url: "{{ url_for('alignviewers.remote_cors', remote_url=custTrack.url) }}",
+                            {% if custTrack.indexURL %}
+                              indexURL: "{{ url_for('alignviewers.remote_cors', remote_url=custTrack.indexURL) }}",
+                            {% endif %}
+                          {% else %}
+                             url: "{{ url_for('alignviewers.remote_static', file=custTrack.url) }}",
+                             {% if custTrack.indexURL %}
+                              indexURL: "{{ url_for('alignviewers.remote_static', file=custTrack.indexURL) }}",
+                             {% endif %}
+                          {% endif %}
                         },
                       {% endfor %}
                       {% for wtrack in rhocall_wig %}

scout/server/blueprints/alignviewers/views.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import logging
+from typing import Optional
 
 import requests
 from flask import (
@@ -11,7 +12,6 @@ from flask import (
     request,
     session,
 )
-from flask_login import current_user
 
 from scout.server.extensions import store
 from scout.server.utils import institute_and_case
@@ -119,20 +119,15 @@ def sashimi_igv(institute_id, case_name, variant_id=None):
 @alignviewers_bp.route(
     "/<institute_id>/<case_name>/<variant_id>/<chrom>/<start>/<stop>/igv", methods=["GET"]
 )  # from SV variant page, where you have to pass breakpoints coordinates
-def igv(institute_id, case_name, variant_id=None, chrom=None, start=None, stop=None):
-    """Visualize BAM alignments using igv.js (https://github.com/igvteam/igv.js)
-
-    Args:
-        institute_id(str): _id of an institute
-        case_name(str): dislay_name of a case
-        variant_id(str/None): variant _id or None
-        chrom(str/None): requested chromosome [1-22], X, Y, [M-MT]
-        start(int/None): start of the genomic interval to be displayed
-        stop(int/None): stop of the genomic interval to be displayed
-
-    Returns:
-        a string, corresponging to the HTML rendering of the IGV alignments page
-    """
+def igv(
+    institute_id: str,
+    case_name: str,
+    variant_id: Optional[str] = None,
+    chrom: Optional[str] = None,
+    start: Optional[int] = None,
+    stop: Optional[int] = None,
+) -> Response:
+    """Visualize BAM alignments using igv.js (https://github.com/igvteam/igv.js)."""
     _, case_obj = institute_and_case(
         store, institute_id, case_name
     )  # This function takes care of checking if user is authorized to see resource