Welcome to KvarQ’s documentation!¶

Precompiled packages¶

The different releases are available als compiled packages for Microsoft Windows and OSX (10.6 and later): http://github.com/kvarq/kvarq/releases

Note that the packages are currently not signed and you therefore have to enable OS X to run programs from unidentified developers if you run OS X 10.8 or newer.

Installing KvarQ From Source¶

The source code is hosted in a git repository at http://github.com/kvarq/kvarq

wget http://www.python.org/ftp/python/2.7.4/Python-2.7.4.tgz
tar xzf Python-2.7.4.tgz
cd Python-2.7.4
mkdir $HOME/py
./configure --prefix=$HOME/py
make && make install
PATH=$HOME/py/bin:$PATH
export $PATH
python -V

wget https://bitbucket.org/pypa/setuptools/raw/bootstrap/ez_setup.py -O - | python

wget https://github.com/kvarq/kvarq/archive/master.zip
unzip master.zip
rm master.zip
cd kvarq-master
python setup.py test

python setup.py install

PYTHONPATH=`pwd`; export PYTHONPATH
alias kvarq='python -m kvarq.cli'
kvarq -h

Using The Command Line¶

Depending on which installation instructions you followed, the KvarQ command line utility will be accessible in a different way

• installation from source: simply enter kvarq on the command line or alternatively call python -m kvarq.cli (make sure the directory containing kvarq/ is in the PYTHONPATH if you just downloaded & compiled KvarQ without installing it)
• binary installation windows: go to the directory with the kvarq files and start kvarq.exe

In either case you can use all the functionality described below by using this one comand with appopriate flags. The different flags are all described briefly if KvarQ is run with the --help command line switch.

Note that most command line arguments apply to a specific subcommand, but some arguments (such as selection of testsuites using the -t option or logging using the -d and -l options) apply to all commands and are therefore specified before the subcommand.

Loading of Testsuites¶

Testsuites can be loaded by three different mechanisms. These mechanisms can be used for the GUI program as well if it is started from the command line using the gui subcommand. Note that if a testsuite is specified more than one time, the last occurrence is used.

1. From the environment variable KVARQ_TESTSUITES that contains a colon separated list of paths to KvarQ testsuites.
2. From the directory testsuites/ in the current working directory. This directory can also contain symbolic links to KvarQ testsuites.
3. Via the command line switch -t. This switch can be specified any number of times.

Directly Analysing a .fastq¶

Use to show subcommand to analyze .fastq files directly without performing a scan of the file. For example, the readlengths that would result from a specified quality cutoff can be displayed using:

kvarq show -Q 13 H37v_scan.fastq

Scanning a Single File¶

The scan subcommand scans a .fastq file and saves the results in a .json file. There are many additional parameters to this command. See the following examples to illustrate some scenarios.

Simplest scenario: Scan a file, showing a progress bar during the scanning process and save the results (using the MTBC testsuites):

kvarq -t testsuites/MTBC/ scan -p H37v_strain.fastq H37v_strain.json

Being more verbose and copying the log output into a separate file:

kvarq -t testsuites/MTBC/ -d -l kvarq.log scan -p H37v_strain.fastq H37v_strain.json

In the following example, only the phylogenetic testsuite is loaded from the MTBC directory:

kvarq -t testsuites/MTBC/phylo.py scan H37v_strain.fastq H37v_strain.json

During the scanning, it is possible to obtain some additional statistics by pressing <CTRL-C> on the terminal (this does not work on Windows when you use a MinGW bash prompt). Pressing <CTRL-C> twice within two seconds will interrupt the scanning process and proceed to calculate the results with the data gathered so far.

Usually, the default parameters for quality cut-off and minimum overlap (see Configuration Parameters) work pretty well. If you encounter problems with a particular .fast file, refer to the examples in Determine Scanning Parameters.

Scanning a Batch of Files¶

The KvarQ source distribution comes with some utility scripts that allow to scan a whole batch of .fastq files with a single invocation from the command line. the names of the .fastq files are taken from a table (which can be in comma separated values format or alternatively in Microsoft Excel 97/2000/XP/2003 for convenience). The execution of the script scripts/table_scan.py will try to find every .fastq file specified in the table, then run kvarq/cli.py and save the resulting .json files into the specified output directory (by default, testsuites are drawn from the directory ./testsuites so you might want to set a symlink before starting the scan as in the following example):

ln -s /usr/local/share/kvarq/testsuites/MTBC/ testsuites
python scripts/table_scan.py fastqs.xls results

In the next example, the files in the list are only scanned for phylogenetic markers and resistance information and the number of threads is limited to four to save some processing power for the other users while all hit occurences are recorded for further analysis (the flags specified are exeactly the same as available for the scan subcommand):

ln -s /usr/local/share/kvarq/testsuites/MTBC/phy testsuites
python scripts/table_scan.py -f '-l kvarq.log -t testsuites/phylo.py -t testsuites/resistance.py scan -t 4 -H -p' fastqs.csv results/

In a second step, the original table can be combined with the results of all the .json files (the following command will create a new file called output/fastqs.xls that contains the original fastqs.xls as well as the result from the scans). The script can easily be modified to include other data from the .json file than the default selection.:

python scripts/table_combine.py fastqs.xls results/

Showing Results¶

Some simple analysis of .json files are possible using the command line, but the GUI explorer is much more powerful.

The subcommand illustrate can be used to show the final results of the scanning, as well as detailed information about the coverages or a histogram of the (quality-cut) readlengths encountered:

kvarq -t testsuites/MTBC illustrate -C H37v_strain.json
kvarq -t testsuites/MTBC illustrate -r H37v_strain.json
kvarq -t testsuites/MTBC illustrate -l H37v_strain.json

Updating Results¶

Since a .json file contains not only the final results but also the intermediare results (encoded in kvarq.analyse.Coverage), it is possible to update the results sections after modifying the code without having to re-scan the .fastq file. The .json file is updated in-place:

kvarq -t testsuites/MTBC -d update H37v_scan.json

More Usage Examples¶

#!/bin/bash
for fastq in `find /tbresearch -name \*.fastq`; do
  python -m kvarq.cli -d show "$fastq" 2>"$0_error.log"
  err="$?"
  echo $err $fastq
  if [ $err -ne 0 ]; then
    # file format error
    base=`basename "$fastq"`
    mv "$0_error.log" "${base%.fastq}.log"
  fi
done
rm "$0_error.log"

[   0-   3] 4440 (44%)*****************************************************************
[   3-   6] 2995 (29%)*******************************************
[   6-   9] 1221 (12%)*****************
[   9-  12]  618 ( 6%)*********
[  12-  15]  364 ( 3%)*****
[  15-  18]  206 ( 2%)***
[  18-  21]   93 ( 0%)*
[  21-  24]   44 ( 0%)
[  24-  27]   11 ( 0%)
[  27-  30]    1 ( 0%)
[  30-  33]    0 ( 0%)
[  33-  36]    0 ( 0%)
[  36-  39]    2 ( 0%)
[  39-  42]    1 ( 0%)
[  42-  45]    2 ( 0%)
[  45-  48]    2 ( 0%)

[   0-   2]  183 ( 1%)******
[   2-   4]  209 ( 2%)*******
[   4-   6]  611 ( 6%)*********************
[   6-   8]  839 ( 8%)******************************
[   8-  10]  896 ( 9%)********************************
[  10-  12]  822 ( 8%)*****************************
[  12-  14]  867 ( 8%)*******************************
[  14-  16]  633 ( 6%)**********************
[  16-  18]  692 ( 6%)************************
[  18-  20]  628 ( 6%)**********************
[  20-  22]  499 ( 5%)*****************
[  22-  24]  520 ( 5%)******************
[  24-  26] 1810 (18%)*****************************************************************
[  26-  28]  706 ( 7%)*************************
[  28-  30]   82 ( 0%)**

Launching the GUI¶

Depending on how KvarQ was installed, there are different ways of launching the GUI

• Installation from source: simply enter kvarq gui on the command line or alternatively call python -m kvarq.cli gui. When KvarQ is launched this way, you can use some command line switches (for example specify the directory containing the testsuites).
• Binary installation windows: go to the directory with the KvarQ files and start kvarq-gui.exe
• Binary installation OS X: open the KvarQ application in the Finder

Below is what you should see after launching the GUI

The right pane in the main window shows the log output that describes the general activity as well as useful additional information during the scanning process. Important messages (warnings, errors) are highlighted in red.

Configuring KvarQ¶

There are two steps to configure KvarQ:

1. Specify the testsuites that are known to the program. These testsuites can be loaded from different places. If a testsuite with the same name already exists, it is replaced with the one specified last.

   The scanner as well as the explorer need to know these testsuites in order perform the scanning or correctly display the results. After loading testsuites, they appear in the list (unless they were replacing another testsuite already listed). From this set of available testsuites, a selection can be made that specifies which of the testsuites should be used during the scanning process. Selecting more testsuites will slow down the scanning process and produce larger, more informative files.

2. The engine configuration parameters can also be modified. Usually, the default values work well, but in some cases (such as old low-quality files) it can be advantageous to change some of these values.

The Scanner¶

This simple window allows to scan a single or multiple .fastq files to generate .json files (depending on whether a single or multiple files are selected in the file selection dialog).

The progress bar (yes, the design is on purpose to remind users to use the command line) shows the progress as well as estimated time left for the current file. The scanning process can be interrupted by clicking on the stop button.

Once the scanning process is done (for all files), the results can be saved to .json files (one per .fastq file). The result of the last scan can also be viewed directly, without saving it to file.

The Explorer¶

The explorer is a simple Tk program consisting of different windows:

Directory explorer viewing .json files in a directory

Double-clicking any of the list items will open then .json explorer showing details on the selected file.

It is also possible to export the analysis summary of all displayed .json files to a excel sheet by using the button at the bottom of the list.

.json explorer showing general information about file

In the upper pane of the .json explorer shows an overview over the file. The contents of the lower pane depend on the selection in the upper pane. Because the info section is selected in the upper pane in this example, the lower pane shows general information about the scanning process, such as the scantime or the kvarq.engine configuration.

The items ending with ... open another window when double-clicked (similar to the coverages described below).

.json explorer showing analysis test details

In this case, the phylogenetic suite was selected in the upper pane. Therefore, all tests belonging to this testsuite are displayed in the lower pane. Every item in the upper pane (apart from the “info” item) consists of the testsuite name (in this case “phylo”) and the summarized result (in this case lineage 2, sublineage bejing).

Every item in the lower pane informs about the following test details:

• Whether the test was “found positive” : a + sign in front of the test name signifies that this test was positive. For a SNP this means that the specified mutant allele was found and for a test covering a larger region of the genome this signifies that there was at least one mutation detected in the region of interest.
• Test name that describes the genotype.
• Double semicolon :: followed by description of what was tested (this can be a SNP or a region; regions are specified by their start/stop base position and a + or - specifying which strand is coding at this position).
• Double-clicking on an item in the lower pane opens a coverage window.

Interpreting Coverages¶

KvarQ displays the results of the scanning process in the form of coverages. This display shows information about how many reads were mapped against the sequence of interest and whether there were any mutations detected. The same display is used for SNPs as well as for longer regions, althoug the signification of the displayed elements is somewhat different.

Mutation in the katG resistance confering codon.

General structure of a coverage window:

• The x axis is the genome position. Add the number showed on the x axis to the base position in parantheses in the figure title.
• The y axis is depth of coverage, piling all reads up that mapped to the given positions.
• The red vertical lines show start and stop of the region of interest. In this case, the region of interest is only three bases long, but 25 bases of spacers are added on either side when scanning for the region (see Configuration Parameters).
• The horizontal lines are mean and pseudo-variations of coverage over the region of interest.
• The colored graphs show mutations. In this example there is clearly a mutation that replaced the second base with a guanosine nucleotide. Note that not every read showed this mutation, but a handful had the original base (if every single read showed this mutation, the colored line would go all the way up to the thick black line).
• Moving the mouse over the graph shows quantitative information about the hovered genome position at the bottom of the graph.

Coverage of a single nucleotide polyphormism (SNP), mutant genotype.

Because KvarQ is looking for a specific mutant sequence, the SNP is “found” if there is no mutation at its position, as is the case in this example (i.e. at position 157129 there is really a T and not a C).

Note: “No color” means mutant for SNP, while it means wild type for regions...

Coverage of a single nucleotide polyphormism (SNP), wildtype genotype.

Note: There’s also the (quite unlikely) possibility that there is a new (i.e. not-looked-for) SNP. This example shows the SNP3304966GA. The bottom display (coverage=91 mutations=91x G) makes it clear that we have indeed the wild type.

Rolling your own testsuite¶

KvarQ makes it very simple to write new testsuites. Take as an example the file included below (can be found in the testsuites/ directory of the source distribution). After having developed a testsuite and tested it on your data, please send me a note and I will include a link in the KvarQ distribution. See Ebola Outbreak 2014 for a tutorial on how to write a testsuite.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

# this is an example testsuite that illustrates how to write simple
# SNP/region based testsuite to be used with kvarq

# the testsuite can be included during the scanning by using the
# command line parameter '-t' or in the configuration window in the GUI

# see the kvarq documentation for more information


# the version specifies the version of the testsuite itself; this version
# string is included in the .json scan results
# the minor number should be increased every time the file changes. the major
# number should be increased when the changes are not backwards compatible
# (e.g. when a new test is added)

VERSION = '0.1'

# this version is compared against the COMPATIBILITY global module variable
# defined in kvarq.genes
# as before, compatibility is warranted if the first number is equal and the
# second equal or lower (than the one defined in kvarq.genes)

GENES_COMPATIBILITY = '0.0'


# we use these classes to define our testsuite
from kvarq.genes import Genotype, Gene, Test, Testsuite, Reference, SNP, TemplateFromGenome

# load hypothetical MTB ancestor genome from local directory
from kvarq.genes import Genome
import os.path
ancestor_path = os.path.join(os.path.dirname(__file__), 'MTB_ancestor_reference.bases')
ancestor = Genome(ancestor_path, 'MTB ancestor')

# use this for loggging (displayed on console / in main GUI window)
from kvarq.log import lo


# references tell where more information ont he mutations can be found
tbdream = Reference('TBDReamDB : see http://tbdreamdb.com/')

# the first genotype simply signals isoniazid resistance
inhA = Genotype('Isoniazid resistance')
# the second genotype also signals isoniazid resistance but indicates
# the gene to which it belongs to -- this enables output of resistance
# mutation in the familiar gene.XposX format
katG = Genotype('Isoniazid resistance', Gene(ancestor,'katG', 2153889, 2156111, plus_strand=False))

# define two SNPs : 1673432TA and 1673432TC -- only specified mutations will
# be found (i.e. 1673432TATG would not be reported)
# note that the SNP is simply the "template" for that will be used when scanning
# for mutations in the FastQ reads; the "test" as a whole defines a template,
# a genotype (inhA in this case) and the resource from the information is drawn
SNP1 = Test(SNP(genome=ancestor, pos=1673432, orig='T', base='A'), inhA, tbdream)
SNP2 = Test(SNP(genome=ancestor, pos=1673432, orig='T', base='C'), inhA, tbdream)

# define a (short) region that should be scanned for ANY mutations here we're
# interested in the codon 2155167-2155169; by specifying where the gene is read
# from (minus strand) and the position of the amino acid is produced by this
# codon (in this case the gene starts at 2153889, therefore the amino acid is
# ((2155167-2153889)/3 +1)=427) it is later possible to check for (non)
# synonymous mutations as before, the "test" consists of a template, a genotype
# and a resource (but the "template" is a region and not a SNP as before)
katG_codon = Test(TemplateFromGenome(genome=ancestor, start=2155167,
    stop=2155169, direction='-', aa_pos0=(2155167-2153889)/3 +1), katG,
    tbdream)


# it's important to NAME the testsuite the SAME AS THE FILENAME up to the first
# dash !  (e.g. it's possible to rename this file to "example-0.1.py")
example = Testsuite([SNP1, SNP2, katG_codon], VERSION)


# note that this testsuite is very simple and will simply eport any mutations
# found in the FastQ file -- often it makes sense to subclass the Testsuite
# class (and redefine the _analyse method) to get a fine-grained control on how
# the mutations are synthesized into a result... see the source code of
# kvarq.genes.phylo as an example

Versions, Compatibility¶

The following problems can arise when different versions of testsuites are used

• A testsuite is not compatible with the KvarQ version that loads it. To avoid this scenario, the module global GENES_COMPATIBILITY is compared with the module global kvarq.genes.COMPATIBILITY version of KvarQ running it. The first number must be matched exactly and the second number must be equal or smaller to the one defined in the genes package. Whenever KvarQ introduces new features that break the backwards-compatibility with the testsuites, the first number is increased.
• A testsuite is loaded to display data from a .json file that was generated by testsuite with a different number. The moduel global VERSION tells the version of the testsuite defining it. Upon a backwards-compatible change (e.g. deletion of a previous test), the minor number is increased by one. Note that introductions of new tests are not backwards compatible because the new version of the testsuite will be looking for non-existing tests when loading data generated with an old version.

Ebola Outbreak 2014¶

Gire et al have sequenced some 99 virus genomes during the 2014 Ebola outbreak and immediately released all sequence data to “facilitate rapid global research”. In the following, we’re going to develop a simple testsuite that allows KvarQ to say whether a .fastq file is from a) a ebola virus, b) the 2014 outbreak, and c) from any of the three sublineages defined in the paper (see figure 4A).

# old ebola genome from previous outbreak
EBOV76 = Genome(os.path.join(os.path.dirname(__file__), 'EBOV76.fasta'))

gire14 = Reference('Gire et al (2014) doi 10.1126/science.1259657')

# sub-lineages as defined in gire14
SL1 = Genotype('SL1')
SL2 = Genotype('SL2')
SL3 = Genotype('SL3')

# SNPs extracted from primary data using suppl/_extract_SNPs.py
SNPs = [
        Test(SNP(genome=EBOV76, pos=800, orig='C', base='T'), SL2, gire14),
        Test(SNP(genome=EBOV76, pos=1849, orig='T', base='C'), SL1, gire14),
        Test(SNP(genome=EBOV76, pos=6283, orig='C', base='T'), SL1, gire14),
        Test(SNP(genome=EBOV76, pos=8928, orig='A', base='C'), SL2, gire14),
        Test(SNP(genome=EBOV76, pos=10218, orig='G', base='A'), SL3, gire14),
        Test(SNP(genome=EBOV76, pos=13856, orig='A', base='G'), SL1, gire14),
        Test(SNP(genome=EBOV76, pos=15660, orig='T', base='C'), SL1, gire14),
        Test(SNP(genome=EBOV76, pos=15963, orig='G', base='A'), SL2, gire14),
        Test(SNP(genome=EBOV76, pos=17142, orig='T', base='C'), SL2, gire14),
    ]

sierraleone14 = Testsuite(SNPs, VERSION)

Overview¶

Simplified overview of scanning process and preparation.

Testsuites are python source files that define the SNPs of interest (or in this case a 3 base pair long region) as well as other relevant genetic information (in this case the katG gene which can confer Isoniazid resistance). This information is used to extract a “target sequence” from a hypothetical ancestral MTBC genome: on both sides, additional bases (“flanks”) are concatenated to avoid border effects within the sequence of interest. During the scanning process, every read is trimmed depending on its PHRED score (in this case, a quality cutoff of Q=13 was defined which corresponds to the ASCII character /). After the scanning, all reads that matched the target sequence are assembled to a “coverage” that indicates the overall coverage depth as well as all detected mutations (green). In a further step, additional information is generated from this coverage (such as the resulting amino acid sequence) and finally a short “result” string is generated that summarizes the result of the scanning process.

This figure illustrates the flow of data inside kvarq.

Python modules/packages are colored in blue, C extensions in red. Rectangles with rounded corners represent data structures passed along the way.

The testsuites provide a list of sequences. The C extension kvarq.engine then scans the .fastq file and finds all occurrences of these sequences. The list of these occurrences (the hit list) is then passed to the module kvarq.analyser that maps the reads onto the original sequences and creates coverages (see Coverage. This coverage is passed back to the different testsuites that calculates the final results. The coverages are saved along with the results (and optionally the hit list) into the .json file.

Configuration Parameters¶

This figure illustrates the different configuration parameters for kvarq.engine

In this example, Amin='B' causes that only the gray part of the read (number of bases in this part is readlength) is considered when the read is aligned to the different sequences. The overlap is the number of bases that the read and the sequence have in common. In this example the read is aligned despite of the two bases that differ from the sequence – this is only the case if maxerrors>=2.

The function kvarq.engine.config() accepts the following parameters

• Amin : ASCII character of the Phred score that corresponds to the minimal quality score of a base calling to be accepted. Use method kvarq.fastq.Fastq.Q2A() to translate a Phred score into an ASCII value.
• minreadlength : After cutting the individual reads using the provided Amin, reads shorter than minreadlength are discarded.
• minoverlap : Reads that overlap (at the beginning or the end of the sequence) with less bases than the specified values are not reported.
• maxerrors : Reads that differ in more than maxerrors base positions are not considered for a match.
• nthreads : Number of threads to use in parallel for scanning the .fastq file.

These parameters can be set using command line switches or in the settings dialog.

About flanks¶

In general, KvarQ searches for a given sequence within the genome and checks for mutations within that “region of interest”. Because .fastq reads are only accepted if the overlap between the target sequence and the read has a specified minimum overlap (minreadlength), the coverage rapidly falls on both extremities of the target sequence. For this reason, a region of interest is flanked with supplementary bases on either side. Mutations in these flanks are disregarded, as their sole purpose is to avoid to have the border effect with low coverage within the region of interest. TemplateFromGenome read their bases from a Genome and can easily add an arbitrary flank on either side of the region of interest.

About positions¶

• All positions within a Genome are relative to the index one. I.e. the first codon of the genome (if it were coding) would be the bases 1-3 which correspond to the first three bytes in the file (at file positions 0-2). Positions increase in the reading direction of the plus strand.
• The TemplateFromGenome‘s start and stop attributes refer to positions in the genome.
• Sequences are simply strings of bases and therefore, indexing within sequences starts at the first character of this sequence string. This sequence string may contain flanks on both sides. The (optional) attribute start refers to the first base after the flank (i.e. the first base of the sequence of interest).
• In a Coverage, positions simply refer to its Sequences on the plus strand. A coverage has no pos attribute and the start, stop attributes correspond to the (plus strand) sequence’s left and right.
• The Hit structure

About the complementary DNA strand¶

In general, everything refers to the + strand of the genome. Just before scanning, the analyser creates a complementary copy of every Sequence in Analyser.scan(). When assembling the hits in Coverage.apply_hit(), hits on the complementary strand are mapped on the positive strand again using the methods Sequence.plus_idx() and Sequence.plus_base(). Finally, the TemplateFromGenome and the Gene attached to a Test know whether the + or the complementary - strand is coding and accordingly converts the base mutations in (non-) synonymous amino acid changes.

Sequence of tests¶

The Analyser is initialized with a set of testsuites that define each a given number of Test. Just before scanning, the analyser creates a list (actually a OrderedDict) that contains every test of every testsuite. The base sequences the engine searches in the .fastq version is ordered in the same sequence (with the complementary base sequences added at the end of the list). Later on, the Coverage are ordered in the same sequence and everything that gets saved to the .json file (in encode()) uses the same sequence again. To be able to reconstruct the same order when loading a .json file, the decode() tries to identify every test by its name (as returned by its __str__() method) and reconstructs the same sequence of tests. The Analyser[...] method retunrs a Coverage and accepts integers as well as strings and Test).

About clonal variants (“heterozygous calls”)¶

• phylogenetic : in current implementation >50% must be present of SNP to be accepted; this leads to complete dominance of the clone with >50% genetic material in the mixture; see kvarq.genes.SNP.validate()

version 0.12.2¶

• added support for more .fastq.gz formats

version 0.12.1¶

• support .fastq.gz files
• added new ways to load testsuites
• some bugfixes in scripts/table_{scan|combine}.py
• moved additional testsuites into their own repositories

version 0.11.3¶

• (first public version, pushed to github)
• compile on windows without having to install pthread files
• moved all testsuites into separate testsuite/ directory
• introduced testsuite compatability checks
• updated MTBC.resistance testsuite (added katG.279, rpoC.N698H, renamed rrsK)

version 0.11.2¶

• renamed to KvarQ (previous name was “pyseq”)
• made xlrd, xlwt optional dependencies (import/export data as .csv)
• polished GUI somewhat

version 0.11.1¶

• internally use kvarq.analyse.Coverage instead of kvarq.genes.Test to identify sequences and hits
• more compact file format
• support legacy .json files; legacy testsuites can also be loaded separately (some are included in testsuites/legacy/)

version 0.10.10¶

• enabled multiple use of same kvarq.genes.Test for different kvarq.genes.Testsuite

version 0.10.9¶

• implemented all plotting in Tkinter – matplotlib not needed anymore
• added settings dialog to GUI
• moved non-published tests into separate files in testsuites/ directory

version 0.10.8¶

• added new fields to stats : nseqhits, records_parsed
• added new attributes to kvarq.fastq.Fastq : readlength, records_approx
• (these fields are also displayed in the json explorer)
• added terminal color support
• improved FastQ quality score decoding
• improved scripts/table_combine.py (insert data into existing table)
• include html documentation in distributions
• testsuites can be loaded from arbitrary locations (see Rolling your own testsuite)

version 0.10.7¶

• relaxed .fastq file format specifications

version 0.10.6¶

• .fastq file format checking (both in kvarq.fastq and kvarq.engine)
• give every thread 10 file junks to keep scanning speed constant until the end

version 0.10.5¶

• “batch processing” in kvarq.gui.{simple|explorer}
• resistances output aa number
• cleaned up output spoligo/resistances
• do not include hits in .jsons when using gui/simple