Repository: monarch-initiative/gpsea (language: python)

Issue:
Add visualization prose
@frehburg I am adding some prose for drawing variants, transcript, and protein. The text includes background and code examples. I think your plotting code is great and the main thing to do now is to connect it to our framework.

The [Visualizers](https://github.com/monarch-initiative/genophenocorr/blob/visualization-prose/dev/Visualizers.ipynb) notebook includes the text with some details. 

Please start reading with *Variant transcript protein figure* section.


Discussion / hints:

Fix patch:
diff --git a/dev/Visualizers.ipynb b/dev/Visualizers.ipynb
index 7d5e9426..508630fe 100644
--- a/dev/Visualizers.ipynb
+++ b/dev/Visualizers.ipynb
@@ -142,7 +142,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Patients Created: 100%|██████████| 35/35 [00:00<00:00, 511.48it/s]\n"
+      "Patients Created: 100%|██████████| 35/35 [00:00<00:00, 340.95it/s]\n"
      ]
     },
     {
@@ -244,7 +244,7 @@
     {
      "data": {
       "text/plain": [
-       "Variant(variant_coordinates:VariantCoordinates(region=GenomicRegion(contig=12, start=56003672, end=56003673, strand=+), ref=G, alt=GC, change_length=1), tx_annotations:(TranscriptAnnotation(gene_id:SUOX,transcript_id:NM_000456.3,hgvsc_id:NM_000456.3:c.287dup,is_preferred:False,variant_effects:(<VariantEffect.FRAMESHIFT_VARIANT: 'SO:0001589'>,),overlapping_exons:(6,),protein_affected:(ProteinMetadata(id=NP_000447.2, label=Sulfite oxidase, mitochondrial, features=(SimpleProteinFeature(type=FeatureType.DOMAIN, info=FeatureInfo(name=Cytochrome b5 heme-binding, start=82, end=161)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Hinge, start=165, end=174)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Moco domain, start=175, end=401)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Homodimerization, start=402, end=538)))),),protein_effect_location:Region(start=94, end=95)), TranscriptAnnotation(gene_id:SUOX,transcript_id:NM_001032386.2,hgvsc_id:NM_001032386.2:c.287dup,is_preferred:True,variant_effects:(<VariantEffect.FRAMESHIFT_VARIANT: 'SO:0001589'>,),overlapping_exons:(5,),protein_affected:(ProteinMetadata(id=NP_001027558.1, label=Sulfite oxidase, mitochondrial, features=(SimpleProteinFeature(type=FeatureType.DOMAIN, info=FeatureInfo(name=Cytochrome b5 heme-binding, start=82, end=161)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Hinge, start=165, end=174)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Moco domain, start=175, end=401)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Homodimerization, start=402, end=538)))),),protein_effect_location:Region(start=94, end=95)), TranscriptAnnotation(gene_id:SUOX,transcript_id:NM_001032387.2,hgvsc_id:NM_001032387.2:c.287dup,is_preferred:False,variant_effects:(<VariantEffect.FRAMESHIFT_VARIANT: 'SO:0001589'>,),overlapping_exons:(4,),protein_affected:(ProteinMetadata(id=NP_001027559.1, label=Sulfite oxidase, mitochondrial, features=(SimpleProteinFeature(type=FeatureType.DOMAIN, info=FeatureInfo(name=Cytochrome b5 heme-binding, start=82, end=161)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Hinge, start=165, end=174)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Moco domain, start=175, end=401)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Homodimerization, start=402, end=538)))),),protein_effect_location:Region(start=94, end=95)), TranscriptAnnotation(gene_id:IKZF4,transcript_id:NM_001351089.2,hgvsc_id:None,is_preferred:False,variant_effects:(<VariantEffect.UPSTREAM_GENE_VARIANT: 'SO:0001631'>,),overlapping_exons:None,protein_affected:(),protein_effect_location:None), TranscriptAnnotation(gene_id:IKZF4,transcript_id:NM_001351091.2,hgvsc_id:None,is_preferred:False,variant_effects:(<VariantEffect.UPSTREAM_GENE_VARIANT: 'SO:0001631'>,),overlapping_exons:None,protein_affected:(),protein_effect_location:None)), genotypes:Genotypes(['5=0/1']))"
+       "Variant(variant_coordinates:VariantCoordinates(region=GenomicRegion(contig=12, start=56004514, end=56004515, strand=+), ref=C, alt=T, change_length=1), tx_annotations:(TranscriptAnnotation(gene_id:SUOX,transcript_id:NM_000456.3,hgvsc_id:NM_000456.3:c.1126C>T,is_preferred:False,variant_effects:(<VariantEffect.MISSENSE_VARIANT: 'SO:0001583'>,),overlapping_exons:(6,),protein_affected:(ProteinMetadata(id=NP_000447.2, label=Sulfite oxidase, mitochondrial, features=(SimpleProteinFeature(type=FeatureType.DOMAIN, info=FeatureInfo(name=Cytochrome b5 heme-binding, start=82, end=161)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Hinge, start=165, end=174)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Moco domain, start=175, end=401)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Homodimerization, start=402, end=538)))),),protein_effect_location:Region(start=375, end=376)), TranscriptAnnotation(gene_id:SUOX,transcript_id:NM_001032386.2,hgvsc_id:NM_001032386.2:c.1126C>T,is_preferred:True,variant_effects:(<VariantEffect.MISSENSE_VARIANT: 'SO:0001583'>,),overlapping_exons:(5,),protein_affected:(ProteinMetadata(id=NP_001027558.1, label=Sulfite oxidase, mitochondrial, features=(SimpleProteinFeature(type=FeatureType.DOMAIN, info=FeatureInfo(name=Cytochrome b5 heme-binding, start=82, end=161)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Hinge, start=165, end=174)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Moco domain, start=175, end=401)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Homodimerization, start=402, end=538)))),),protein_effect_location:Region(start=375, end=376)), TranscriptAnnotation(gene_id:SUOX,transcript_id:NM_001032387.2,hgvsc_id:NM_001032387.2:c.1126C>T,is_preferred:False,variant_effects:(<VariantEffect.MISSENSE_VARIANT: 'SO:0001583'>,),overlapping_exons:(4,),protein_affected:(ProteinMetadata(id=NP_001027559.1, label=Sulfite oxidase, mitochondrial, features=(SimpleProteinFeature(type=FeatureType.DOMAIN, info=FeatureInfo(name=Cytochrome b5 heme-binding, start=82, end=161)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Hinge, start=165, end=174)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Moco domain, start=175, end=401)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Homodimerization, start=402, end=538)))),),protein_effect_location:Region(start=375, end=376)), TranscriptAnnotation(gene_id:IKZF4,transcript_id:NM_001351089.2,hgvsc_id:None,is_preferred:False,variant_effects:(<VariantEffect.UPSTREAM_GENE_VARIANT: 'SO:0001631'>,),overlapping_exons:None,protein_affected:(),protein_effect_location:None), TranscriptAnnotation(gene_id:IKZF4,transcript_id:NM_001351091.2,hgvsc_id:None,is_preferred:False,variant_effects:(<VariantEffect.UPSTREAM_GENE_VARIANT: 'SO:0001631'>,),overlapping_exons:None,protein_affected:(),protein_effect_location:None)), genotypes:Genotypes(['individual_5_PMID_12112661=0/1']))"
       ]
      },
      "execution_count": 8,
@@ -472,59 +472,695 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Visualize the data"
+    "# Variant transcript protein figure\n",
+    "\n",
+    "## Background\n",
+    "\n",
+    "*Gene* is a genomic region that has some functional relevance. Usually, this is because the region includes DNA sequence that encodes a protein product. The information for protein synthesis is encoded in the sequence of DNA nucleotides, one of four letters of the DNA alphabet: `A`, `C`, `G`, `T`. Per [central dogma of molecular biology](https://en.wikipedia.org/wiki/Central_dogma_of_molecular_biology), the information flows from gene to protein. Gene is first transcribed into precursor messenger RNA (pre-mRNA), pre-mRNA undergoes splicing to remove non-coding regions *introns*, resulting in mature messenger RNA (mRNA) that (mostly) consists of coding *exons*. \n",
+    "\n",
+    "However, splicing is not deterministic, and due to several reasons, it can produce several versions of mRNA from one pre-mRNA sequence that encode different protein isoforms. We denote the alternate mRNA versions as *transcripts*, and, depending on splicing, one gene can produce `1..m` transcripts.\n",
+    "\n",
+    "After splicing, the sequence of the mature mRNA is translated into a protein sequence. The protein alphabet includes 21 letters - aminoacids the maping between DNA and protein alphabets is dictated by the [codon table](https://en.wikipedia.org/wiki/DNA_and_RNA_codon_tables) (just for reference, no need to study deeper) where *codon* is a triplet of DNA letters that correspond to one protein letter.\n",
+    "\n",
+    "There is one more detail left to discuss. The mRNA includes two *untranslated regions* (UTRs), one UTR on each end of mRNA molecule. The UTR at the start is denoted as 5' (read five prime) and the UTR at the end is called 3' (three prime). The UTRs do not encode protein sequence, so, we do not want to plot them.\n",
+    "\n",
+    "So, that's about it for background. Now, let me show how to get the information from our domain model."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Draw the figures"
+    "## Transcript\n",
+    "\n",
+    "In our domain model, we ask the user to choose the desired transcript by providing transcript ID:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'NM_001032386.2'"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tx_id"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now, let's draw the plots:"
+    "Thanks to the ID, our app can fetch the \"anatomy\" of the transcript - the coordinates of exon regions. The coordinates were fetched above so I'll only reuse `tx_coordinates` here:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Start\tEnd\tLength\n",
+      "55,997,275\t55,997,339\t64\n",
+      "55,997,614\t55,997,723\t109\n",
+      "56,002,211\t56,002,271\t60\n",
+      "56,002,542\t56,002,720\t178\n",
+      "56,003,617\t56,005,525\t1908\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Start\\tEnd\\tLength')\n",
+    "for exon in tx_coordinates.exons:\n",
+    "    print(f'{exon.start:,}\\t{exon.end:,}\\t{len(exon)}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We get an instance of `TranscriptCoordinates` that has `exons` property. The property provides a sequence of `genophenocorr.model.genome.GenomicRegion`s that correspond to exon regions.\n",
+    "\n",
+    "This transcript has 5 exons. Note that the exons are *not* consecutive - they are separated by introns (not in the model). The exons consist of the coding sequence regions (CDS) and UTRs.\n",
+    "\n",
+    "We can get the CDS regions by calling `get_cds_regions()`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Start\tEnd\tLength\n",
+      "56,002,221\t56,002,271\t50\n",
+      "56,002,542\t56,002,720\t178\n",
+      "56,003,617\t56,005,027\t1410\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Start\\tEnd\\tLength')\n",
+    "for cds in tx_coordinates.get_cds_regions():\n",
+    "    print(f'{cds.start:,}\\t{cds.end:,}\\t{len(cds)}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Same as above, we iterate through `GenomicRegion`s, but they correspond to CDS this time. Note that only 3 exons of this transcript include coding sequence. The entire first 2 exons plus the first 10 bases of the 3rd exon represent the 5'UTR. The 3'UTR spans the last 498 bases (`56,005,525 - 56,005,027 = 498`).\n",
+    "\n",
+    "Note that the sum of CDS lengths is always be divisible by 3:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from genophenocorr.view import VariantTranscriptVisualizer\n",
+    "assert sum(len(cds) for cds in tx_coordinates.get_cds_regions()) % 3 == 0, \"CDS must be divisible by 3!\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The sum divided by 3 corresponds to the codon count. The last codon ([stop codon](https://en.wikipedia.org/wiki/Stop_codon)) does not encode an aminoacid. Therefore, we can calculate the number of codons that encode the protein aminoacids `aa_count` as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "545.0"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "codon_count = sum(len(cds) for cds in tx_coordinates.get_cds_regions()) / 3\n",
+    "aa_count = codon_count - 1\n",
+    "aa_count"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The transcript encodes a protein that consists of 545 aminoacids.\n",
     "\n",
-    "viz = VariantTranscriptVisualizer()"
+    "You don't have to compute these by hand, `TxCoordinates` provides some convenience here:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "N coding bases: 1635\n",
+      "N coding codons (aminoacids): 545\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('N coding bases:', tx_coordinates.get_coding_base_count())\n",
+    "print('N coding codons (aminoacids):', tx_coordinates.get_codon_count())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Protein\n",
+    "\n",
+    "Let's discuss the protein features.\n",
+    "\n",
+    "Genophenocorr knows that `NM_001032386.2` transcript corresponds to `NP_001027558.1` protein and it can fetch the corresponding metadata:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Protein ID: NP_001027558.1\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "ProteinMetadata(id=NP_001027558.1, label=Sulfite oxidase, mitochondrial, features=(SimpleProteinFeature(type=FeatureType.DOMAIN, info=FeatureInfo(name=Cytochrome b5 heme-binding, start=82, end=161)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Hinge, start=165, end=174)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Moco domain, start=175, end=401)), SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Homodimerization, start=402, end=538))))"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "print('Protein ID:', protein_id)\n",
+    "protein_meta"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`genophenocorr.model.ProteinMetadata` knows about the protein anatomy.\n",
+    "\n",
+    "The protein has an identifier and a human-readable label."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "NP_001027558.1\n",
+      "Sulfite oxidase, mitochondrial\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(protein_meta.protein_id)\n",
+    "print(protein_meta.label)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The protein metadata includes features - protein regions that were annotated with some useful information.\n",
+    "\n",
+    "All features know about their location within the aminoacid sequence. There is `info` property that exposes `region` property. \n",
+    "The `region` has `start` and `end` that denote the coordinates of the aminoacids spanned by the feature:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Name\tStart\tEnd\tLength\n",
+      "Cytochrome b5 heme-binding\t82\t161\t79\n",
+      "Hinge\t165\t174\t9\n",
+      "Moco domain\t175\t401\t226\n",
+      "Homodimerization\t402\t538\t136\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Name', 'Start', 'End', 'Length', sep='\\t')\n",
+    "for pm in protein_meta.protein_features:\n",
+    "    info = pm.info\n",
+    "    region = info.region\n",
+    "    print(info.name, region.start, region.end, len(region), sep='\\t')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In addition, the features can be of different types. Our data model includes protein *repeats*, *motifs*, *domains*, protein *regions* (see `FeatureType` enum). Not all proteins have been assigned with all feature types, and here we only have domains and regions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(SimpleProteinFeature(type=FeatureType.DOMAIN, info=FeatureInfo(name=Cytochrome b5 heme-binding, start=82, end=161)),\n",
+       " SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Hinge, start=165, end=174)),\n",
+       " SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Moco domain, start=175, end=401)),\n",
+       " SimpleProteinFeature(type=FeatureType.REGION, info=FeatureInfo(name=Homodimerization, start=402, end=538)))"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "protein_meta.protein_features"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "So, that's it for the background. Now, let's return to the figure."
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The figure\n",
+    "\n",
+    "Let's discuss the requirements of the variant transcript protein figure. I'll use your initial figure from the issue as a reference:\n",
+    "\n",
+    "![image.png](attachment:image.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The plot consists of 2 tracks: transcript and protein. The transcript track consists of adjacent adjacent blue/light blue boxes. The protein track features gray background with an overlay of colored boxes. The variant locations are depicted using lollipop markers. We can tweak the lollipop color and the diameter to represent variant properties."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Main figure\n",
+    "\n",
+    "The figure should have a title. The title should include the transcript and protein accessions, and probably also the protein name:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('NM_001032386.2', 'NP_001027558.1', 'Sulfite oxidase, mitochondrial')"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tx_coordinates.identifier, protein_meta.protein_id, protein_meta.label"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Transcript track\n",
+    "\n",
+    "The transcript track consists of adjacent boxes that represent CDS regions only. We do *not* plot UTRs or introns.\n",
+    "\n",
+    "In the context of *SUOX*, the track should include 3 boxes with widths that are proportionate to CDS region lengths:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
       "text/plain": [
-       "<Figure size 1000x1000 with 1 Axes>"
+       "[50, 178, 1410]"
       ]
      },
+     "execution_count": 27,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "widths = [len(cds) for cds in tx_coordinates.get_cds_regions()]\n",
+    "widths"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As an addition to the existing track, we should include CDS region number, unless the box width is insufficient to accommodate the number. We should use 1-based numbering to make this user friendly. \n",
+    "\n",
+    "So, `1`, `2`, `3` in this case.\n",
+    "\n",
+    "That's it for the transcript track."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Protein track\n",
+    "\n",
+    "Protein track is somwhat more elaborate.\n",
+    "\n",
+    "The track has grey region that spans the entire protein sequence. In our case, it corresponds to `545` aminoacids. \n",
+    "\n",
+    "Note, due to the aminoacid length, the coordinates of the grey region span $[0, 545)$. Any feature that extends beyond these coordinates is a bug. It should generally not happen, but if it does, it is a hard error, you must raise an exception with enough context to allow the user to fix the input, and abort the drawing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "545"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tx_coordinates.get_codon_count()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We must ensure that the grey region is perfectly aligned with the transcript track.\n",
+    "\n",
+    "The grey region is overlaid with boxes that correspond to protein features. As stated above, each feature has the coordinates with respect to the entire protein (gray region):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Region(start=82, end=161)\n",
+      "Region(start=165, end=174)\n",
+      "Region(start=175, end=401)\n",
+      "Region(start=402, end=538)\n"
+     ]
+    }
+   ],
+   "source": [
+    "for pf in protein_meta.protein_features:\n",
+    "    print(pf.info.region)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "So, in this example, we need to draw 4 boxes located at the corresponding regions. I believe that the boxes will never overlap, they should be, at most, adjacent.\n",
+    "\n",
+    "> I recommend adding a check that the features do not overlap and raising an exception if they do.\n",
+    "\n",
+    "We need to inform the user about the feature type (`genophenocorr.model.FeatureType`). One way of doing this is to use different colors but feel free to do whatever you like:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "FeatureType.DOMAIN\n",
+      "FeatureType.REGION\n",
+      "FeatureType.REGION\n",
+      "FeatureType.REGION\n"
+     ]
+    }
+   ],
+   "source": [
+    "for pf in protein_meta.protein_features:\n",
+    "    print(pf.feature_type)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We should annotate the boxes with the feature name if the box size permits:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cytochrome b5 heme-binding\n",
+      "Hinge\n",
+      "Moco domain\n",
+      "Homodimerization\n"
+     ]
+    }
+   ],
+   "source": [
+    "for pf in protein_meta.protein_features:\n",
+    "    print(pf.info.name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "That's it for the protein representation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Variants\n",
+    "\n",
+    "We need to show the location and attributes of variants found in the patient cohort. In principle, the variants could be drawn on either or both of the tracks. However, let's focus on protein track for now.\n",
+    "\n",
+    "First, a word of caution. Always think of a variant as of a *region* and not a *point*. After all, each point is a region with length `1`, right? Unlike protein features or CDS regions, the variant regions can overlap. Most of the time we will work with short variants and we can make some simplifications, but we may need to tweak this in future, so please keep this in mind.\n",
+    "\n",
+    "Getting the protein regions affected by the variants is a bit convoluted. Remember, the variant has information with respect to each transcript of the gene. In case of *SUOX*, the alternative splicing can produce x transcripts. So, we retrieve the annotation corresponding to the transcript of choice and then access the protein region. I show how to do this for the first 5 variants for simplicity:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Region(start=375, end=376)\n",
+      "Region(start=216, end=217)\n",
+      "Region(start=361, end=362)\n",
+      "Region(start=505, end=507)\n",
+      "Region(start=294, end=295)\n"
+     ]
     }
    ],
    "source": [
-    "viz.draw_variants(variants, tx_coordinates, protein_meta)"
+    "tx_anns = []\n",
+    "for i, v in enumerate(variants):\n",
+    "    if i == 5:\n",
+    "        break\n",
+    "    tx_ann = None\n",
+    "    for ann in v.tx_annotations:\n",
+    "        if ann.transcript_id == tx_id:\n",
+    "            tx_ann = ann\n",
+    "            break\n",
+    "    if tx_ann is None:\n",
+    "        raise ValueError(f'The transcript annotation for {tx_id} was not found!')\n",
+    "    else:\n",
+    "        tx_anns.append(tx_ann)\n",
+    "\n",
+    "for ann in tx_anns:\n",
+    "    print(ann.protein_effect_location)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### TODO - implement"
+    "We got the variant regions. In four out of five casese, the variant affects one aminoacid. However, the second variant spans *two* aminoacids!\n",
+    "\n",
+    "The question is what is the best way to draw variants as regions. I am not sure this can be done easily with lollipops. However, to keep things simple, we can draw the lollipop at the start coordinate."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we need to encode the variant effects. Each variant can have `1..m` effects on a transcript. The effects are members of the `genophenocorr.model.VariantEffect` enum. \n",
+    "\n",
+    "For simplicity, let's just choose the first effect and we can update this strategy later:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "missense_variant\n",
+      "missense_variant\n",
+      "missense_variant\n",
+      "frameshift_variant\n",
+      "missense_variant\n"
+     ]
+    }
+   ],
+   "source": [
+    "for ann in tx_anns:\n",
+    "    print(ann.variant_effects[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Last, some variants occurr more frequently than the others. In general, the variant count should be in range $[1, n)$ where $n$ is the number of patients in the cohort. We should be able to communicate the variant frequency to the users.\n",
+    "\n",
+    "In your figure, you do this using the lollipop color. I think it's OK.\n",
+    "\n",
+    "So, these are the main requirements."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Nice to have\n",
+    "\n",
+    "There are several things that would be nice to have, depending on how difficult their implementation would be. I list a few in arbitrary order (no precedence).\n",
+    "\n",
+    "### Variant overlap\n",
+    "\n",
+    "Currently, the lollipops overlap and it may be hard to see all the data.\n",
+    "\n",
+    "Ideally, the lollipops should not overlap. However, I am not sure how easy it would be to implement a layout algorithm to ensure there is no overlap.\n",
+    "\n",
+    "### View point\n",
+    "\n",
+    "Some medically releveant genes are very large. For instance, the protein *dystrophin* encoded by [*DMD*](https://www.genenames.org/data/gene-symbol-report/#!/hgnc_id/HGNC:2928) gene consists of 79 exons. The CDS includes ~11 thousand nucleotides. Dystrophin is, however, medically relevant and showing variants on such a large gene can bring up some issues.\n",
+    "\n",
+    "It could be helpful to be able to limit the picture on some part of the gene. Say, only the protein region $[a,b)$ or the exons $[a,b)$, ...\n",
+    "\n",
+    "### Popup on hover\n",
+    "\n",
+    "Is it possible to add information that shows on mouse cursor hover? We could show lots of useful info at many places. However, I am not sure how easy this would be. We intend to provide the figure through Jupyter, so the popup functionality would have to work there.\n",
+    "\n",
+    "### Scales\n",
+    "\n",
+    "Right now the plot includes two scales - `0 - 1390` and `# Markers`. I think the aminoacid scale is useful, and we should add a similar scale to the transcript plot to represent nulceotides, if possible. \n",
+    "\n",
+    "`# Markers` is great as well. It should probably start at `1`, it would be great to include a bunch of major ticks, and perhaps also horizontal grid lines? That would be SUPER cool.. :)\n",
+    "\n",
+    "### API\n",
+    "\n",
+    "Right now we make show certain things on the figure. For instance, we color the lollipop based on variant effect. However, I can imagine abstracting the coloring scheme away such that we can color the lollipop in arbitrary fashion (e.g. missense = red, others = blue). The same applies to other variant attributes, such as lollipop size and height.\n",
+    "\n",
+    "It would be great if the coloring scheme (and others) would be adjustable. This would allow us to provide a bunch of useful presets but also letting the users to do whatevery they wish.\n",
+    "\n",
+    "\n",
+    "This is all I can think of right now.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "To conclude, the figure is really amazing! I hope this is useful and let's stay in touch!"
    ]
   }
  ],
diff --git a/src/genophenocorr/view/_draw_variants.py b/src/genophenocorr/view/_draw_variants.py
new file mode 100644
index 00000000..830b879d
--- /dev/null
+++ b/src/genophenocorr/view/_draw_variants.py
@@ -0,0 +1,263 @@
+from itertools import cycle
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+from genophenocorr.model import Cohort, ProteinMetadata, TranscriptCoordinates, VariantEffect, FeatureType
+
+
+#  BASIC DRAWING METHODS
+def draw_rectangle(start_x, start_y, end_x, end_y, line_color='black', fill_color=None, line_width=1.0):
+    rect = plt.Rectangle((start_x, start_y), end_x - start_x, end_y - start_y, edgecolor=line_color,
+                         fill=fill_color is not None, linewidth=line_width, facecolor=fill_color)
+    plt.gca().add_patch(rect)
+
+
+def draw_line(start_x, start_y, end_x, end_y, line_color='black', line_width=1.0):
+    plt.plot([start_x, end_x], [start_y, end_y], color=line_color, linewidth=line_width)
+
+
+def draw_circle(center_x, center_y, radius, line_color='black', fill_color=None, line_width=1.0):
+    circle = plt.Circle((center_x, center_y), radius, edgecolor=line_color, fill=fill_color is not None,
+                        linewidth=line_width, facecolor=fill_color)
+    plt.gca().add_patch(circle)
+
+
+def draw_string(text, x, y, ha, va, color='black', fontsize=12, rotation=0):
+    plt.text(x, y, text, fontsize=fontsize, color=color, ha=ha, va=va, rotation=rotation)
+
+
+class VariantsVisualizer:
+    def __init__(self):
+        self.protein_track_color = '#a9a9a9'
+        self.transcript_track_color = '#a9a9a9'
+        self.marker_colors = {  # TODO: @ielis change colors for variant effects as desired
+            VariantEffect.TRANSCRIPT_ABLATION: "#ff0000",
+            VariantEffect.SPLICE_ACCEPTOR_VARIANT: "#00ff00",
+            VariantEffect.SPLICE_DONOR_VARIANT: "#0000ff",
+            VariantEffect.STOP_GAINED: "#ff00ff",
+            VariantEffect.FRAMESHIFT_VARIANT: "#ffff00",
+            VariantEffect.STOP_LOST: "#00ffff",
+            VariantEffect.START_LOST: "#ff9900",
+            VariantEffect.TRANSCRIPT_AMPLIFICATION: "#9900ff",
+            VariantEffect.INFRAME_INSERTION: "#ff0099",
+            VariantEffect.INFRAME_DELETION: "#99ff00",
+            VariantEffect.MISSENSE_VARIANT: "#00ff99",
+            VariantEffect.PROTEIN_ALTERING_VARIANT: "#990000",
+            VariantEffect.SPLICE_REGION_VARIANT: "#009900",
+            VariantEffect.SPLICE_DONOR_5TH_BASE_VARIANT: "#009999",
+            VariantEffect.SPLICE_DONOR_REGION_VARIANT: "#990099",
+            VariantEffect.SPLICE_POLYPYRIMIDINE_TRACT_VARIANT: "#999900",
+            VariantEffect.INCOMPLETE_TERMINAL_CODON_VARIANT: "#999999",
+            VariantEffect.START_RETAINED_VARIANT: "#ffcc00",
+            VariantEffect.STOP_RETAINED_VARIANT: "#ccff00",
+            VariantEffect.SYNONYMOUS_VARIANT: "#00ccff",
+            VariantEffect.CODING_SEQUENCE_VARIANT: "#ff00cc",
+            VariantEffect.MATURE_MIRNA_VARIANT: "#cc00ff",
+            VariantEffect.FIVE_PRIME_UTR_VARIANT: "#ff6600",
+            VariantEffect.THREE_PRIME_UTR_VARIANT: "#6600ff",
+            VariantEffect.NON_CODING_TRANSCRIPT_EXON_VARIANT: "#ff3366",
+            VariantEffect.INTRON_VARIANT: "#3366ff",
+            VariantEffect.NMD_TRANSCRIPT_VARIANT: "#ffcc99",
+            VariantEffect.NON_CODING_TRANSCRIPT_VARIANT: "#cc99ff",
+            VariantEffect.UPSTREAM_GENE_VARIANT: "#ff6633",
+            VariantEffect.DOWNSTREAM_GENE_VARIANT: "#6633ff",
+            VariantEffect.TFBS_ABLATION: "#cc3300",
+            VariantEffect.TFBS_AMPLIFICATION: "#ccff66",
+            VariantEffect.TF_BINDING_SITE_VARIANT: "#66ccff",
+            VariantEffect.REGULATORY_REGION_ABLATION: "#ff3366",
+            VariantEffect.REGULATORY_REGION_AMPLIFICATION: "#3366ff",
+            VariantEffect.FEATURE_ELONGATION: "#ffcc33",
+            VariantEffect.REGULATORY_REGION_VARIANT: "#ccff33",
+            VariantEffect.FEATURE_TRUNCATION: "#33ccff",
+            VariantEffect.INTERGENIC_VARIANT: "#ff0033",
+            VariantEffect.SEQUENCE_VARIANT: "#33ff00",
+        }
+        self.protein_feature_colors = {
+            FeatureType.REPEAT: 'yellow',
+            FeatureType.MOTIF: 'orange',
+            FeatureType.DOMAIN: 'red',
+            FeatureType.REGION: 'brown'
+        }
+        self.protein_feature_names = {
+            FeatureType.REPEAT: 'Repeat',
+            FeatureType.MOTIF: 'Motif',
+            FeatureType.DOMAIN: 'Domain',
+            FeatureType.REGION: 'Region'
+        }
+        self.feature_outline_color = 'black'
+        self.exon_colors = cycle(['blue', 'lightblue'])
+        self.exon_outline_color = 'black'
+        self.axis_color = 'black'
+
+    def _draw_marker(self, x_start, x_end, min_y, max_y, circle_radius, color):
+        x = (x_start + x_end) / 2  # TODO @ielis, currently putting marker in the middle of start and end, can change this later
+        draw_line(x, min_y, x, max_y - circle_radius, line_color=self.protein_track_color, line_width=0.5)
+        draw_circle(x, max_y, circle_radius, line_color=self.protein_track_color, fill_color=color, line_width=0.5)
+
+    def _marker_dim(self, marker_count, protein_track_y_max, marker_length=0.02, marker_radius=0.0025):
+        radius = marker_radius + np.sqrt(marker_count - 1) * marker_radius
+        length = protein_track_y_max + marker_length + np.sqrt(marker_count - 1) * marker_length
+        return radius, length
+
+    def _get_tx_anns(self, variants, tx_id):
+        tx_anns = []
+        for i, v in enumerate(variants):
+            tx_ann = None
+            for ann in v.tx_annotations:
+                if ann.transcript_id == tx_id:
+                    tx_ann = ann
+                    break
+            if tx_ann is None:
+                raise ValueError(f'The transcript annotation for {tx_id} was not found!')
+            else:
+                tx_anns.append(tx_ann)
+
+        return tx_anns
+
+    def draw_fig(self, tx_coordinates: TranscriptCoordinates, protein_meta: ProteinMetadata, cohort: Cohort):
+        tx_id = tx_coordinates.identifier
+        protein_id = protein_meta.protein_id
+        variants = cohort.all_variants
+        tx_anns = self._get_tx_anns(variants, tx_id)
+
+        exon_limits = np.array([(cds.start, cds.end) for cds in tx_coordinates.get_cds_regions()])
+        min_exon_limit = np.min(exon_limits)
+        feature_limits = np.array([(feature.info.start, feature.info.end) for feature in protein_meta.protein_features])
+        feature_types = [pf.feature_type for pf in protein_meta.protein_features]
+        feature_colors = [self.protein_feature_colors[ft] for ft in feature_types]
+        feature_names = [self.protein_feature_names[ft] for ft in feature_types]
+        feature_limits = (feature_limits * 3) - 2 + min_exon_limit  # to convert from codons to bases
+        variant_locations = np.array([[
+            ann.protein_effect_location.start,
+            ann.protein_effect_location.end]
+            for ann in tx_anns
+        ])
+        variant_locations = (variant_locations * 3) - 2 + min_exon_limit  # to convert from codons to bases
+        variant_effects = np.array([(ann.variant_effects[0]) for ann in tx_anns])
+        # count marker occurrences and remove duplicates
+        variant_locations_counted_absolute, marker_counts = np.unique(variant_locations, axis=0, return_counts=True)
+        variant_effect_colors = []
+        for vl in variant_locations_counted_absolute:
+            i = np.where(variant_locations == vl)[0][0]  # find index of unique variant loc in all locs to find effect
+            effect = variant_effects[i]
+            variant_effect_colors.append(self.marker_colors[effect])
+        exon_labels = [f'{i + 1}' for i in range(len(exon_limits))]
+
+        protein_track_x_min, protein_track_x_max = 0.15, 0.85
+        protein_track_y_min, protein_track_y_max = 0.492, 0.508
+        exon_y_min, exon_y_max = 0.39, 0.43
+        font_size = 12
+        text_padding = 0.004
+
+        plt.figure(figsize=(20, 20))
+
+        min_x_absolute = min(np.min(feature_limits), np.min(exon_limits), np.min(variant_locations))
+        max_x_absolute = max(np.max(feature_limits), np.max(exon_limits), np.max(variant_locations))
+
+        max_marker_count = np.max(marker_counts)
+
+        # normalize into [0, 1], leaving some space on the sides
+        def preprocess(x_absolute):
+            shifted_to_0_1 = ((x_absolute - min_x_absolute) / (max_x_absolute - min_x_absolute))
+            relative_scale = (protein_track_x_max - protein_track_x_min)
+            return shifted_to_0_1 * relative_scale + protein_track_x_min
+
+        exon_limits_relative = preprocess(exon_limits)
+        feature_limits_relative = preprocess(feature_limits)
+        variant_locations_relative = preprocess(variant_locations_counted_absolute)
+
+        # draw the tracks
+        draw_rectangle(protein_track_x_min, protein_track_y_min, protein_track_x_max, protein_track_y_max,
+                       line_color=self.protein_track_color, fill_color=self.protein_track_color, line_width=2.0)
+        draw_rectangle(protein_track_x_min, exon_y_min*1.03, protein_track_x_max, exon_y_max/1.03,
+                       line_color=self.protein_track_color, fill_color=self.protein_track_color, line_width=2.0)
+        # x_axis
+        x_axis_y = protein_track_y_min - 0.02
+        x_axis_min_x, x_axis_max_x = protein_track_x_min, protein_track_x_max
+        big_tick_length, small_tick_length = 0.01, 0.005
+        draw_line(x_axis_min_x, x_axis_y, x_axis_max_x, x_axis_y, line_color=self.axis_color,
+                  line_width=1.0)  # main line
+        draw_line(x_axis_min_x, x_axis_y - big_tick_length, x_axis_min_x, x_axis_y, line_color=self.axis_color,
+                  line_width=1.0)  # minimum tick
+        draw_string(str(min_x_absolute), x_axis_min_x, x_axis_y - big_tick_length - text_padding, fontsize=font_size,
+                    ha='center', va='top')
+        draw_line(x_axis_max_x, x_axis_y - big_tick_length, x_axis_max_x, x_axis_y, line_color=self.axis_color,
+                  line_width=1.0)  # max tick
+        draw_string(str(max_x_absolute), x_axis_max_x, x_axis_y - big_tick_length - text_padding, fontsize=font_size,
+                    ha='center', va='top')
+
+        # y_axis
+        y_axis_x = protein_track_x_min - 0.02
+        y_axis_min_y = protein_track_y_max + 0.01
+        _, y_axis_max_y = self._marker_dim(max_marker_count, protein_track_y_max)
+        draw_line(y_axis_x, y_axis_min_y, y_axis_x, y_axis_max_y, line_color=self.axis_color, line_width=1.0)
+        draw_line(y_axis_x - small_tick_length, y_axis_min_y, y_axis_x, y_axis_min_y, line_color=self.axis_color,
+                  line_width=1.0)  # 0 tick
+        draw_string("0", y_axis_x - small_tick_length - text_padding, y_axis_min_y, fontsize=font_size, ha='right',
+                    va='center')
+        draw_line(y_axis_x - small_tick_length, y_axis_max_y, y_axis_x, y_axis_max_y, line_color=self.axis_color,
+                  line_width=1.0)  # max tick
+        draw_string(str(max_marker_count), y_axis_x - small_tick_length - text_padding, y_axis_max_y,
+                    fontsize=font_size, ha='right', va='center')
+        draw_string("# Markers", y_axis_x - 0.05, (y_axis_min_y + y_axis_max_y) / 2, fontsize=font_size, ha='center',
+                    va='center', rotation=90)  # x axis label
+
+        # draw the exons (transcript track)
+        # iterate over pairs
+        for exon_x, exon_label in zip(exon_limits_relative, exon_labels):
+            exon_x_min, exon_x_max = exon_x
+            cur_color = next(self.exon_colors)
+            draw_rectangle(exon_x_min, exon_y_min, exon_x_max, exon_y_max,
+                           line_color=self.exon_outline_color, fill_color=cur_color, line_width=1.0)
+            exon_width = exon_x_max - exon_x_min
+            font_size = int(4 * exon_width + 8)  # min 8, max 12
+            draw_string(exon_label,
+                        0.45 * (exon_x_max - exon_x_min) + exon_x_min,
+                        0.4 * (exon_y_max - exon_y_min) + exon_y_min,
+                        ha="left", va="center", color='black', fontsize=font_size
+                        )
+
+        # draw variants
+        marker_y_min = protein_track_y_max
+        for marker, marker_color in zip(variant_locations_relative, variant_effect_colors):
+            marker_count = marker_counts[np.where(variant_locations_relative == marker)[0][0]]
+            cur_radius, cur_length = self._marker_dim(marker_count, protein_track_y_max)
+            x_start, x_end = marker[0], marker[1]
+            self._draw_marker(x_start, x_end, marker_y_min, cur_length, cur_radius, marker_color)
+
+        # draw the features (protein track)
+        feature_y_min, feature_y_max = 0.485, 0.515
+        for feature_x, feature_color, feature_name in zip(feature_limits_relative, feature_colors, feature_names):
+            feature_x_min, feature_x_max = feature_x
+            draw_rectangle(feature_x_min, feature_y_min, feature_x_max, feature_y_max,
+                           line_color=self.feature_outline_color,
+                           fill_color=feature_color, line_width=1.0)
+            if (feature_x_max - feature_x_min) <= 0.03:  # too small to dsplay name
+                draw_string(feature_name,
+                            0.05 * (feature_x_max - feature_x_min) + feature_x_min,
+                            0.55 * (feature_y_max - feature_y_min) + feature_y_min,
+                            ha="left", va="center", rotation=90, color='black', fontsize=8
+                            )
+            elif (feature_x_max - feature_x_min) <= 0.005:  # too small even to draw vertical string
+                # TODO @ielis: How to display name here?
+                pass
+            else:
+                draw_string(feature_name,
+                            0.2 * (feature_x_max - feature_x_min) + feature_x_min,
+                            0.4 * (feature_y_max - feature_y_min) + feature_y_min,
+                            ha="left", va="center", color='black'
+                            )
+
+        # draw legend
+        draw_rectangle(0.7, 0.6, 0.85, 0.7, 'black')
+        # TODO: legend
+
+        plt.xlim(0, 1)
+        plt.ylim(0.3, 0.75)
+        plt.gca().set_aspect('equal')
+        plt.axis('off')
+        plt.title(f'[Working title:] transcript: {tx_id}, '
+                  f'protein: {protein_id},'
+                  f'protein name: {protein_meta.label}')
+        plt.show()


Test patch:
diff --git a/dev/test_draw_variants.ipynb b/dev/test_draw_variants.ipynb
new file mode 100644
index 00000000..8e176054
--- /dev/null
+++ b/dev/test_draw_variants.ipynb
@@ -0,0 +1,345 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "70a753d6a4225669",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-02-21T13:03:47.738479300Z",
+     "start_time": "2024-02-21T13:03:47.731404100Z"
+    },
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "tx_id = 'NM_001032386.2'\n",
+    "protein_id = 'NP_001027558.1'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "7a49258b45c46876",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-02-21T13:03:55.325990900Z",
+     "start_time": "2024-02-21T13:03:47.738479300Z"
+    },
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/robin/PycharmProjects/genophenocorr/gpc_venv/lib/python3.9/site-packages/urllib3/__init__.py:35: NotOpenSSLWarning: urllib3 v2 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n",
+      "  warnings.warn(\n",
+      "Response.transcripts has 6!=1 items. Choosing the first\n"
+     ]
+    }
+   ],
+   "source": [
+    "from genophenocorr.model.genome import GRCh38\n",
+    "from genophenocorr.preprocessing import VVTranscriptCoordinateService\n",
+    "\n",
+    "txc_service = VVTranscriptCoordinateService(genome_build=GRCh38)\n",
+    "tx_coordinates = txc_service.fetch(tx_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3b9f3c741a2352b5",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-02-21T13:03:55.658500400Z",
+     "start_time": "2024-02-21T13:03:55.328237400Z"
+    },
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from genophenocorr.preprocessing import UniprotProteinMetadataService\n",
+    "\n",
+    "pms = UniprotProteinMetadataService()\n",
+    "\n",
+    "protein_metas = pms.annotate(protein_id)\n",
+    "\n",
+    "assert len(protein_metas) == 1\n",
+    "protein_meta = protein_metas[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "cf458535b18dc26c",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-02-21T13:04:05.189283600Z",
+     "start_time": "2024-02-21T13:03:55.672155100Z"
+    },
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Patients Created: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 35/35 [01:58<00:00,  3.38s/it]\n",
+      "Validated under none policy\n",
+      "Showing errors and warnings\n",
+      "35 phenopacket(s) found at `/Users/robin/PycharmProjects/genophenocorr/dev/../notebooks/SUOX/phenopackets`\n",
+      "  patient #0\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #1\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #2\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #3\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #4\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #5\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #6\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #7\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #8\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #9\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #10\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #11\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #12\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #13\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #14\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #15\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #16\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #17\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #18\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #19\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #20\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #21\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #22\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #23\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #24\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #25\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #26\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #27\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #28\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #29\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #30\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #31\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #32\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #33\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n",
+      "  patient #34\n",
+      "    phenotype-features\n",
+      "     warnings:\n",
+      "     ·No diseases found.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Loaded 35 samples'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import hpotk\n",
+    "import os\n",
+    "from genophenocorr.preprocessing import load_phenopacket_folder\n",
+    "from genophenocorr.preprocessing import configure_caching_cohort_creator\n",
+    "from hpotk.validate import ValidationRunner\n",
+    "from hpotk.validate import ObsoleteTermIdsValidator, PhenotypicAbnormalityValidator, AnnotationPropagationValidator\n",
+    "\n",
+    "fpath_hpo = 'https://github.com/obophenotype/human-phenotype-ontology/releases/download/v2023-10-09/hp.json'\n",
+    "hpo = hpotk.load_minimal_ontology(fpath_hpo)\n",
+    "\n",
+    "validation_runner = ValidationRunner(\n",
+    "    validators=(\n",
+    "        ObsoleteTermIdsValidator(hpo),\n",
+    "        PhenotypicAbnormalityValidator(hpo),\n",
+    "        AnnotationPropagationValidator(hpo)\n",
+    "    ))\n",
+    "\n",
+    "pc = configure_caching_cohort_creator(hpo, validation_runner=validation_runner)\n",
+    "\n",
+    "fpath_suox_cohort = os.path.join(os.getcwd(), os.pardir, 'notebooks', 'SUOX', 'phenopackets')\n",
+    "cohort = load_phenopacket_folder(fpath_suox_cohort, pc)\n",
+    "f'Loaded {len(cohort)} samples'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "c5abc6b06465c6c1",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-02-21T13:04:05.423909300Z",
+     "start_time": "2024-02-21T13:04:05.191304900Z"
+    },
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x2000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from genophenocorr.view._draw_variants import VariantsVisualizer\n",
+    "viz = VariantsVisualizer()\n",
+    "viz.draw_fig(tx_coordinates, protein_meta, cohort)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0385dd13-2134-4f0f-b5ad-4bc60e88f336",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "gpc_venv",
+   "language": "python",
+   "name": "gpc_venv"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tests/test_data/test_vv_response.json b/tests/test_data/test_vv_response.json
new file mode 100644
index 00000000..af4f4e94
--- /dev/null
+++ b/tests/test_data/test_vv_response.json
@@ -0,0 +1,1 @@
+{"current_name": "sulfite oxidase", "current_symbol": "SUOX", "hgnc": "HGNC:11460", "previous_symbol": "", "requested_symbol": "NM_001032386.2", "transcripts": [{"annotations": {"chromosome": "12", "db_xref": {"CCDS": "CCDS8901.2", "ensemblgene": "None", "hgnc": "HGNC:11460", "ncbigene": "6821", "select": "False"}, "ensembl_select": "False", "mane_plus_clinical": "False", "mane_select": "False", "map": "12q13.2", "note": "sulfite oxidase", "refseq_select": "False", "variant": "3"}, "coding_end": 1712, "coding_start": 75, "description": "Homo sapiens sulfite oxidase (SUOX), transcript variant 3, mRNA; nuclear gene for mitochondrial product", "genomic_spans": {"NC_000012.11": {"end_position": 56399309, "exon_structure": [{"cigar": "64=", "exon_number": 1, "genomic_end": 56391123, "genomic_start": 56391060, "transcript_end": 64, "transcript_start": 1}, {"cigar": "60=", "exon_number": 2, "genomic_end": 56396055, "genomic_start": 56395996, "transcript_end": 124, "transcript_start": 65}, {"cigar": "178=", "exon_number": 3, "genomic_end": 56396504, "genomic_start": 56396327, "transcript_end": 302, "transcript_start": 125}, {"cigar": "1908=", "exon_number": 4, "genomic_end": 56399309, "genomic_start": 56397402, "transcript_end": 2210, "transcript_start": 303}], "orientation": 1, "start_position": 56391060, "total_exons": 4}, "NC_000012.12": {"end_position": 56005525, "exon_structure": [{"cigar": "64=", "exon_number": 1, "genomic_end": 55997339, "genomic_start": 55997276, "transcript_end": 64, "transcript_start": 1}, {"cigar": "60=", "exon_number": 2, "genomic_end": 56002271, "genomic_start": 56002212, "transcript_end": 124, "transcript_start": 65}, {"cigar": "178=", "exon_number": 3, "genomic_end": 56002720, "genomic_start": 56002543, "transcript_end": 302, "transcript_start": 125}, {"cigar": "1908=", "exon_number": 4, "genomic_end": 56005525, "genomic_start": 56003618, "transcript_end": 2210, "transcript_start": 303}], "orientation": 1, "start_position": 55997276, "total_exons": 4}}, "length": 2210, "reference": "NM_001032387.2", "translation": "NP_001027559.1"}, {"annotations": {"chromosome": "12", "db_xref": {"CCDS": "CCDS8901.2", "ensemblgene": "None", "hgnc": "HGNC:11460", "ncbigene": "6821", "select": "False"}, "ensembl_select": "False", "mane_plus_clinical": "False", "mane_select": "False", "map": "12q13.2", "note": "sulfite oxidase", "refseq_select": "False", "variant": "3"}, "coding_end": 1729, "coding_start": 92, "description": "Homo sapiens sulfite oxidase (SUOX), transcript variant 3, mRNA", "genomic_spans": {"NC_000012.11": {"end_position": 56399309, "exon_structure": [{"cigar": "81=", "exon_number": 1, "genomic_end": 56391123, "genomic_start": 56391043, "transcript_end": 81, "transcript_start": 1}, {"cigar": "60=", "exon_number": 2, "genomic_end": 56396055, "genomic_start": 56395996, "transcript_end": 141, "transcript_start": 82}, {"cigar": "178=", "exon_number": 3, "genomic_end": 56396504, "genomic_start": 56396327, "transcript_end": 319, "transcript_start": 142}, {"cigar": "1908=", "exon_number": 4, "genomic_end": 56399309, "genomic_start": 56397402, "transcript_end": 2227, "transcript_start": 320}], "orientation": 1, "start_position": 56391043, "total_exons": 4}, "NC_000012.12": {"end_position": 56005525, "exon_structure": [{"cigar": "81=", "exon_number": 1, "genomic_end": 55997339, "genomic_start": 55997259, "transcript_end": 81, "transcript_start": 1}, {"cigar": "60=", "exon_number": 2, "genomic_end": 56002271, "genomic_start": 56002212, "transcript_end": 141, "transcript_start": 82}, {"cigar": "178=", "exon_number": 3, "genomic_end": 56002720, "genomic_start": 56002543, "transcript_end": 319, "transcript_start": 142}, {"cigar": "1908=", "exon_number": 4, "genomic_end": 56005525, "genomic_start": 56003618, "transcript_end": 2227, "transcript_start": 320}], "orientation": 1, "start_position": 55997259, "total_exons": 4}}, "length": 2329, "reference": "NM_001032387.1", "translation": "NP_001027559.1"}, {"annotations": {"chromosome": "12", "db_xref": {"CCDS": "CCDS8901.2", "ensemblgene": "None", "hgnc": "HGNC:11460", "ncbigene": "6821", "select": "False"}, "ensembl_select": "False", "mane_plus_clinical": "False", "mane_select": "False", "map": "12q13.2", "note": "sulfite oxidase", "refseq_select": "False", "variant": "1"}, "coding_end": 1964, "coding_start": 327, "description": "Homo sapiens sulfite oxidase (SUOX), transcript variant 1, mRNA", "genomic_spans": {"NC_000012.11": {"end_position": 56399309, "exon_structure": [{"cigar": "81=", "exon_number": 1, "genomic_end": 56391123, "genomic_start": 56391043, "transcript_end": 81, "transcript_start": 1}, {"cigar": "109=", "exon_number": 2, "genomic_end": 56391507, "genomic_start": 56391399, "transcript_end": 190, "transcript_start": 82}, {"cigar": "126=", "exon_number": 3, "genomic_end": 56393242, "genomic_start": 56393117, "transcript_end": 316, "transcript_start": 191}, {"cigar": "60=", "exon_number": 4, "genomic_end": 56396055, "genomic_start": 56395996, "transcript_end": 376, "transcript_start": 317}, {"cigar": "178=", "exon_number": 5, "genomic_end": 56396504, "genomic_start": 56396327, "transcript_end": 554, "transcript_start": 377}, {"cigar": "1908=", "exon_number": 6, "genomic_end": 56399309, "genomic_start": 56397402, "transcript_end": 2462, "transcript_start": 555}], "orientation": 1, "start_position": 56391043, "total_exons": 6}, "NC_000012.12": {"end_position": 56005525, "exon_structure": [{"cigar": "81=", "exon_number": 1, "genomic_end": 55997339, "genomic_start": 55997259, "transcript_end": 81, "transcript_start": 1}, {"cigar": "109=", "exon_number": 2, "genomic_end": 55997723, "genomic_start": 55997615, "transcript_end": 190, "transcript_start": 82}, {"cigar": "126=", "exon_number": 3, "genomic_end": 55999458, "genomic_start": 55999333, "transcript_end": 316, "transcript_start": 191}, {"cigar": "60=", "exon_number": 4, "genomic_end": 56002271, "genomic_start": 56002212, "transcript_end": 376, "transcript_start": 317}, {"cigar": "178=", "exon_number": 5, "genomic_end": 56002720, "genomic_start": 56002543, "transcript_end": 554, "transcript_start": 377}, {"cigar": "1908=", "exon_number": 6, "genomic_end": 56005525, "genomic_start": 56003618, "transcript_end": 2462, "transcript_start": 555}], "orientation": 1, "start_position": 55997259, "total_exons": 6}, "NG_008136.1": {"end_position": 13267, "exon_structure": [{"cigar": "81=", "exon_number": 1, "genomic_end": 5081, "genomic_start": 5001, "transcript_end": 81, "transcript_start": 1}, {"cigar": "109=", "exon_number": 2, "genomic_end": 5465, "genomic_start": 5357, "transcript_end": 190, "transcript_start": 82}, {"cigar": "126=", "exon_number": 3, "genomic_end": 7200, "genomic_start": 7075, "transcript_end": 316, "transcript_start": 191}, {"cigar": "60=", "exon_number": 4, "genomic_end": 10013, "genomic_start": 9954, "transcript_end": 376, "transcript_start": 317}, {"cigar": "178=", "exon_number": 5, "genomic_end": 10462, "genomic_start": 10285, "transcript_end": 554, "transcript_start": 377}, {"cigar": "1908=", "exon_number": 6, "genomic_end": 13267, "genomic_start": 11360, "transcript_end": 2462, "transcript_start": 555}], "orientation": 1, "start_position": 5001, "total_exons": 6}}, "length": 2564, "reference": "NM_000456.2", "translation": "NP_000447.2"}, {"annotations": {"chromosome": "12", "db_xref": {"CCDS": "CCDS8901.2", "ensemblgene": "None", "hgnc": "HGNC:11460", "ncbigene": "6821", "select": "MANE"}, "ensembl_select": "False", "mane_plus_clinical": "False", "mane_select": "True", "map": "12q13.2", "note": "sulfite oxidase", "refseq_select": "True", "variant": "2"}, "coding_end": 1821, "coding_start": 184, "description": "Homo sapiens sulfite oxidase (SUOX), transcript variant 2, mRNA; nuclear gene for mitochondrial product", "genomic_spans": {"NC_000012.11": {"end_position": 56399309, "exon_structure": [{"cigar": "64=", "exon_number": 1, "genomic_end": 56391123, "genomic_start": 56391060, "transcript_end": 64, "transcript_start": 1}, {"cigar": "109=", "exon_number": 2, "genomic_end": 56391507, "genomic_start": 56391399, "transcript_end": 173, "transcript_start": 65}, {"cigar": "60=", "exon_number": 3, "genomic_end": 56396055, "genomic_start": 56395996, "transcript_end": 233, "transcript_start": 174}, {"cigar": "178=", "exon_number": 4, "genomic_end": 56396504, "genomic_start": 56396327, "transcript_end": 411, "transcript_start": 234}, {"cigar": "1908=", "exon_number": 5, "genomic_end": 56399309, "genomic_start": 56397402, "transcript_end": 2319, "transcript_start": 412}], "orientation": 1, "start_position": 56391060, "total_exons": 5}, "NC_000012.12": {"end_position": 56005525, "exon_structure": [{"cigar": "64=", "exon_number": 1, "genomic_end": 55997339, "genomic_start": 55997276, "transcript_end": 64, "transcript_start": 1}, {"cigar": "109=", "exon_number": 2, "genomic_end": 55997723, "genomic_start": 55997615, "transcript_end": 173, "transcript_start": 65}, {"cigar": "60=", "exon_number": 3, "genomic_end": 56002271, "genomic_start": 56002212, "transcript_end": 233, "transcript_start": 174}, {"cigar": "178=", "exon_number": 4, "genomic_end": 56002720, "genomic_start": 56002543, "transcript_end": 411, "transcript_start": 234}, {"cigar": "1908=", "exon_number": 5, "genomic_end": 56005525, "genomic_start": 56003618, "transcript_end": 2319, "transcript_start": 412}], "orientation": 1, "start_position": 55997276, "total_exons": 5}, "NG_008136.1": {"end_position": 13267, "exon_structure": [{"cigar": "64=", "exon_number": 1, "genomic_end": 5081, "genomic_start": 5018, "transcript_end": 64, "transcript_start": 1}, {"cigar": "109=", "exon_number": 2, "genomic_end": 5465, "genomic_start": 5357, "transcript_end": 173, "transcript_start": 65}, {"cigar": "60=", "exon_number": 3, "genomic_end": 10013, "genomic_start": 9954, "transcript_end": 233, "transcript_start": 174}, {"cigar": "178=", "exon_number": 4, "genomic_end": 10462, "genomic_start": 10285, "transcript_end": 411, "transcript_start": 234}, {"cigar": "1908=", "exon_number": 5, "genomic_end": 13267, "genomic_start": 11360, "transcript_end": 2319, "transcript_start": 412}], "orientation": 1, "start_position": 5018, "total_exons": 5}}, "length": 2319, "reference": "NM_001032386.2", "translation": "NP_001027558.1"}, {"annotations": {"chromosome": "12", "db_xref": {"CCDS": "CCDS8901.2", "ensemblgene": "None", "hgnc": "HGNC:11460", "ncbigene": "6821", "select": "False"}, "ensembl_select": "False", "mane_plus_clinical": "False", "mane_select": "False", "map": "12q13.2", "note": "sulfite oxidase", "refseq_select": "False", "variant": "1"}, "coding_end": 1947, "coding_start": 310, "description": "Homo sapiens sulfite oxidase (SUOX), transcript variant 1, mRNA; nuclear gene for mitochondrial product", "genomic_spans": {"NC_000012.11": {"end_position": 56399309, "exon_structure": [{"cigar": "64=", "exon_number": 1, "genomic_end": 56391123, "genomic_start": 56391060, "transcript_end": 64, "transcript_start": 1}, {"cigar": "109=", "exon_number": 2, "genomic_end": 56391507, "genomic_start": 56391399, "transcript_end": 173, "transcript_start": 65}, {"cigar": "126=", "exon_number": 3, "genomic_end": 56393242, "genomic_start": 56393117, "transcript_end": 299, "transcript_start": 174}, {"cigar": "60=", "exon_number": 4, "genomic_end": 56396055, "genomic_start": 56395996, "transcript_end": 359, "transcript_start": 300}, {"cigar": "178=", "exon_number": 5, "genomic_end": 56396504, "genomic_start": 56396327, "transcript_end": 537, "transcript_start": 360}, {"cigar": "1908=", "exon_number": 6, "genomic_end": 56399309, "genomic_start": 56397402, "transcript_end": 2445, "transcript_start": 538}], "orientation": 1, "start_position": 56391060, "total_exons": 6}, "NC_000012.12": {"end_position": 56005525, "exon_structure": [{"cigar": "64=", "exon_number": 1, "genomic_end": 55997339, "genomic_start": 55997276, "transcript_end": 64, "transcript_start": 1}, {"cigar": "109=", "exon_number": 2, "genomic_end": 55997723, "genomic_start": 55997615, "transcript_end": 173, "transcript_start": 65}, {"cigar": "126=", "exon_number": 3, "genomic_end": 55999458, "genomic_start": 55999333, "transcript_end": 299, "transcript_start": 174}, {"cigar": "60=", "exon_number": 4, "genomic_end": 56002271, "genomic_start": 56002212, "transcript_end": 359, "transcript_start": 300}, {"cigar": "178=", "exon_number": 5, "genomic_end": 56002720, "genomic_start": 56002543, "transcript_end": 537, "transcript_start": 360}, {"cigar": "1908=", "exon_number": 6, "genomic_end": 56005525, "genomic_start": 56003618, "transcript_end": 2445, "transcript_start": 538}], "orientation": 1, "start_position": 55997276, "total_exons": 6}, "NG_008136.1": {"end_position": 13267, "exon_structure": [{"cigar": "64=", "exon_number": 1, "genomic_end": 5081, "genomic_start": 5018, "transcript_end": 64, "transcript_start": 1}, {"cigar": "109=", "exon_number": 2, "genomic_end": 5465, "genomic_start": 5357, "transcript_end": 173, "transcript_start": 65}, {"cigar": "126=", "exon_number": 3, "genomic_end": 7200, "genomic_start": 7075, "transcript_end": 299, "transcript_start": 174}, {"cigar": "60=", "exon_number": 4, "genomic_end": 10013, "genomic_start": 9954, "transcript_end": 359, "transcript_start": 300}, {"cigar": "178=", "exon_number": 5, "genomic_end": 10462, "genomic_start": 10285, "transcript_end": 537, "transcript_start": 360}, {"cigar": "1908=", "exon_number": 6, "genomic_end": 13267, "genomic_start": 11360, "transcript_end": 2445, "transcript_start": 538}], "orientation": 1, "start_position": 5018, "total_exons": 6}}, "length": 2445, "reference": "NM_000456.3", "translation": "NP_000447.2"}, {"annotations": {"chromosome": "12", "db_xref": {"CCDS": "CCDS8901.2", "ensemblgene": "None", "hgnc": "HGNC:11460", "ncbigene": "6821", "select": "False"}, "ensembl_select": "False", "mane_plus_clinical": "False", "mane_select": "False", "map": "12q13.2", "note": "sulfite oxidase", "refseq_select": "False", "variant": "2"}, "coding_end": 1838, "coding_start": 201, "description": "Homo sapiens sulfite oxidase (SUOX), transcript variant 2, mRNA", "genomic_spans": {"NC_000012.11": {"end_position": 56399309, "exon_structure": [{"cigar": "81=", "exon_number": 1, "genomic_end": 56391123, "genomic_start": 56391043, "transcript_end": 81, "transcript_start": 1}, {"cigar": "109=", "exon_number": 2, "genomic_end": 56391507, "genomic_start": 56391399, "transcript_end": 190, "transcript_start": 82}, {"cigar": "60=", "exon_number": 3, "genomic_end": 56396055, "genomic_start": 56395996, "transcript_end": 250, "transcript_start": 191}, {"cigar": "178=", "exon_number": 4, "genomic_end": 56396504, "genomic_start": 56396327, "transcript_end": 428, "transcript_start": 251}, {"cigar": "1908=", "exon_number": 5, "genomic_end": 56399309, "genomic_start": 56397402, "transcript_end": 2336, "transcript_start": 429}], "orientation": 1, "start_position": 56391043, "total_exons": 5}, "NC_000012.12": {"end_position": 56005525, "exon_structure": [{"cigar": "81=", "exon_number": 1, "genomic_end": 55997339, "genomic_start": 55997259, "transcript_end": 81, "transcript_start": 1}, {"cigar": "109=", "exon_number": 2, "genomic_end": 55997723, "genomic_start": 55997615, "transcript_end": 190, "transcript_start": 82}, {"cigar": "60=", "exon_number": 3, "genomic_end": 56002271, "genomic_start": 56002212, "transcript_end": 250, "transcript_start": 191}, {"cigar": "178=", "exon_number": 4, "genomic_end": 56002720, "genomic_start": 56002543, "transcript_end": 428, "transcript_start": 251}, {"cigar": "1908=", "exon_number": 5, "genomic_end": 56005525, "genomic_start": 56003618, "transcript_end": 2336, "transcript_start": 429}], "orientation": 1, "start_position": 55997259, "total_exons": 5}}, "length": 2438, "reference": "NM_001032386.1", "translation": "NP_001027558.1"}]}
\ No newline at end of file
diff --git a/tests/test_vv_preprocessing.py b/tests/test_vv_preprocessing.py
new file mode 100644
index 00000000..73e3dee3
--- /dev/null
+++ b/tests/test_vv_preprocessing.py
@@ -0,0 +1,95 @@
+import os
+import json
+import typing
+import unittest
+
+import hpotk
+import requests
+
+from genophenocorr.model import VariantCoordinates, TranscriptInfoAware, TranscriptCoordinates
+from genophenocorr.model.genome import GenomeBuild, GenomicRegion, Strand, Contig, transpose_coordinate
+#from ._api import VariantCoordinateFinder, TranscriptCoordinateService
+
+
+RESPONSE_FILENAME = os.path.join(os.path.dirname(__file__), 'test_data', 'test_vv_response.json')
+
+
+class TestVvPreprocessing(unittest.TestCase):
+    """Test class to understand and document the structure of the JSON returned by VariantValidator queries for transcript coordinates.
+    """
+    @classmethod
+    def setUpClass(cls) -> None:
+        f = open(RESPONSE_FILENAME)
+        cls._response_d = json.load(f,)
+
+    def test_response_is_dictionary(self):
+        self.assertIsNotNone(self._response_d)
+        self.assertTrue(isinstance(self._response_d, dict))
+
+
+    def test_keys(self):
+        expected_keys = {"current_name", "current_symbol", "hgnc", "previous_symbol", "requested_symbol", "transcripts" }
+        self.assertEqual(len(expected_keys), len(self._response_d.keys()))
+        for key in expected_keys:
+            self.assertTrue(key in self._response_d)
+        
+    def test_current_name(self):
+        expected = "sulfite oxidase"
+        # variant_identifier = list(self._response_d.keys())[0]
+        self.assertEqual(expected, self._response_d.get("current_name"))
+
+    def test_current_symbol(self):
+        expected = "SUOX"
+        self.assertEqual(expected, self._response_d.get("current_symbol"))
+
+    def test_hgnc(self):
+        expected = "HGNC:11460"
+        self.assertEqual(expected, self._response_d.get("hgnc"))
+
+    def test_previous_symbol(self):
+        expected = ""
+        self.assertEqual(expected, self._response_d.get("previous_symbol"))
+
+    def test_requested_symbol(self):
+        expected = "NM_001032386.2"  ## this is the transcript ID we requested from variantvalidator
+        self.assertEqual(expected, self._response_d.get("requested_symbol"))
+
+    def test_transcripts(self):
+        transcripts = self._response_d.get("transcripts")
+        self.assertTrue(isinstance(transcripts, list))
+        self.assertEqual(6, len(transcripts))
+        for t in transcripts:
+            print(t)
+
+    def test_transcript_zero(self):
+        transcripts = self._response_d.get("transcripts")
+        t0 = transcripts[0]
+        self.assertTrue(isinstance(t0, dict))
+        expected_keys = {'annotations', 'coding_end', 'coding_start', 'description', 'genomic_spans', 'length', 'reference', 'translation'}
+        self.assertEqual(len(t0.keys()), len(expected_keys))
+        for key in t0.keys():
+            self.assertTrue(key in expected_keys)
+        coding_start = t0.get("coding_start")
+        self.assertEqual(75, coding_start)
+        coding_end = t0.get("coding_end")
+        self.assertEqual(1712, coding_end)
+        length = t0.get("length")
+        self.assertEqual(2210, length)
+        reference = t0.get("reference")
+        self.assertEqual("NM_001032387.2", reference)
+        translation = t0.get("translation")
+        self.assertEqual("NP_001027559.1", translation)
+        genomic_spans = t0.get("genomic_spans")
+        self.assertTrue(isinstance(genomic_spans, dict))
+        #Homo sapiens chromosome 12, GRCh37.p13
+        self.assertTrue("NC_000012.11" in genomic_spans)
+        # Homo sapiens chromosome 12, GRCh38.p14 
+        self.assertTrue("NC_000012.12" in genomic_spans)
+        hg38span = genomic_spans.get("NC_000012.12")
+        end_position = hg38span.get("end_position")
+        self.assertEqual(56005525, end_position)
+        exon_structure = hg38span.get("exon_structure")
+        self.assertTrue(isinstance(exon_structure, list))
+        self.assertEqual(4, len(exon_structure))
+        total_exons = hg38span.get("total_exons")
+        self.assertEqual(4, total_exons)
\ No newline at end of file