toulligqc 2.6__tar.gz → 2.7.1__tar.gz

{toulligqc-2.6 → toulligqc-2.7.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: toulligqc
-Version: 2.6
+Version: 2.7.1
 Summary: A post sequencing QC tool for Oxford Nanopore sequencers
-Home-page: https://github.com/GenomicParisCentre/toulligQC
+Home-page: https://github.com/GenomiqueENS/toulligQC
 Author: Genomic Paris Centre team
-Author-email: toulligqc@biologie.ens.fr
+Author-email: toulligqc@bio.ens.psl.eu
 License: GPL V3
 Keywords: Nanopore MinION QC report
 Platform: ALL
@@ -15,7 +15,7 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: License :: OSI Approved :: CEA CNRS Inria Logiciel Libre License, version 2.1 (CeCILL-2.1)
-Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.11.0
 License-File: LICENSE-CeCILL.txt
 License-File: LICENSE.txt

{toulligqc-2.6 → toulligqc-2.7.1}/README.md

@@ -24,6 +24,7 @@ Support is availlable on [GitHub issue page](https://github.com/GenomicParisCent
   * 1.3 [Docker](#docker)
      *  [Docker image recovery](#docker-image-recovery)
      *  [Launching Docker image with docker run](#launching-Docker-image-with-docker-run)
+  * 1.4 [nf-core module](#nfcore-module)
 
 * 2.[Usage](#usage)
   * 2.1 [Command line](#command-line)
@@ -52,18 +53,31 @@ $ cd toulligqc && python3 setup.py build install
 ToulligQC is written with Python 3.
 To run ToulligQC without Docker, you need to install the following Python modules:
 
-* matplotlib
-* plotly
-* h5py
+ * matplotlib
+ * plotly
+ * h5py
 * pandas
 * numpy
 * scipy
 * scikit-learn
 * pysam
+* tqdm
+* pod5
 
+<a name="Conda-environemnt"></a>
+### 1.2 Conda environemnt**
+
+You can use a conda environment to install the required packages:
+
+```
+git clone https://github.com/GenomicParisCentre/toulligQC.git
+cd toulligqc && python3 setup.py build install
+conda env create -f environment.yml
+conda activate toulliqc
+```
 
 <a name="pypi-installation"></a>
-### 1.2 Using a PyPi package
+### 1.3 Using a PyPi package
 
 ToulligQC can be more easlily installed with a pip package availlable on the PyPi repository. The following command line  will install the latest version of ToulligQC:
 ```bash
@@ -71,7 +85,7 @@ $ pip3 install toulligqc
 ```
 
 <a name="docker"></a>
-### 1.3 Using Docker
+### 1.4 Using Docker
 ToulligQC and its dependencies are available through a Docker image. To install docker on your system, go to the Docker website (<https://docs.docker.com/engine/installation/>).
 Even if Docker can run on Windows or macOS virtual machines, we recommend to run ToulligQC on a Linux host.
 <a name="docker-image-recovery"></a>
@@ -93,14 +107,25 @@ $ docker run -ti \
              -v /path/to/basecaller/sequencing/summary/file:/path/to/basecaller/sequencing/summary/file \
              -v /path/to/basecaller/sequencing/telemetry/file:/path/to/basecaller/telemetry/summary/file \
              -v /path/to/result/directory:/path/to/result/directory \
-             toulligqc:latest
+             genomicpariscentre/toulligqc:latest
+```
+
+<a name="nfcore-module"></a>
+### 1.4 Using nf-core module
+ToulligQC is also available on nf-core as a module written in nextflow. To install nf-core on your system, please visit their website (<https://nf-co.re/docs/usage/introduction>).
+
+The following command line will install the latest version of the ToulligQC module:
+
+```bash
+$ nf-core modules install toulligqc
 ```
+
 <a name="usage"></a>
 ## 2. Usage
 <a name="command-line"></a>
 
 ToulligQC is adapted to RNA-Seq along with DNA-Seq and it is compatible with 1D² runs.
-This QC tool supports only Guppy basecalling ouput files.
+This QC tool supports only Guppy and Dorado basecalling ouput files.
 It also needs a single FAST5 file (to catch the flowcell ID and the run date) if a telemetry file is not provided.
 Flow cells and kits version are retrieved using the telemetry file.
 ToulligQC can take barcoding samples by adding the barcode list as a command line option.
@@ -111,7 +136,7 @@ To do so, ToulligQC deals with different file formats: gz, tar.gz, bz2, tar.bz2
 This tool will produce a set of graphs, statistic file in plain text format and a HTML report.
 
 
-To run ToulligQC you need the Guppy basecaller output files : ```sequencing_summary.txt``` and ```sequencing_telemetry.js```. or ```FASTQ``` or ```BAM```
+To run ToulligQC you need the Guppy/ Dorado basecaller output files : ```sequencing_summary.txt``` and ```sequencing_telemetry.js```. or ```FASTQ``` or ```BAM```
 This can be compressed with gzip or bzip2. 
 You can use your initial Fast5 ONT file too.
 ToulligQC can perform analyses on your data if the directory is organised as the following:
@@ -132,7 +157,7 @@ RUN_ID
     └── sequencing_1dsq_summary.txt
  ```
 
-For a barcoded run you can add the barcoding files generated by Guppy ```barcoding_summary_pass.txt``` and ```barcoding_summary_fail.txt``` to ToulligQC or a single file ```sequencing_summary_all.txt``` containing sequencing_summary and barcoding_summary information combined.
+For a barcoded run you can add the barcoding files generated by Guppy/ Dorado ```barcoding_summary_pass.txt``` and ```barcoding_summary_fail.txt``` to ToulligQC or a single file ```sequencing_summary_all.txt``` containing sequencing_summary and barcoding_summary information combined.
 
 For the barcode list to use in the command line options, ToulligQC handle the following naming schemes: BCXX, RBXX, NBXX and barcodeXX where XX is the number of the barcode.
 The barcode naming schemes are case insensitive.
@@ -156,14 +181,16 @@ This is a directory for 1D² analysis with barcoding files:
 
 General Options:
 ```
-usage: ToulligQC V2.2.1 -a SEQUENCING_SUMMARY_SOURCE [-t TELEMETRY_SOURCE]
-                        [--fastq -q FASTQ] [--bam -u BAM]
-                        [-f FAST5_SOURCE] [-n REPORT_NAME]
-                        [--output-directory OUTPUT] [-o HTML_REPORT_PATH]
-                        [--data-report-path DATA_REPORT_PATH]
-                        [--images-directory IMAGES_DIRECTORY]
-                        [-d SEQUENCING_SUMMARY_1DSQR_SOURCE] [-b]
-                        [-l BARCODES] [--quiet] [--force] [-h] [--version]
+usage: ToulligQC V2.6 [-a SEQUENCING_SUMMARY_SOURCE] [-t TELEMETRY_SOURCE]
+                      [-f FAST5_SOURCE] [-p POD5_SOURCE] [-q FASTQ] [-u BAM]
+                      [--thread THREAD] [--batch-size BATCH_SIZE] [--qscore-threshold THRESHOLD]
+                      [-n REPORT_NAME] [--output-directory OUTPUT] [-o HTML_REPORT_PATH]
+                      [--data-report-path DATA_REPORT_PATH] 
+                      [--images-directory IMAGES_DIRECTORY]
+                      [-d SEQUENCING_SUMMARY_1DSQR_SOURCE]
+                      [-s SAMPLESHEET]
+                      [-b] [-l BARCODES]
+                      [--quiet] [--force] [-h] [--version]
 
 required arguments:
   -a SEQUENCING_SUMMARY_SOURCE, --sequencing-summary-source SEQUENCING_SUMMARY_SOURCE
@@ -175,6 +202,9 @@ required arguments:
   -f FAST5_SOURCE, --fast5-source FAST5_SOURCE
                         Fast5 file source (necessary if no telemetry file),
                         can also be in a tar.gz/tar.bz2 archive or a directory
+  -p POD5_SOURCE, --pod5-source POD5_SOURCE
+                        pod5 file source (necessary if no telemetry file), 
+                        can also be in a tar.gz/tar.bz2 archive or a directory
   -q FASTQ, --fastq FASTQ
                         FASTQ file (necessary if no sequencing summary file),
                         can also be in a .gz archive
@@ -183,6 +213,8 @@ required arguments:
                         can also be a SAM format
 
 optional arguments:
+  -s SAMPLESHEET, --samplesheet SAMPLESHEET
+                        Samplesheet (.csv file) to fill out sample names in MinKNOW.
   -n REPORT_NAME, --report-name REPORT_NAME
                         Report name
   --output-directory OUTPUT
@@ -197,8 +229,9 @@ optional arguments:
                         Basecaller 1dsq summary source
   -b, --barcoding       Option for barcode usage
   -l BARCODES, --barcodes BARCODES
-                        Coma separated barcode list (e.g.
-                        BC05,RB09,NB01,barcode10)
+                        Comma-separated barcode list (e.g.,
+                        BC05,RB09,NB01,barcode10) or a range separated with ':' (e.g.,
+                        barcode01:barcode19)
   --thread THREAD       Number of threads for parsing FASTQ or BAM files (default: 2).
   --batch-size BATCH_SIZE Batch size for each threads (default: 500).
   --qscore-threshold THRESHOLD Q-score threshold to distinguish between passing filter and
@@ -213,7 +246,41 @@ optional arguments:
  * #### Examples
 
 
-Example with optional arguments:
+* Sequencing summary alone \
+Note that the fowcell ID and run date will be missing from report, found in telemetry file or single fast5 file
+
+```bash
+$ toulligqc --report-name summary_only \
+            --sequencing-summary-source /path/to/basecaller/output/sequencing_summary.txt \
+            --html-report-path /path/to/output/report.html
+```
+* Sequencing summary + telemetry file
+
+```bash
+$ toulligqc --report-name summary_plus_telemetry \
+            --telemetry-source /path/to/basecaller/output/sequencing_telemetry.js \
+            --sequencing-summary-source /path/to/basecaller/output/sequencing_summary.txt \
+            --html-report-path /path/to/output/report.html
+```
+
+* Telemetry file + fast5 files
+
+```bash
+$ toulligqc --report-name telemetry_plus_fast5 \
+            --telemetry-source /path/to/basecaller/output/sequencing_telemetry.js \
+            --fast5-source /path/to/basecaller/output/fast5_files.fast5.gz \ 
+            --html-report-path /path/to/output/report.html
+```
+
+* Fastq/ bam files only
+
+```bash
+$ toulligqc --report-name FAF0256 \
+            --fastq /path/to/basecaller/output/fastq_files.fq.gz \ # (replace with --bam)
+            --html-report-path /path/to/output/report.html
+```
+
+* Optional arguments for 1D² analysis
 
 ```bash
 $ toulligqc --report-name FAF0256 \
@@ -223,7 +290,7 @@ $ toulligqc --report-name FAF0256 \
             --html-report-path /path/to/output/report.html
 ```
 
-Example with optional arguments to deal with barcoded samples:
+* Optional arguments to deal with barcoded samples
 
 ```bash
 $ toulligqc --report-name FAF0256 \
@@ -271,7 +338,7 @@ $ toulligqc \
     --sequencing-summary-source sequencing_summary.txt \
     --sequencing-summary-source barcoding_summary_pass.txt \
     --sequencing-summary-source barcoding_summary_fail.txt \
-    --barcodes                  BC01,BC02,BC03,BC04,BC05,BC07 \
+    --barcodes                  BC01:BC07 \
     --output-directory          output
 ```
 

{toulligqc-2.6 → toulligqc-2.7.1}/setup.py

@@ -14,11 +14,11 @@ setup(
     long_description='See project website for more information.',
 
     # The project's main homepage.
-    url='https://github.com/GenomicParisCentre/toulligQC',
+    url='https://github.com/GenomiqueENS/toulligQC',
 
     # Author details
     author='Genomic Paris Centre team',
-    author_email='toulligqc@biologie.ens.fr',
+    author_email='toulligqc@bio.ens.psl.eu',
 
     license='GPL V3',
     platforms='ALL',
@@ -34,7 +34,7 @@ setup(
         'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',
         'License :: OSI Approved :: CEA CNRS Inria Logiciel Libre License, version 2.1 (CeCILL-2.1)',
 
-        'Programming Language :: Python :: 3.11'
+        'Programming Language :: Python :: 3.12'
     ],
 
     keywords='Nanopore MinION QC report',
@@ -46,10 +46,10 @@ setup(
     include_package_data=True,
 
     python_requires='>=3.11.0',
-    install_requires=['matplotlib>=3.6.3',   'plotly>=5.15.0', 'h5py>=3.7.0',
-                      'pandas>=1.5.3',       'numpy>=1.24.2',  'scipy>=1.10.1',
-                      'scikit-learn>=1.2.1', 'tqdm>=4.64.1',   'pysam>=0.21.0',
-                      'pod5>=0.3.6'],
+    install_requires=['matplotlib>=3.6.3',   'plotly==5.15.0', 'h5py>=3.10.0',
+                      'pandas>=2.1.4',       'numpy>=1.26.4',  'scipy>=1.11.4',
+                      'scikit-learn>=1.4.1', 'tqdm>=4.66.2',   'pysam>=0.22.0',
+                      'pod5>=0.3.10', 'ezcharts==0.7.6'],
 
     entry_points={
         'console_scripts': [

{toulligqc-2.6 → toulligqc-2.7.1}/toulligqc/bam_extractor.py

@@ -64,8 +64,9 @@ class uBAM_Extractor:
         
         # Add missing categories
         if 'barcode_arrangement' in self.dataframe.columns:
-           self.dataframe['barcode_arrangement'].cat.add_categories([0, 'other barcodes', 'passes_filtering'],
-                                                                       inplace=True)
+            self.dataframe['barcode_arrangement'] = self.dataframe['barcode_arrangement'].cat.add_categories([0,
+                                                                                        'other barcodes',
+                                                                                        'passes_filtering'])
         
         # Replace all NaN values by 0 to avoid data manipulation errors when columns are not the same length
         self.dataframe = self.dataframe.fillna(0)
@@ -124,21 +125,29 @@ class uBAM_Extractor:
         add_image_to_result(self.quiet, images, time.time(), pgg.phred_score_over_time(self.dataframe_dict, result_dict, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg.speed_over_time(self.dataframe_dict, self.images_directory))
         if self.is_barcode:
+            if "barcode_alias" in self.config_dictionary:
+                barcode_alias = self.config_dictionary['barcode_alias']
+            else:
+                barcode_alias = None 
             add_image_to_result(self.quiet, images, time.time(), pgg.barcode_percentage_pie_chart_pass(self.dataframe_dict,
                                                                                                        self.barcode_selection,
-                                                                                                       self.images_directory))
+                                                                                                       self.images_directory,
+                                                                                                       barcode_alias))
 
             read_fail = self.dataframe_dict["read.fail.barcoded"]
             if not (len(read_fail) == 1 and read_fail["other barcodes"] == 0):
                 add_image_to_result(self.quiet, images, time.time(), pgg.barcode_percentage_pie_chart_fail(self.dataframe_dict,
                                                                                                       self.barcode_selection,
-                                                                                                      self.images_directory))
+                                                                                                      self.images_directory,
+                                                                                                      barcode_alias))
 
             add_image_to_result(self.quiet, images, time.time(), pgg.barcode_length_boxplot(self.dataframe_dict,
-                                                                                            self.images_directory))
+                                                                                            self.images_directory,
+                                                                                            barcode_alias))
 
             add_image_to_result(self.quiet, images, time.time(), pgg.barcoded_phred_score_frequency(self.dataframe_dict,
-                                                                                                    self.images_directory))
+                                                                                                    self.images_directory,
+                                                                                                    barcode_alias))
         return images
 
 
@@ -271,8 +280,10 @@ class uBAM_Extractor:
         """
         #def process_bam_chunk(bam_chunk):
         rec_data = []
+        record_count = 0
         for rec in uBAM_chunk:
-            rec_dict = self._process_record(rec)
+            record_count += 1
+            rec_dict = self._process_record(rec, record_count)
             rec_data.append(rec_dict)
         return rec_data
 
@@ -290,41 +301,45 @@ class uBAM_Extractor:
 
 
     def _get_header(self):
-        samfile = pysam.AlignmentFile(self.ubam[0], "rb", check_sq=False)
-        header = samfile.header.to_dict()
-        run_id, model_version_id =  extract_headerTag(header,'RG','ID').split('_', 1)
+        sam_file = pysam.AlignmentFile(self.ubam[0], "rb", check_sq=False)
+        header = sam_file.header.to_dict()
+        run_id, model_version_id = extract_headerTag(header, 'RG','ID',
+                                                     'Unknown_Unknown').split('_', 1)
         self.header = {
-        "run_id" : run_id,
-        "run_date" : extract_headerTag(header, 'RG', 'DT'),
-        "sample_id" : extract_headerTag(header,'RG','SM'),
-        "basecaller" : extract_headerTag(header,'PG','PN'),
-        "basecaller_version" : extract_headerTag(header,'PG','VN'),
-        "model_version_id" : model_version_id,
-        "flow_cell_id" : extract_headerTag(header,'RG','PU')
+            "run_id": run_id,
+            "run_date": extract_headerTag(header, 'RG', 'DT', 'Unknown'),
+            "sample_id": extract_headerTag(header, 'RG', 'SM', 'Unknown'),
+            "basecaller": extract_headerTag(header, 'PG', 'PN', 'Unknown'),
+            "basecaller_version": extract_headerTag(header, 'PG', 'VN', 'Unknown'),
+            "model_version_id": model_version_id,
+            "flow_cell_id": extract_headerTag(header, 'RG', 'PU', 'Unknown')
         }
 
-    
-    
-    def _process_record(self, rec):
+
+    def _process_record(self, rec, record_count):
         """
         extract QC info from BAM record
         return : dict of QC info
         """
-        tags = rec.split("\t")
-        tag_dict = defaultdict(lambda:'unclassified')
-        tag_dict.update({key : value for key,_, value in [item.split(':',2) for item in tags[11:]]})
-        start_time = timeISO_to_float(tag_dict['st'], '%Y-%m-%dT%H:%M:%S.%f%z')
-        qual = avg_qual(tags[10]) 
+        fields = rec.split("\t")
+
+        # Parse optional fields
+        attributes = {}
+        for t in fields[11:]:
+            k, t, v = t.split(':', 2)
+            attributes[k] = v
+
+        iso_start_time = attributes.get('st', None)
+        qual = avg_qual(fields[10])
         passes_filtering = True if qual > self.threshold_Qscore else False
         data = [
-            len(tags[9]),
-            qual,
-            passes_filtering,
-            start_time,
-            tag_dict['ch'],
-            tag_dict['du']
+            len(fields[9]), # read length
+            qual, # AVG Qscore
+            passes_filtering, # Passing filter
+            float(record_count) if iso_start_time is None else timeISO_to_float(iso_start_time, '%Y-%m-%dT%H:%M:%S.%f%z'), # start time
+            attributes.get('ch', '1'),  # Channel
+            attributes.get('du', '1')  # Duration
         ]
         if self.is_barcode:
-            bc = tag_dict['BC'].split('_')[-1]
-            data.append(bc)
-        return data
+            data.append(attributes.get('BC', 'unclassified'))
+        return data

{toulligqc-2.6 → toulligqc-2.7.1}/toulligqc/common_statistics.py

@@ -18,7 +18,7 @@ def compute_LXX(dataframe_dict, x):
     cum_sum = 0
     count = 0
     for v in data:
-        cum_sum += v
+        cum_sum += int(v)
         count += 1
         if cum_sum >= half_sum:
             return count
@@ -31,7 +31,7 @@ def compute_NXX(dataframe_dict, x):
     half_sum = data.sum() * x / 100
     cum_sum = 0
     for v in data:
-        cum_sum += v
+        cum_sum += int(v)
         if cum_sum >= half_sum:
             return int(v)
 

{toulligqc-2.6 → toulligqc-2.7.1}/toulligqc/extractor_common.py

@@ -164,16 +164,24 @@ def extract_barcode_info(extractor, result_dict, barcode_selection, dataframe_di
     if "unclassified" not in barcode_selection:
         barcode_selection.append("unclassified")
 
+
+    # If the barcode_arrangement column contains a barcode kit id
+    mask = df['barcode_arrangement'].str.startswith(('SQK', 'VQK'))
+
+    if mask.any():
+        df['barcode_arrangement'] = df['barcode_arrangement'].astype(str)
+        df.loc[mask, 'barcode_arrangement'] = df.loc[mask, 'barcode_arrangement'].str.extract(r'[SV]QK-.+_(.+)$')[0]
+
     # Create keys barcode.arrangement, and read.pass/fail.barcode in dataframe_dict with all values of
     # column barcode_arrangement when reads are passed/failed
-    dataframe_dict["barcode.arrangement"] = df["barcode_arrangement"]
+    dataframe_dict["barcode.arrangement"] = df['barcode_arrangement']
+
 
     # Print warning message if a barcode is unknown
-    barcodes_found = set(dataframe_dict["barcode.arrangement"].unique())
+    barcodes_found = set(df["barcode_arrangement"].unique())
     for element in barcode_selection:
         if element not in barcodes_found and element != 'other barcodes':
-            sys.stderr.write("Warning: The barcode {} doesn't exist in input data\n".format(element))
-
+            sys.stderr.write("\033[93mWarning:\033[0m The barcode {} doesn't exist in input data\n".format(element))
 
     # Get barcodes frequency by Bases
     df_base_pass_barcode = series_cols_boolean_elements(df, ["barcode_arrangement",  "sequence_length"],
@@ -218,6 +226,7 @@ def extract_barcode_info(extractor, result_dict, barcode_selection, dataframe_di
                      (read_fail_barcoded_count / total_reads) * 100)
 
     # Replaces all rows with unused barcodes (ie not in barcode_selection) in column barcode_arrangement with the 'other' value
+
     df.loc[~df['barcode_arrangement'].isin(
         barcode_selection), 'barcode_arrangement'] = 'other barcodes'
 
@@ -423,7 +432,11 @@ def add_image_to_result(quiet, image_list, start_time, image):
 def timeISO_to_float(iso_datetime, format):
         """
         """
-        dt = datetime.strptime(iso_datetime, format)
+        try:
+            dt = datetime.strptime(iso_datetime, format)
+        except:
+            format = '%Y-%m-%dT%H:%M:%SZ'
+            dt = datetime.strptime(iso_datetime, format)
         unix_timestamp = dt.timestamp()
         return unix_timestamp
 

{toulligqc-2.6 → toulligqc-2.7.1}/toulligqc/fastq_bam_common.py

@@ -2,8 +2,23 @@ import multiprocessing as mp
 from tqdm import tqdm
 from concurrent.futures import ProcessPoolExecutor, as_completed
 
-def extract_headerTag(header, tagGroup, tag):
-        return header[tagGroup][0][tag]
+def extract_headerTag(header, tagGroup, tag, defaultValue = None):
+
+    if tagGroup not in header:
+        if defaultValue is not None:
+            return defaultValue
+        else:
+            raise KeyError(tagGroup)
+
+    first_entry = header[tagGroup][0]
+
+    if tag not in first_entry:
+        if defaultValue is not None:
+            return defaultValue
+        else:
+            raise KeyError(tag)
+
+    return first_entry[tag]
 
 
 def batch_iterator(iterator, batch_size):

{toulligqc-2.6 → toulligqc-2.7.1}/toulligqc/fastq_extractor.py

@@ -64,8 +64,9 @@ class fastqExtractor:
 
         # Add missing categories
         if 'barcode_arrangement' in self.dataframe_1d.columns:
-           self.dataframe_1d['barcode_arrangement'].cat.add_categories([0, 'other barcodes', 'passes_filtering'],
-                                                                       inplace=True)
+            self.dataframe_1d['barcode_arrangement'] = self.dataframe_1d['barcode_arrangement'].cat.add_categories([0, 
+                                                                                                    'other barcodes',
+                                                                                                    'passes_filtering'])
         self.dataframe_1d = self.dataframe_1d.fillna(0)
         self.barcode_selection = self.config_dictionary['barcode_selection']
         
@@ -118,32 +119,45 @@ class fastqExtractor:
 
         add_image_to_result(self.quiet, images, time.time(), pgg.read_count_histogram(result_dict, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg.read_length_scatterplot(self.dataframe_dict, self.images_directory))
+
         if self.rich:
             add_image_to_result(self.quiet, images, time.time(), pgg.yield_plot(self.dataframe_1d, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg.read_quality_multiboxplot(self.dataframe_dict, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg.allphred_score_frequency(self.dataframe_dict, self.images_directory))
+
         if self.rich:
             add_image_to_result(self.quiet, images, time.time(), pgg.plot_performance(self.dataframe_1d, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg.twod_density(self.dataframe_dict, self.images_directory))
+
         if self.rich:
             add_image_to_result(self.quiet, images, time.time(), pgg.sequence_length_over_time(self.dataframe_dict, self.images_directory))
             add_image_to_result(self.quiet, images, time.time(), pgg.phred_score_over_time(self.dataframe_dict, result_dict, self.images_directory))
-        if self.is_barcode:
-            add_image_to_result(self.quiet, images, time.time(), pgg.barcode_percentage_pie_chart_pass(self.dataframe_dict,
-                                                                                                       self.barcode_selection,
-                                                                                                       self.images_directory))
 
-            read_fail = self.dataframe_dict["read.fail.barcoded"]
-            if not (len(read_fail) == 1 and read_fail["other barcodes"] == 0):
-                add_image_to_result(self.quiet, images, time.time(), pgg.barcode_percentage_pie_chart_fail(self.dataframe_dict,
-                                                                                                      self.barcode_selection,
-                                                                                                      self.images_directory))
-
-            add_image_to_result(self.quiet, images, time.time(), pgg.barcode_length_boxplot(self.dataframe_dict,
-                                                                                            self.images_directory))
-
-            add_image_to_result(self.quiet, images, time.time(), pgg.barcoded_phred_score_frequency(self.dataframe_dict,
-                                                                                                    self.images_directory))
+            if self.is_barcode:
+                if "barcode_alias" in self.config_dictionary:
+                    barcode_alias = self.config_dictionary['barcode_alias']
+                else:
+                    barcode_alias = None
+
+                add_image_to_result(self.quiet, images, time.time(), pgg.barcode_percentage_pie_chart_pass(self.dataframe_dict,
+                                                                                                        self.barcode_selection,
+                                                                                                        self.images_directory,
+                                                                                                        barcode_alias))
+
+                read_fail = self.dataframe_dict["read.fail.barcoded"]
+                if not (len(read_fail) == 1 and read_fail["other barcodes"] == 0):
+                    add_image_to_result(self.quiet, images, time.time(), pgg.barcode_percentage_pie_chart_fail(self.dataframe_dict,
+                                                                                                        self.barcode_selection,
+                                                                                                        self.images_directory,
+                                                                                                        barcode_alias))
+
+                add_image_to_result(self.quiet, images, time.time(), pgg.barcode_length_boxplot(self.dataframe_dict,
+                                                                                                self.images_directory,
+                                                                                                barcode_alias))
+
+                add_image_to_result(self.quiet, images, time.time(), pgg.barcoded_phred_score_frequency(self.dataframe_dict,
+                                                                                                        self.images_directory,
+                                                                                                        barcode_alias))
         return images
 
 
@@ -210,7 +224,7 @@ class fastqExtractor:
                       "pass.reads.sequence.length")
         describe_dict(self, result_dict, self.dataframe_dict["fail.reads.sequence.length"],
                       "fail.reads.sequence.length")
-        if self.is_barcode:
+        if self.rich and self.is_barcode:
             extract_barcode_info(self, result_dict,
                                  self.barcode_selection,
                                  self.dataframe_dict,
@@ -257,8 +271,9 @@ class fastqExtractor:
         columns = ['sequence_length', 'mean_qscore', 'passes_filtering']
         if self.rich:
             columns.extend(['start_time', 'channel'])
-        if self.is_barcode:
-            columns.append('barcode_arrangement')
+
+            if self.is_barcode:
+                columns.append('barcode_arrangement')
 
         fq_df = pd.DataFrame(fq_df, columns=columns)
 
@@ -270,8 +285,10 @@ class fastqExtractor:
             fq_df["start_time"] = fq_df["start_time"] - fq_df["start_time"].min()
             fq_df['start_time'] = fq_df['start_time'].astype(np.float64)
             fq_df['channel'] = fq_df['channel'].astype(np.int16)
-        if self.is_barcode:
-            fq_df['barcode_arrangement'] = fq_df['barcode_arrangement'].astype("category")
+
+            if self.is_barcode:
+                fq_df['barcode_arrangement'] = fq_df['barcode_arrangement'].astype("category")
+
         return fq_df 
 
 
@@ -326,9 +343,10 @@ class fastqExtractor:
                     fastq_lines.append((len(read[1]), qscore, passes_filtering, start_time, ch))
         else:
             for read in read_batch:
-                qscore = avg_qual(read)
-                passes_filtering = True if qscore > self.threshold_Qscore else False
-                fastq_lines.append((len(read), qscore, passes_filtering))
+                if len(read)>0:
+                    qscore = avg_qual(read)
+                    passes_filtering = True if qscore > self.threshold_Qscore else False
+                    fastq_lines.append((len(read), qscore, passes_filtering))
         return fastq_lines
 
 
@@ -344,8 +362,11 @@ class fastqExtractor:
             self.is_barcode = False
         if 'model_version_id' not in metadata:
                 metadata['model_version_id'] = 'Unknow'
+        run_info = []
         try:
-            return metadata['runid'] , metadata['sampleid'] , metadata['model_version_id'] 
+           sample_id = 'sample_id' if 'sample_id' in metadata else 'sampleid'
+           run_id = 'run_id' if 'run_id' in metadata else 'runid'
+           return metadata[run_id] , metadata[sample_id] , metadata['model_version_id'] 
         except:
             return None
 
@@ -354,7 +375,7 @@ class fastqExtractor:
         """
         """
         metadata = dict(x.split("=") for x in name.split(" ")[1:])
-        start_time = timeISO_to_float(metadata['start_time'], '%Y-%m-%dT%H:%M:%SZ')
+        start_time = timeISO_to_float(metadata['start_time'],  '%Y-%m-%dT%H:%M:%S.%f%z')
         if self.is_barcode:
             return  start_time, metadata['ch'], metadata['barcode']
         return  start_time, metadata['ch']