levseq 1.2.1__tar.gz → 1.2.6__tar.gz

{levseq-1.2.1/levseq.egg-info → levseq-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: levseq
-Version: 1.2.1
+Version: 1.2.6
 Home-page: https://github.com/fhalab/levseq/
 Author: Yueming Long, Emreay Gursoy, Ariane Mora, Francesca-Zhoufan Li
 Author-email: ylong@caltech.edu
@@ -43,6 +43,7 @@ Requires-Dist: seaborn
 Requires-Dist: scikit-learn
 Requires-Dist: statsmodels
 Requires-Dist: tqdm
+Requires-Dist: biopandas
 
 # Variant Sequencing with Nanopore
 
@@ -53,8 +54,7 @@ Figure 1: Overview of the LevSeq variant sequencing workflow using Nanopore tech
 
 
 - Data to reproduce the results and to test are available on zenodo [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.13694463.svg)](https://doi.org/10.5281/zenodo.13694463)
-
-- A dockerized website and database for labs to locally host and visualize their data: website is available at: https://levseq.caltech.edu/ and code to host locally at: https://github.com/fhalab/LevSeq_VDB/
+- A dockerized website and database for labs to locally host and visualize their data: website is available [here](https://github.com/ArianeMora/LevSeq_vis/) and code to host locally at: https://github.com/fhalab/LevSeq_VDB/
 
 ## Setup
 
@@ -65,76 +65,92 @@ For setting up the experimental side of LevSeq we suggest the following preparat
 
 ## How to Use LevSeq
 
-The wet lab part is detailed in the method section of the paper. 
+The wet lab part is detailed in the method section of the paper or via the [wiki](https://github.com/fhalab/LevSeq/wiki/Experimental-protocols).
 
 Once samples are prepared, the multiplexed sample is used for sequencing, and the sequencing data is stored in the `../data` folder as per the typical Nanopore flow (refer to Nanopore documentation for this).
 
 After sequencing, you can identify variants, demultiplex, and combine with your variant function here! For simple applications, we recommend using the notebook `example/Example.ipynb`.
 
-### Steps of LevSeq:
-
-1. **Basecalling**: This step converts Nanopore's FAST5 files to sequences. For basecalling, we use Nanopore's basecaller, Medaka, which can run in parallel with sequencing (recommended) or afterward.
-
-2. **Demultiplexing**: After sequencing, the reads, stored as bulk FASTQ files, are sorted. During demultiplexing, each read is assigned to its correct plate/well combination and stored as a FASTQ file.
-
-3. **Variant Calling**: For each sample, the consensus sequence is compared to the reference sequence. A variant is called if it differs from the reference sequence. The success of variant calling depends on the number of reads sequenced and their quality.
+### Installation
 
+We aimed to make LevSeq as simple to use as possible, this means you should be able to run it all using pip (note you need `samtools` 
+and `minimap2` installed on your path. However, if you have issues we recommend using the Docker instance! 
+(the pip version doesn't work well with mac M3 but docker does.)
 
-### Installation:
-
-We aimed to make LevSeq as simple to use as possible, this means you should be able to run it all using pip. However, if you have issues we recomend using the Docker instance!
-
-We recommend using command line interface(Terminal) and a conda environment for installation:
-```
-git clone https://github.com/fhalab/LevSeq.git
-```
+We recommend using terminal and a conda environment for installation:
 
 ```
-conda create --name levseq python=3.10 -y
+conda create --name levseq python=3.12 -y
 ```
 
 ```
 conda activate levseq
 ```
 
-From the LevSeq folder, install the package using pip:
-
-```
-pip install levseq
-```
 #### Dependencies 
 
 1. Samtools: https://www.htslib.org/download/ 
 ```
 conda install -c bioconda -c conda-forge samtools
 ```
-or for mac users you can use: `brew install samtools`
+
 
 2. Minimap2: https://github.com/lh3/minimap2
+
 ```
 conda install -c bioconda -c conda-forge minimap2
 ```
-or for mac users you can use: `brew install minimap2`
-Once dependencies are all installed, you can run LevSeq using command line.
-3. GCC version 13 and 14 are both needed
-For Mac M chip users: installation via homebrew
+### Docker Installation (Recommended for full pipeline)  
+For installing the whole pipeline, you'll need to use the docker image. For this, install docker as required for your 
+operating system (https://docs.docker.com/engine/install/).
+
+### Usage
+
+#### Run via pip
+```
+levseq <name of the run you can make this whatever> <location to data folder> <location of reference csv file>
+```
+
+#### Run via docker
+If using linux system
 ```
-brew install gcc@14
-brew install gcc@13
+docker pull yueminglong/levseq:levseq-1.2.5-x86
 ```
-For Linux users: installation via conda 
+If using Mac M chips (image tested on M1, M3, and M4)
 ```
-conda install conda-forge::gcc=14
-conda install conda-forge::gcc=13
+docker pull yueminglong/levseq:levseq-1.2.5-arm64
 ```
 
-### Usage
-#### Command Line Interface
-LevSeq can be run using the command line interface. Here's the basic structure of the command:
-
 ```
-levseq <name of the run you can make this whatever> <location to data folder> <location of reference csv file>
+docker run --rm -v "$(pwd):/levseq_results" yueminglong/levseq:levseq-1.2.5-<architecture> <name> <location to data folder> <location of reference csv file>
 ```
+Explanation:
+
+--rm: Automatically removes the container after the command finishes.
+
+-v "$(pwd):/levseq\_results": Mounts the current directory ($(pwd)) to /levseq\_results inside the container, ensuring the results are saved to your current directory.
+
+yueminglong/levseq:levseq-1.2.5-\<architecture\>: Specifies the Docker image to run. Replace \<architecture\> with the appropriate platform (e.g., x86).
+
+\<name\>: The name or identifier for the analysis.
+
+\<location to data folder\>: Path to the folder containing input data.
+
+\<location of reference csv file\>: Path to the reference .csv file.
+
+Important Notes:
+
+If the current directory is mounted to the container (via -v "$(pwd):/levseq\_results"), the basecalled result in FASTQ format and the ref.csv file must be located in the current directory.
+
+If these files are not present in the current directory, they will not be processed by the tool.
+
+Output:
+
+The results of the analysis will be saved to your current working directory.
+
+See the [manuscrtipt notebook](https://github.com/fhalab/LevSeq/blob/main/manuscript/notebooks/epPCR_10plates.ipynb) for an example.
+*Note: if using docker, the html and csv final output will be saved in the directory that you are running from instead of in the Platemaps or Results subfolder.
+
 #### Required Arguments
 1. Name of the experiment, this will be the name of the output folder
 2. Location of basecalled fastq files, this is the direct output from using the MinKnow software for sequencing
@@ -149,37 +165,10 @@ levseq <name of the run you can make this whatever> <location to data folder> <l
 
 --show\_msa Showing multiple sequence alignment for each well
 
-### Docker Installation (Recommended for full pipeline)  
-For installing the whole pipeline, you'll need to use the docker image. For this, install docker as required for your 
-operating system (https://docs.docker.com/engine/install/).
-
-
-To build the docker image run (within the main folder that contains the `Dockerfile`). Note building does **not** work 
-on Mac M3 chip, please use a ubuntu machine to build the docker image!
-
-```
-docker build -t levseq .
-```
-
-This gives us the access to the lebSeq command line interface via:
-
-```
-docker run levseq
-```
-Note! The docker image should work with linux, and mac, however, different mac architectures may have issues (owing to the different M1/M3 processers.)
-
-Basically the -v connects a folder on your computer with the output from the minION sequencer with the docker image that will take these results and then perform 
-demultiplexing and variant calling.
-
-docker run -v /disk1/ariane/vscode/LevSeq/manuscript/Data/20241116-YL-LevSeq-parlqep400-1-2-P25-28:/levseq_results/ levseq docker-test levseq_results/ levseq_results/LevSeq-T1.csv
-```
- docker run -v /Users/XXXX/Documents/LevSeq/data:/levseq_results/ levseq 20240502 levseq_results/20240502/ levseq_results/20240502-YL-ParLQ-ep2.csv
-```
-
-In this command: `/Users/XXXX/Documents/LevSeq/data` is a folder on your computer, which contains a subfolder `20240502` 
+Great you should be all done!
 
-### Issues and Troubleshooting
+For more details or trouble shooting please look at our [computational_protocols](https://github.com/fhalab/LevSeq/wiki/Computational-protocols).
 
-If you have any issues, please check the LevSeq\_error.log find in the output direectory and report the issue. If the problem persists, please open an issue on the GitHub repository with the error details.
+#### Citing
 
-If you solve something code wise, submit a pull request! We would love community input.
+If you have found LevSeq useful, please cite out [paper](https://doi.org/10.1101/2024.09.04.611255).

levseq-1.2.6/README.md

@@ -0,0 +1,127 @@
+# Variant Sequencing with Nanopore
+
+In directed evolution, sequencing every variant enhances data insight and creates datasets suitable for AI/ML methods. This method is presented as an extension of the original Every Variant Sequencer using Illumina technology. With this approach, sequence variants can be generated within a day at an extremely low cost.
+
+![Figure 1: LevSeq Workflow](manuscript/figures/LevSeq_Figure-1.png)
+Figure 1: Overview of the LevSeq variant sequencing workflow using Nanopore technology. This diagram illustrates the key steps in the process, from sample preparation to data analysis and visualization.
+
+
+- Data to reproduce the results and to test are available on zenodo [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.13694463.svg)](https://doi.org/10.5281/zenodo.13694463)
+- A dockerized website and database for labs to locally host and visualize their data: website is available [here](https://github.com/ArianeMora/LevSeq_vis/) and code to host locally at: https://github.com/fhalab/LevSeq_VDB/
+
+## Setup
+
+For setting up the experimental side of LevSeq we suggest the following preparations:
+
+- Order forward and reverse primers compatible with the desired plasmid, see methods section of [our paper](http://biorxiv.org/cgi/content/short/2024.09.04.611255v1?rss=1).
+- Successfully install Oxford Nanopore's software (this is only for if you are doing basecalling/minION processing). [Link to installation guide](https://nanoporetech.com/).
+
+## How to Use LevSeq
+
+The wet lab part is detailed in the method section of the paper or via the [wiki](https://github.com/fhalab/LevSeq/wiki/Experimental-protocols).
+
+Once samples are prepared, the multiplexed sample is used for sequencing, and the sequencing data is stored in the `../data` folder as per the typical Nanopore flow (refer to Nanopore documentation for this).
+
+After sequencing, you can identify variants, demultiplex, and combine with your variant function here! For simple applications, we recommend using the notebook `example/Example.ipynb`.
+
+### Installation
+
+We aimed to make LevSeq as simple to use as possible, this means you should be able to run it all using pip (note you need `samtools` 
+and `minimap2` installed on your path. However, if you have issues we recommend using the Docker instance! 
+(the pip version doesn't work well with mac M3 but docker does.)
+
+We recommend using terminal and a conda environment for installation:
+
+```
+conda create --name levseq python=3.12 -y
+```
+
+```
+conda activate levseq
+```
+
+#### Dependencies 
+
+1. Samtools: https://www.htslib.org/download/ 
+```
+conda install -c bioconda -c conda-forge samtools
+```
+
+
+2. Minimap2: https://github.com/lh3/minimap2
+
+```
+conda install -c bioconda -c conda-forge minimap2
+```
+### Docker Installation (Recommended for full pipeline)  
+For installing the whole pipeline, you'll need to use the docker image. For this, install docker as required for your 
+operating system (https://docs.docker.com/engine/install/).
+
+### Usage
+
+#### Run via pip
+```
+levseq <name of the run you can make this whatever> <location to data folder> <location of reference csv file>
+```
+
+#### Run via docker
+If using linux system
+```
+docker pull yueminglong/levseq:levseq-1.2.5-x86
+```
+If using Mac M chips (image tested on M1, M3, and M4)
+```
+docker pull yueminglong/levseq:levseq-1.2.5-arm64
+```
+
+```
+docker run --rm -v "$(pwd):/levseq_results" yueminglong/levseq:levseq-1.2.5-<architecture> <name> <location to data folder> <location of reference csv file>
+```
+Explanation:
+
+--rm: Automatically removes the container after the command finishes.
+
+-v "$(pwd):/levseq\_results": Mounts the current directory ($(pwd)) to /levseq\_results inside the container, ensuring the results are saved to your current directory.
+
+yueminglong/levseq:levseq-1.2.5-\<architecture\>: Specifies the Docker image to run. Replace \<architecture\> with the appropriate platform (e.g., x86).
+
+\<name\>: The name or identifier for the analysis.
+
+\<location to data folder\>: Path to the folder containing input data.
+
+\<location of reference csv file\>: Path to the reference .csv file.
+
+Important Notes:
+
+If the current directory is mounted to the container (via -v "$(pwd):/levseq\_results"), the basecalled result in FASTQ format and the ref.csv file must be located in the current directory.
+
+If these files are not present in the current directory, they will not be processed by the tool.
+
+Output:
+
+The results of the analysis will be saved to your current working directory.
+
+See the [manuscrtipt notebook](https://github.com/fhalab/LevSeq/blob/main/manuscript/notebooks/epPCR_10plates.ipynb) for an example.
+*Note: if using docker, the html and csv final output will be saved in the directory that you are running from instead of in the Platemaps or Results subfolder.
+
+#### Required Arguments
+1. Name of the experiment, this will be the name of the output folder
+2. Location of basecalled fastq files, this is the direct output from using the MinKnow software for sequencing
+3. Location of reference csv file, this file includes information of barcodes used for each plate and the DNA sequence used for reference for each plate
+
+#### Optional Arguments
+--skip\_demultiplexing If enabled, demultiplexing step will be skipped 
+
+--skip\_variantcalling If enabled, variant valling step will be skipped 
+
+--output Save location for output, if not provided default to where the program is executed
+
+--show\_msa Showing multiple sequence alignment for each well
+
+Great you should be all done!
+
+For more details or trouble shooting please look at our [computational_protocols](https://github.com/fhalab/LevSeq/wiki/Computational-protocols).
+
+#### Citing
+
+If you have found LevSeq useful, please cite out [paper](https://doi.org/10.1101/2024.09.04.611255).

{levseq-1.2.1 → levseq-1.2.6}/levseq/__init__.py

@@ -18,7 +18,7 @@
 __title__ = 'levseq'
 __description__ = 'LevSeq nanopore sequencing'
 __url__ = 'https://github.com/fhalab/levseq/'
-__version__ = '1.2.1'
+__version__ = '1.2.6'
 __author__ = 'Yueming Long, Emreay Gursoy, Ariane Mora, Francesca-Zhoufan Li'
 __author_email__ = 'ylong@caltech.edu'
 __license__ = 'GPL3'

levseq-1.2.6/levseq/coordinates.py

@@ -0,0 +1,76 @@
+import esm
+import torch
+import pandas as pd
+from sklearn.decomposition import PCA
+import os
+import argparse
+
+def preprocess_sequence(sequence):
+    """
+    Preprocesses the amino acid sequence by removing everything after the first '*' (stop codon).
+    """
+    if '*' in sequence:
+        sequence = sequence.split('*')[0]  # Take everything before the first '*'
+    return sequence
+
+def process_file(input_file, output_file=None):
+    # Load the dataset
+    data = pd.read_csv(input_file)
+
+    # Remove the "Unnamed: 0" column if it exists
+    if 'Unnamed: 0' in data.columns:
+        data = data.drop(columns=['Unnamed: 0'])
+
+    # Create the ID column as the combination of `Plate` and `Well`
+    data['ID'] = data['Plate'] + '-' + data['Well']
+    data = data[['ID'] + [col for col in data.columns if col != 'ID']]  # Reorder to make ID the first column
+
+    # Filter valid sequences from the `aa_sequence` column
+    valid_sequences = data['aa_sequence'].dropna()
+    valid_sequences = valid_sequences[~valid_sequences.str.contains('#N.A.#|Deletion')]
+
+    # Preprocess sequences to handle stop codons
+    valid_sequences = valid_sequences.apply(preprocess_sequence)
+
+    # Load the ESM-2 model
+    model, alphabet = esm.pretrained.esm2_t33_650M_UR50D()
+    batch_converter = alphabet.get_batch_converter()
+
+    # Prepare sequences for embedding
+    sequences = valid_sequences.tolist()
+    sequence_names = [f"Sequence {i}" for i in range(len(sequences))]
+    batch_labels, batch_strs, batch_tokens = batch_converter(list(zip(sequence_names, sequences)))
+
+    # Extract embeddings
+    with torch.no_grad():
+        results = model(batch_tokens, repr_layers=[33])
+        embeddings = results["representations"][33]  # Use the top (last) layer representations
+
+    # Average embeddings across residues for sequence-level representation
+    sequence_embeddings = embeddings.mean(1).numpy()
+
+    # Dimensionality Reduction using PCA
+    pca = PCA(n_components=2)
+    xy_coordinates = pca.fit_transform(sequence_embeddings)
+
+    # Add x, y coordinates back to the dataframe
+    xy_df = pd.DataFrame(xy_coordinates, columns=['x_coordinate', 'y_coordinate'], index=valid_sequences.index)
+    data = pd.concat([data, xy_df], axis=1)
+
+    # Determine output file location
+    if output_file is None:
+        input_name, input_ext = os.path.splitext(input_file)
+        output_file = f"{input_name}_xy{input_ext}"
+
+    # Save the updated dataframe to a file
+    data.to_csv(output_file, index=False)
+    print(f"Processed data with x, y coordinates saved to: {output_file}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Generate x, y coordinates for amino acid sequences")
+    parser.add_argument('input_file', type=str, help="Path to the input CSV file")
+    parser.add_argument('--output_file', type=str, default=None, help="Path to save the output CSV file (optional)")
+    args = parser.parse_args()
+
+    process_file(args.input_file, args.output_file)
+

{levseq-1.2.1 → levseq-1.2.6}/levseq/run_levseq.py

@@ -243,6 +243,19 @@ def call_variant(experiment_name, experiment_folder, template_fasta, filtered_ba
     except Exception as e:
         logging.error("Variant calling failed", exc_info=True)
         raise
+
+def assign_alignment_probability(row):
+    if row["Variant"] == "#PARENT#":
+        if row["Alignment Count"] > 20:
+            return 1
+        elif 10 <= row["Alignment Count"] <= 20:
+            return (row["Alignment Count"] - 10) / 10  # Ranges from 0 to 1 linearly
+        else:
+            return 0
+    else:
+        return row["Average mutation frequency"]
+
+
 # Full version of create_df_v function
 def create_df_v(variants_df):
     # Make copy of dataframe
@@ -258,28 +271,19 @@ def create_df_v(variants_df):
 
     # Translate nc_variant to aa_variant
     df_variants_["aa_variant"] = df_variants_["nc_variant"].apply(
-    lambda x: x if x in ["Deletion", "#N.A.#"] else translate(x)
+        lambda x: x if x in ["Deletion", "#N.A.#", 'Insertion'] else translate(x)
     )
     # Fill in 'Deletion' in 'aa_variant' column
     df_variants_.loc[
         df_variants_["nc_variant"] == "Deletion", "aa_variant"
     ] = "Deletion"
+    df_variants_.loc[
+        df_variants_["nc_variant"] == "Insertion", "aa_variant"
+    ] = "Insertion"
 
     # Compare aa_variant with translated refseq and generate Substitutions column
     df_variants_["Substitutions"] = df_variants_.apply(get_mutations, axis=1)
-
     # Adding sequence quality to Alignment Probability before filling in empty values
-    def assign_alignment_probability(row):
-        if row["Variant"] == "#PARENT#":
-            if row["Alignment Count"] > 20:
-                return 1
-            elif 10 <= row["Alignment Count"] <= 20:
-                return (row["Alignment Count"] - 10) / 10  # Ranges from 0 to 1 linearly
-            else:
-                return 0
-        else:
-            return row["Average mutation frequency"]
-
     df_variants_["Alignment Probability"] = df_variants_.apply(assign_alignment_probability, axis=1)
     df_variants_["Alignment Probability"] = df_variants_["Alignment Probability"].fillna(0.0)
     df_variants_["Alignment Count"] = df_variants_["Alignment Count"].fillna(0.0)
@@ -291,7 +295,9 @@ def create_df_v(variants_df):
         elif df_variants_["nc_variant"].iloc[i] == "#N.A.#":
             df_variants_.Substitutions.iat[i] = "#N.A.#"
 
-    
+    # Low read counts override low mutations
+    df_variants_["Substitutions"] = ["#LOW#" if a < 10 and a > 0 else s for a, s in df_variants_[["Alignment Count", "Substitutions"]].values]
+
     # Add row and columns
     Well = df_variants_["Well"].tolist()
     row = []
@@ -315,32 +321,36 @@ def create_df_v(variants_df):
     df_variants_["Plate"] = df_variants_["Plate"].apply(
         lambda x: f"0{x}" if len(x) == 1 else x
     )
-    # Rename columns as per the request
+
+    # First rename columns as before
     df_variants_.rename(columns={
-	"Variant": "nucleotide_mutation",
-	"Substitutions": "amino-acid_substitutions",
-	"nc_variant": "nt_sequence",
-	"aa_variant": "aa_sequence"
-	}, inplace=True)
-
-
-	# Select the desired columns in the desired order
-    restructured_df = df_variants_[
-            [
-                    "barcode_plate",
-                    "Plate",
-                    "Well",
-                    "Alignment Count",
-                    "nucleotide_mutation",
-                    "amino-acid_substitutions",
-                    "Alignment Probability",
-                    "Average mutation frequency",
-                    "P value",
-                    "P adj. value",
-                    "nt_sequence",
-                    "aa_sequence",
-            ]
-    ]
+        "Variant": "nucleotide_mutation",
+        "Substitutions": "amino_acid_substitutions",
+        "nc_variant": "nt_sequence",
+        "aa_variant": "aa_sequence"
+        }, inplace=True)
+
+    # Create a copy for restructuring to avoid affecting the original
+    restructured_df = df_variants_.copy()
+    restructured_df.columns = restructured_df.columns.str.lower().str.replace('[\s-]', '_', regex=True)
+    # Fix the specific column name
+    restructured_df.columns = restructured_df.columns.str.replace('p_adj._value', 'p_adj_value')
+
+    # Select the desired columns in the desired order
+    restructured_df = restructured_df[[
+        "barcode_plate",
+        "plate",
+        "well",
+        "alignment_count",
+        "nucleotide_mutation",
+        "amino_acid_substitutions",
+        "alignment_probability",
+        "average_mutation_frequency",
+        "p_value",
+        "p_adj_value",
+        "nt_sequence",
+        "aa_sequence"
+    ]]
 
     return restructured_df, df_variants_
 
@@ -354,16 +364,21 @@ def create_nc_variant(variant, refseq):
         return refseq
     elif "DEL" in variant:
         return "Deletion"
+    elif variant == '+':
+        return "Insertion"
     else:
         mutations = variant.split("_")
         nc_variant = list(refseq)
         for mutation in mutations:
-            if len(mutation) >= 2:
+            try:
                 position = int(re.findall(r"\d+", mutation)[0]) - 1
                 original = mutation[0]
                 new = mutation[-1]
-            if position < len(nc_variant) and nc_variant[position] == original:
-                nc_variant[position] = new
+                if position < len(nc_variant) and nc_variant[position] == original:
+                    nc_variant[position] = new
+            except:
+                print('WARNING! UNABLE TO PROCESS THIS')
+                print(mutation)
         return "".join(nc_variant)
 
 
@@ -377,7 +392,9 @@ def get_mutations(row):
         # Check if alignment_count is zero and return "#N.A.#" if true
         if alignment_count == 0:
             return "#N.A.#"
-        
+        if alignment_count <= 10:
+            return "#LOW#"
+
         refseq = row["refseq"]
 
         if not is_valid_dna_sequence(refseq):
@@ -395,10 +412,7 @@ def get_mutations(row):
                     if refseq_aa[i] != variant_aa[i]:
                         mutations.append(f"{refseq_aa[i]}{i+1}{variant_aa[i]}")
                 if not mutations:
-                    if alignment_count < 15:
-                        return "#N.A.#"
-                    else:
-                        return "#PARENT#"
+                    return "#PARENT#"
             else:
                 return "LEN"
         return "_".join(mutations) if mutations else ""
@@ -433,10 +447,7 @@ def process_ref_csv(cl_args, tqdm_fn=tqdm.tqdm):
     result_folder = create_result_folder(cl_args)
     variant_csv_path = os.path.join(result_folder, "variants.csv")
 
-    if os.path.exists(variant_csv_path):
-        variant_df = pd.read_csv(variant_csv_path)
-    else:
-        variant_df = pd.DataFrame(columns=["barcode_plate", "name", "refseq", "variant"])
+    variant_df = pd.DataFrame(columns=["barcode_plate", "name", "refseq", "variant"])
     
     for i, row in tqdm_fn(ref_df.iterrows(), total=len(ref_df), desc="Processing Samples"):
         barcode_plate = row["barcode_plate"]
@@ -456,9 +467,9 @@ def process_ref_csv(cl_args, tqdm_fn=tqdm.tqdm):
         barcode_path = filter_bc(cl_args, name_folder, i)
         output_dir = Path(result_folder) / "basecalled_reads"
         output_dir.mkdir(parents=True, exist_ok=True)
-        file_to_fastq = cat_fastq_files(cl_args.get("path"), output_dir)
 
         if not cl_args["skip_demultiplexing"]:
+            file_to_fastq = cat_fastq_files(cl_args.get("path"), output_dir)
             try:
                 demux_fastq(output_dir, name_folder, barcode_path)
             except Exception as e: