2.3.Integrative Transcriptome Viewer

This is an interactive notebook with code-along enabled using the below options:

• Binder (https://mybinder.org/) - Opens the notebooks in an executable environment on a virtual machine using JupyterLab interface
  

• Colab (https://colab.research.google.com/) - Google Colab Notebook (requires additional config to set-up env)

• Deepnote (https://deepnote.com/) - Additional feautures built on top of Jupyter notebook

• Live code (https://thebe.readthedocs.io/en/stable/) - Converts the static cells below to interactive execulatble cells to run the notebook inplace.

Install notes

#!git clone https://github.com/MethodsDev/ITV.git && cd ITV
#!make install
#!mamba activate itv-1.1.2

First we import the primary class Configuration that we will interact with that contains a range of methods to plot views easily while offering a lot of customization options. We also import the save method for export. Interval is imported as the underlying structure for defining regions if not using a GTF annotation input or specific gene/transcript names/IDs. The IPython.display imports will be used to display some of the HTML formatted results inside the Jupyter notebook directly by telling it what to do with the data.

import integrative_transcriptomics_viewer as itv
from integrative_transcriptomics_viewer.convenience import Configuration
from integrative_transcriptomics_viewer.export import save
from integrative_transcriptomics_viewer.classification import BAMtagClassification
from integrative_transcriptomics_viewer.annotation_matching import TaggedBAMAnnotationMatching

from intervaltree import Interval
from IPython.display import display, HTML 

itv.__version__

'1.1.2'

We then declare the files for our reference of choice, in this instance GRCh38.v39, which we will shorten to human. We provide the Configuration class with the following files:

• the fasta sequence file to be able to highlight SNPs

• an annotation GTF that will be indexed to allow easily plotting specific genes or transcripts by ID or name ; features from the GTF will only be used to define what regions to show, not be directly shown in the visualization

• a set of BED files to display features of interest, in this instance, one file contains the knows transcripts and the other the PFAM domains predicted by pfam_scan.pl

Getting test data for ITV

!which gsutil 
!gsutil -q -m cp gs://mdl-preprocess-refs/ITV_refs/ITV-demo-data.zip .
!gsutil -q -m cp gs://mdl-preprocess-refs/ITV_refs/PBMC_BioIVT_10x3p.aligned.tagged.sorted.bam .
!ls
!unzip ITV-demo-data.zip

/home/docs/checkouts/readthedocs.org/user_builds/kinnex-documentation-external/envs/latest/bin/gsutil

^C
Traceback (most recent call last):
  File "/home/docs/checkouts/readthedocs.org/user_builds/kinnex-documentation-external/envs/latest/bin/gsutil", line 3, in <module>
    from gslib.__main__ import main
  File "/home/docs/checkouts/readthedocs.org/user_builds/kinnex-documentation-external/envs/latest/lib/python3.12/site-packages/gslib/__main__.py", line 89, in <module>
    from gslib import wildcard_iterator
  File "/home/docs/checkouts/readthedocs.org/user_builds/kinnex-documentation-external/envs/latest/lib/python3.12/site-packages/gslib/wildcard_iterator.py", line 43, in <module>
    from gslib.third_party.storage_apitools import storage_v1_messages as apitools_messages
  File "/home/docs/checkouts/readthedocs.org/user_builds/kinnex-documentation-external/envs/latest/lib/python3.12/site-packages/gslib/third_party/storage_apitools/storage_v1_messages.py", line 22, in <module>
    from apitools.base.py import encoding
  File "/home/docs/checkouts/readthedocs.org/user_builds/kinnex-documentation-external/envs/latest/lib/python3.12/site-packages/apitools/base/py/__init__.py", line 23, in <module>
    from apitools.base.py.credentials_lib import *
  File "/home/docs/checkouts/readthedocs.org/user_builds/kinnex-documentation-external/envs/latest/lib/python3.12/site-packages/apitools/base/py/credentials_lib.py", line 32, in <module>
    from oauth2client import tools  # for gflags declarations
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/docs/checkouts/readthedocs.org/user_builds/kinnex-documentation-external/envs/latest/lib/python3.12/site-packages/gslib/vendored/oauth2client/oauth2client/tools.py", line 28, in <module>
    from six.moves import BaseHTTPServer
  File "<frozen importlib._bootstrap>", line 1412, in _handle_fromlist
  File "/home/docs/checkouts/readthedocs.org/user_builds/kinnex-documentation-external/envs/latest/lib/python3.12/site-packages/six.py", line 97, in __get__
    result = self._resolve()
             ^^^^^^^^^^^^^^^
  File "/home/docs/checkouts/readthedocs.org/user_builds/kinnex-documentation-external/envs/latest/lib/python3.12/site-packages/six.py", line 120, in _resolve
    return _import_module(self.mod)
           ^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/docs/checkouts/readthedocs.org/user_builds/kinnex-documentation-external/envs/latest/lib/python3.12/site-packages/six.py", line 87, in _import_module
    __import__(name)
  File "<frozen importlib._bootstrap>", line 1360, in _find_and_load
  File "<frozen importlib._bootstrap>", line 1331, in _find_and_load_unlocked
  File "<frozen importlib._bootstrap>", line 935, in _load_unlocked
  File "<frozen importlib._bootstrap_external>", line 995, in exec_module
  File "<frozen importlib._bootstrap_external>", line 1091, in get_code
  File "<frozen importlib._bootstrap_external>", line 1191, in get_data
KeyboardInterrupt

ITV-demo-data.zip
demo-ITV.ipynb
id_mapping_from_gffcompare.ipynb
isoformSwitchAnalysisR_kinnex_bulk.Rmd
isoformSwitchAnalysisR_kinnex_bulk.nb.html
scKinnex-vignette.Rmd
scKinnex-vignette.html
subsampling.nb.html

Archive:  ITV-demo-data.zip
   creating: data/
  inflating: data/data_files_needed.txt  
   creating: data/refs/
   creating: data/bams/
   creating: data/beds/
  inflating: data/refs/GRCh38_no_alt.fa  

Setting up config object - Demo start checkpoint

human_genome_path = "data/refs/GRCh38_no_alt.fa"
human_gtf_path = "data/refs/GRCh38.gencode.v39.annotation.gtf"
human_bed_gencode = ["data/refs/GRCh38.gencode.v39.annotation.sorted.bed.gz", "data/beds/gencode.v39.pfam_predictions.in_transcript.sorted.bed.gz"]

human = Configuration(genome_fasta = human_genome_path, 
                      gtf_annotation = human_gtf_path, 
                      bed_annotation = human_bed_gencode)

Now we should declare the paths to the BAM files we wish to visualize. For this example we have 6 files, 3 replicates of HG002, and 3 replicates of K562. We are organizing the paths in a few different dict objects so that we can easily switch between visualizing all the BAMs, just one set of replicates, or one replicate of each depending on what we care about.

all_bams_dict = {
    "HG002_E0": "data/bams/HG002_E0_sorted.subsampled.bam",
    "HG002_E1": "data/bams/HG002_E1_sorted.subsampled.bam",
    "HG002_E2": "data/bams/HG002_E2_sorted.subsampled.bam",
    "K562_E0":  "data/bams/K562_E0_sorted.subsampled.bam",
    "K562_E1":  "data/bams/K562_E1_sorted.subsampled.bam",
    "K562_E2":  "data/bams/K562_E2_sorted.subsampled.bam",
}

HG002_dict = {
    "HG002_E0": "data/bams/HG002_E0_sorted.subsampled.bam",
    "HG002_E1": "data/bams/HG002_E1_sorted.subsampled.bam",
    "HG002_E2": "data/bams/HG002_E2_sorted.subsampled.bam",
}

K562_dict = {
    "K562_E0":  "data/bams/K562_E0_sorted.subsampled.bam",
    "K562_E1":  "data/bams/K562_E1_sorted.subsampled.bam",
    "K562_E2":  "data/bams/K562_E2_sorted.subsampled.bam",
}

vs_dict = {
    "HG002_E0": "data/bams/HG002_E0_sorted.subsampled.bam",
    "K562_E0":  "data/bams/K562_E0_sorted.subsampled.bam",
}

Here is a list of the basic methods we can use for plotting:

• plot_interval: provided a contig, start and end position, or an intervaltree.Interval object where the data field is contig + strand, for example Interval(42, 1000, "chr2-").

• plot_intervals: bulk version of plot_interval that accepts a list of intervaltree.Interval objects for successive plots.

• plot_feature: the most generic method, using the index built from the GTF file provided, accepts a gene name, gene ID, transcript ID or exon ID to plot.

• plot_features: bulk version of plot_feature that accepts a list of features for successive plots.

• plot_exons: accepts the same type of input as plot_feature, but will only plot the exons of the feature, cutting out the introns to reclaim vertical space since most intronic regions will be empty in mature mRNA.

• plot_splice_junctions: accepts the same type of input as plot_feature, but will plot each pair of annotated splice junction based on the input GTF in a separate view.

• plot_read: searches the BAM(s) for the given read ID to plot that read. Can be quite slow with large BAMs as no position information is provided and so the whole file needs to be scanned.

• plot_reads: bulk version of plot_read that accepts a list of read IDs for successive plots.

Now let’s start by looking at one of the classic housekeeping genes, ACTB. The general method to look at a gene, transcript or exon by name or ID is plot_feature.
Given that it is usually highly expressed, we will only look at the coverage track for now, meaning we should disable plotting of the actual reads using with_reads=False.

human.plot_feature("ACTB", bams_dict=vs_dict, with_reads=False)

As you can see, a very large portion of the view is wasted because there are some very large introns that reduce the proportion of space used to display the exons, where basically all the coverage is. This is a good example of where we can use plot_exons instead to only visualize exons (with a little bit of padding around for context):

human.plot_exons("ACTB", bams_dict=vs_dict, with_reads=False)

We can also look at individual splice junctions with plot_splice_junctions, although it can get a bit messy quickly given the number of distinct junctions that exist due to all the different isoforms with splitly different exon boundaries. To avoid that, we will run it with the option as_widget=True which will make dropdown menu of all the views and only show one at once.

human.plot_splice_junctions("ACTB", bams_dict=vs_dict, with_reads=False, as_widget=True)

Now let’s look at a different example with lower coverage so we can also inspect the reads.

human.plot_exons("CAT", bams_dict=vs_dict)

To make the view a bit more compact we can set tighter_track=True to reduce the vertical size of reads.

human.plot_exons("CAT", bams_dict=vs_dict, tighter_track=True)

We can notice some “cliffs” on the 3” side of the reads, but given that reads are sorted by starting position, it is not always very clear if they have some particularity. To look at that, we can use the coverage_bin_size option to separate the coverage in multiple layers based on bins of a given size for where the reads primed (by default on the 3” side for polyA capture, relative to the strand on which the gene is).

human.plot_exons("CAT", bams_dict=vs_dict, tighter_track=True, coverage_bin_size=100)

In this case there does not seem to be any relation to the splicing or 5” start of the transcript. The different 3” end positions might be real differences in transcript, or they could be due to internal priming to a stretch of As, which could be verified by looking at the reference sequence. [to be added]

Now we can look at another example. Because some of the terminal exons are very large, we also increase the width of the visualization with the view_width option, and increase the height of the coverage track with coverage_height to see more details.

human.plot_exons("LEPR", bams_dict=K562_dict, with_reads=False, coverage_bin_size=100, coverage_height=200, view_width=3200)

This time there is clearly something going on. The third exon from the left is a clean start for some of the transcripts, with no reads that primed further downstream using it. Upstream we also see the first two exons have almost exclusively reads that started more upstream than the reads up to the third exon, but we see multiple color bins even though they all seem to start at the same location. If we “dezoom” and look back at the full region, we can see that this is actually because there are two distinct genes that overlap both in region but also in actual exons, LEPR and LEPROT. Most of the reads covering the two left most exons of LEPR are actually aligning to LEPROT, but a few reads do align to LEPR (can be verified by re-enabling the plotting of reads). One way to fix the issue we see in this instance of plot_exons with some exons not being shown because they are exclusive to the overlapping gene would be to create an entry in the annotation gtf that contains all the exons of both gene.

human.plot_feature("LEPR", bams_dict=K562_dict, with_reads=False, coverage_bin_size=100, coverage_height=200, view_width=3200)

Another example we can look at is the one below:

human.plot_exons("PCMT1", bams_dict=vs_dict, with_reads=False, coverage_bin_size=100)

In this case, we can clearly see patterns of splicing, but it seems like the bin size may not be ideal as there are 2 bins for multiple reads starting generally on the same spliced version of an exon. To try to automatically fix this, we can use the coverage_peak_min_distance option instead of coverage_bin_size. This will find the positions with the most reads priming and make a bin of that distance around it.

human.plot_exons("PCMT1", bams_dict=vs_dict, with_reads=False, coverage_peak_min_distance=20)

Below are some other examples you can look at to test things.

with open("test_coverage.svg", "w") as f:
    f.write(human.plot_exons("JUN", bams_dict=vs_dict, with_reads=True, coverage_bin_size=100)._repr_svg__())

human.plot_exons("JUN", bams_dict=vs_dict, with_reads=True, coverage_bin_size=100)

human.plot_exons("LMNA", bams_dict=vs_dict, with_reads=False, coverage_bin_size=100)

human.plot_exons("MAPK8", bams_dict=all_bams_dict, with_reads=False, coverage_bin_size=100)

human.plot_exons("PARPBP", bams_dict=vs_dict, with_reads=False, coverage_bin_size=100)

Another feature of the coverage track binning is that it will automatically add to a separate bin colored in black at the top all reads that primed out of the region being displayed. In the example below a gene overlaps the gene or interest but it is easy to ignore its contribution to the coverage. In this mode, reads that don’t fall within any of the peak bins (10 at most by default) will be added to a separate bin colored in black.

human.plot_exons("STUB1", bams_dict=vs_dict, with_reads=False, coverage_bin_size=50, priming_orientation="3p")

Now let’s go back to the first example of ACTB and try to export it to a self-contained file. We will generate an HTML file that can be open in any modern browser. There are other formats available (SVG and PNG) but the next methods we will look at take advantage of JavaScript so will be limited to HTML.

view = human.plot_exons("ACTB", bams_dict=vs_dict, tighter_track=True, with_reads=True)
save(view, "ACTB_exons_plot.html")

save(view, "ACTB_exons_plot.svg")

save(view, "ACTB_exons_plot.png", requested_converter="cairosvg")

You can now open the html filed generated and look at the data independently of your Python setup, making it easy to share. When opening it in a browser rather than inside a Jupyter notebook if you were to directly display the output, you can also hover over certain elements of the view to have additional information shown such as the type of point mutations, read IDs, and cigar strings.

Given that in many cases we will be interested in visualizing reads annotated with other characteristics such as isoform they are classified as, structural category (ex: proper read, internally primed, artifact, etc.), cell type for single cell, or even filter only to a whitelist of cell barcodes, we provide a couple of modular methods to split or filter alignments in memory without having to manually split and index BAM files first. This also allows to integrate with results generated directly through the Python instance currently running by defining a class inheriting from the prototypes included. We will look at the following methods:

• plot_feature with the coverage_tag option

• plot_by_features_as_tab

• plot_by_classification_over_features

• plot_by_classification_as_tabs

We declare a new dict with the example data used for this part. The data is single-cell sequencing of PBMCs, and the BAM has been annotated with gene and isoform classification results from IsoQuant in repectively the tags XG and XI.

sc_dict = {
    "PBMC": "./data/bams/PBMC_BioIVT_10x3p.aligned.tagged.sorted.bam",
}

Let’s first plot the exons of a gene like we did earlier.

human.plot_exons("AIF1", bams_dict=sc_dict, with_reads=False, coverage_bin_size=100, coverage_height=200)

The first and third exon windows shows some alternative splicing so let’s visualize split the coverage by the isoform classification we have in the tag XI.

human.plot_exons("AIF1", bams_dict=sc_dict, with_reads=False, coverage_tag="XI", coverage_height=200)

human.plot_feature("AIF1", bams_dict=sc_dict, with_reads=False, coverage_tag="XI", coverage_height=200)

Next we will plot the two genes at once with all reads shown. To make things easier to interact with, each gene will be a section whose visibility can be toggled with a button at the top of the view. Within each gene view, we then have another clickable button to toggle the visibility of each BAM we wanted to display. Since this is an HTML based view, when displaying reads from a BAM, we can have a resizeable box to control how tall that view is to more easily compare potentially large numbers of reads.

HTML(human.plot_by_features_as_tab(features_list=["AIF1", "APP"], bams_dict=sc_dict, tighter_track=True, coverage_tag="XI"))

AIF1 APP

AIF1_PBMC

APP_PBMC

To construct a similar style of view, but where tabs are instead the different classifications found in the XI tag and split according to that, we can do the following.

HTML(human.plot_by_classification_over_features(features_list=["AIF1", "APP"], 
                                                bams_dict=sc_dict, 
                                                tighter_track=True,
                                                classification_from=BAMtagClassification("XI"), 
                                                annotation_matching=TaggedBAMAnnotationMatching(),
                                                coverage_tag="XI",
                                               )
    )

AIF1 APP

AIF1_PBMC_unclassified AIF1_PBMC_ENST00000375880.6 AIF1_PBMC_ENST00000350274.9 AIF1_PBMC_ENST00000600239.5;ENST00000452918.7;ENST00000601879.5 AIF1_PBMC_ENST00000674069.1;ENST00000616296.4 AIF1_PBMC_ENST00000465703.5 AIF1_PBMC_ENST00000414046.3 AIF1_PBMC_ENST00000376059.8;ENST00000337917.11 AIF1_PBMC_ENST00000337917.11 AIF1_PBMC_ENST00000376059.8 AIF1_PBMC_ENST00000497362.5 AIF1_PBMC_ENST00000466820.1 AIF1_PBMC_ENST00000376049.4;ENST00000376059.8;ENST00000337917.11 AIF1_PBMC_ENST00000376049.4 AIF1_PBMC_ENST00000376049.4;ENST00000466820.1;ENST00000376059.8;ENST00000337917.11 AIF1_PBMC_ENST00000643519.1;ENST00000263368.9;ENST00000595483.5;ENST00000643596.1;ENST00000601346.5 AIF1_PBMC_ENST00000376049.4;ENST00000337917.11

APP_PBMC_ENST00000346798.8;ENST00000357903.7;ENST00000359726.7;ENST00000348990.9;ENST00000354192.7 APP_PBMC_ENST00000358918.7 APP_PBMC_ENST00000346798.8;ENST00000464867.1;ENST00000357903.7;ENST00000359726.7;ENST00000439274.6;ENST00000348990.9;ENST00000440126.7;ENST00000354192.7 APP_PBMC_unclassified APP_PBMC_ENST00000440126.7;ENST00000357903.7 APP_PBMC_ENST00000636732.2 APP_PBMC_ENST00000346798.8;ENST00000357903.7;ENST00000359726.7;ENST00000439274.6;ENST00000348990.9;ENST00000440126.7;ENST00000354192.7 APP_PBMC_ENST00000617755.1 APP_PBMC_ENST00000456904.3 APP_PBMC_ENST00000596669.1 APP_PBMC_ENST00000596385.5 APP_PBMC_ENST00000600590.1;ENST00000597894.1;ENST00000596385.5 APP_PBMC_ENST00000448850.5 APP_PBMC_ENST00000667606.1 APP_PBMC_ENST00000690116.1;ENST00000689729.1;ENST00000692086.1;ENST00000688218.1;ENST00000685846.1;ENST00000693503.1 APP_PBMC_ENST00000440126.7;ENST00000448850.5;ENST00000357903.7 APP_PBMC_ENST00000415997.1;ENST00000346798.8;ENST00000357903.7;ENST00000359726.7;ENST00000358918.7;ENST00000439274.6;ENST00000348990.9;ENST00000440126.7;ENST00000448850.5;ENST00000354192.7 APP_PBMC_ENST00000357903.7 APP_PBMC_ENST00000346798.8;ENST00000357903.7;ENST00000358918.7;ENST00000439274.6;ENST00000440126.7;ENST00000448850.5 APP_PBMC_ENST00000474136.5 APP_PBMC_ENST00000346798.8;ENST00000357903.7;ENST00000348990.9 APP_PBMC_ENST00000346798.8;ENST00000357903.7;ENST00000359726.7;ENST00000358918.7;ENST00000348990.9;ENST00000474136.5;ENST00000440126.7 APP_PBMC_ENST00000346798.8;ENST00000357903.7 APP_PBMC_ENST00000346798.8;ENST00000357903.7;ENST00000359726.7;ENST00000358918.7;ENST00000439274.6;ENST00000348990.9;ENST00000474136.5;ENST00000440126.7;ENST00000448850.5;ENST00000354192.7 APP_PBMC_ENST00000548570.1 APP_PBMC_ENST00000410396.1

In these 2 genes’ case, the subtabs can become a bit confusing because there are reads which can not confidently be classified as a specific transcript and that lead to having a lot of subtabs with all the different combinations of transcripts found. To solve this we can make our own implementation of Classification that will merge in an ambiguous category all such reads. To do that we make class that extends from genomeview.classification.Classification and define its get_classification(self, read, gene_id) method, as well as __init__ to store what tag we’re using. Since ambiguous classifications will have a ; between each possible transcript, we can just look for that in the tag. The expected return format is a list so that’s what we return.

class custom_BAMtagClassification(itv.classification.Classification):
    """
    Implementation of Classification class to use the information stored in a given BAM tag.
    """

    def __init__(self, tag):
        self.tag = tag

    def get_classification(self, read, gene_id):
        if not read.has_tag(self.tag):
            return None
        tag_content = read.get_tag(self.tag)
        if ";" in tag_content:
            return ["ambiguous"]
        else:
            return [tag_content]

Then we can just run the previous plotting function, swapping the classification_from argument to use our new class.

HTML(human.plot_by_classification_over_features(features_list=["AIF1", "APP"], 
                                                bams_dict=sc_dict, 
                                                tighter_track=True,
                                                classification_from=custom_BAMtagClassification("XI"), 
                                                annotation_matching=TaggedBAMAnnotationMatching(),
                                                coverage_tag="XI",
                                               )
    )

AIF1 APP

AIF1_PBMC_unclassified AIF1_PBMC_ENST00000375880.6 AIF1_PBMC_ENST00000350274.9 AIF1_PBMC_ambiguous AIF1_PBMC_ENST00000465703.5 AIF1_PBMC_ENST00000414046.3 AIF1_PBMC_ENST00000337917.11 AIF1_PBMC_ENST00000376059.8 AIF1_PBMC_ENST00000497362.5 AIF1_PBMC_ENST00000466820.1 AIF1_PBMC_ENST00000376049.4

APP_PBMC_ambiguous APP_PBMC_ENST00000358918.7 APP_PBMC_unclassified APP_PBMC_ENST00000636732.2 APP_PBMC_ENST00000617755.1 APP_PBMC_ENST00000456904.3 APP_PBMC_ENST00000596669.1 APP_PBMC_ENST00000596385.5 APP_PBMC_ENST00000448850.5 APP_PBMC_ENST00000667606.1 APP_PBMC_ENST00000357903.7 APP_PBMC_ENST00000474136.5 APP_PBMC_ENST00000548570.1 APP_PBMC_ENST00000410396.1

If we only care about one gene, we can make a plot where the tabs are directly the classifications, and the subtabs are the different BAM files provided.

HTML(human.plot_by_classification_as_tabs(feature="AIF1", 
                                          bams_dict=sc_dict, 
                                          tighter_track=True,
                                          classification_from=custom_BAMtagClassification("XI"), 
                                          annotation_matching=TaggedBAMAnnotationMatching(),
                                          coverage_tag="XI")
    )

all unclassified ENST00000375880.6 ENST00000350274.9 ambiguous ENST00000465703.5 ENST00000414046.3 ENST00000337917.11 ENST00000376059.8 ENST00000497362.5 ENST00000466820.1 ENST00000376049.4

all_PBMC

unclassified_PBMC

ENST00000375880.6_PBMC

ENST00000350274.9_PBMC

ambiguous_PBMC

ENST00000465703.5_PBMC

ENST00000414046.3_PBMC

ENST00000337917.11_PBMC

ENST00000376059.8_PBMC

ENST00000497362.5_PBMC

ENST00000466820.1_PBMC

ENST00000376049.4_PBMC

Because these type of views return directly an the HTML to display rather than the object containing the information to build it, saving them works slightly differently. However we just need to save the contents to a file, nothing more.

with open("AIF1_classification_as_tabs.html", "w") as f:
    f.write(human.plot_by_classification_as_tabs(feature="AIF1", 
                                                 bams_dict=sc_dict, 
                                                 tighter_track=True,
                                                 classification_from=custom_BAMtagClassification("XI"), 
                                                 annotation_matching=TaggedBAMAnnotationMatching(),
                                                 coverage_tag="XI"))