levseq 1.3.3__tar.gz → 1.4.1__tar.gz

levseq-1.4.1/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.1
+Name: levseq
+Version: 1.4.1
+Home-page: https://github.com/fhalab/levseq/
+Author: Yueming Long, Ariane Mora, Francesca-Zhoufan Li, Emre Gursoy
+Author-email: ylong@caltech.edu
+License: GPL3
+Project-URL: Bug Tracker, https://github.com/fhalab/levseq/
+Project-URL: Documentation, https://github.com/fhalab/levseq/
+Project-URL: Source Code, https://github.com/fhalab/levseq/
+Keywords: Nanopore,ONT,evSeq
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Bio
+Requires-Dist: biopython
+Requires-Dist: fsspec
+Requires-Dist: h5py
+Requires-Dist: holoviews
+Requires-Dist: jupyterlab
+Requires-Dist: mappy
+Requires-Dist: matplotlib
+Requires-Dist: ninetysix
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: pybedtools
+Requires-Dist: pycoQC
+Requires-Dist: pyfaidx
+Requires-Dist: pyparsing
+Requires-Dist: pysam
+Requires-Dist: scipy
+Requires-Dist: sciutil
+Requires-Dist: seaborn
+Requires-Dist: scikit-learn
+Requires-Dist: statsmodels
+Requires-Dist: tqdm
+Requires-Dist: biopandas
+
+# Variant Sequencing with Nanopore (LevSeq)
+
+LevSeq provides a streamlined pipeline for sequencing and analyzing genetic variants using Oxford Nanopore technology. In directed evolution experiments, LevSeq enables sequencing of every variant, enhancing data insight and creating datasets suitable for AI/ML methods. Sequence variants can be generated within a day at an extremely low cost.
+
+![Figure 1: LevSeq Workflow](manuscript/figures/LevSeq_Figure-1.jpeg)
+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.
+
+## Quick Start
+
+### Docker Installation (Recommended)
+
+1. Install Docker: [https://docs.docker.com/engine/install/](https://docs.docker.com/engine/install/)
+2. Pull the appropriate image:
+   ```bash
+   # For Linux/Windows x86 systems:
+   docker pull yueminglong/levseq:levseq-1.4-x86
+   
+   # For Mac M-series chips (M1, M2, M3, M4):
+   docker pull yueminglong/levseq:levseq-1.4-arm64
+   ```
+3. Run LevSeq:
+   ```bash
+   docker run --rm -v "/full/path/to/data:/levseq_results" yueminglong/levseq:levseq-1.4-arm64 my_experiment levseq_results/ levseq_results/ref.csv
+   ```
+
+### Pip Installation (Mac/Linux only)
+
+**IMPORTANT**: On Mac M-series chips (M1-M4), gcc 13 and 14 are **REQUIRED**:
+```bash
+brew install gcc@13 gcc@14
+```
+
+1. Create and activate conda environment:
+   ```bash
+   conda create --name levseq python=3.12 -y
+   conda activate levseq
+   ```
+
+2. Install dependencies:
+   ```bash
+   conda install -c bioconda -c conda-forge samtools minimap2
+   ```
+
+3. Install LevSeq:
+   ```bash
+   pip install levseq
+   ```
+
+4. Run LevSeq:
+   ```bash
+   levseq my_experiment /path/to/data/ /path/to/ref.csv
+   ```
+
+## Data and Visualization
+
+- **Test Data**: Sample data is available on Zenodo [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.13694463.svg)](https://doi.org/10.5281/zenodo.13694463)
+- **Visualization Tool**: A web application is available at [https://levseqdb.streamlit.app/](https://levseqdb.streamlit.app/) - simply upload your LevSeq output and LCMS results
+- **Self-hosted Solution**: You can deploy your own instance using our [LevSeq_db repository](https://github.com/fhalab/LevSeq_db)
+
+## Reference File Format (ref.csv)
+
+Your reference CSV file must contain the following columns:
+
+| barcode_plate | name   | refseq    |
+|---------------|--------|-----------|
+| 33            | Q97A76 | ATGCGC... |
+
+For oligopool experiments (multiple proteins per plate), use:
+
+| barcode_plate | name   | refseq    |
+|---------------|--------|-----------|
+| 33            | Q97A76 | ATGCGCAAG |
+| 33            | P96084 | ATGGATCA  |
+| 34            | P46209 | ATGGGGCAA |
+| 34            | Q60336 | ATGGGGCC  |
+
+## Command Line Arguments
+
+### Required Arguments
+1. **name**: Name of the experiment (output folder)
+2. **path**: Location of basecalled fastq files
+3. **summary**: Path to reference CSV file
+
+### Optional Arguments
+- `--skip_demultiplexing`: Skip the demultiplexing step
+- `--skip_variantcalling`: Skip the variant calling step
+- `--output`: Custom save location (defaults to current directory)
+- `--show_msa`: Show multiple sequence alignment for each well
+- `--oligopool`: Process data as oligopool experiment
+
+## Step-by-Step Tutorial
+
+1. **Prepare your sequencing data**:
+   - Your fastq files should be in a directory structure similar to Nanopore's output
+   - Prepare a reference CSV file with barcode plates, sample names, and reference sequences
+
+2. **Run LevSeq**:
+   ```bash
+   # Via Docker
+   docker run --rm -v "/path/to/data:/levseq_results" yueminglong/levseq:levseq-1.4-arm64 my_experiment levseq_results/ levseq_results/ref.csv
+   
+   # Via pip
+   levseq my_experiment /path/to/data/ /path/to/ref.csv
+   ```
+
+3. **Analyze results**:
+   - Output includes variant data (CSV) and interactive visualizations (HTML)
+   - Upload results to the LevSeq visualization tool for further analysis
+
+## Experimental Setup
+
+For the wet lab protocol:
+- Refer to the [wiki](https://github.com/fhalab/LevSeq/wiki/Experimental-protocols)
+- See the methods section of [our paper](https://pubs.acs.org/doi/10.1021/acssynbio.4c00625)
+- Order forward and reverse primers compatible with your plasmid
+- Install Oxford Nanopore's software for basecalling if needed
+
+## Additional Resources
+
+- **Example Notebook**: See `example/Example.ipynb` for a walkthrough
+- **Advanced Usage**: See the [manuscript notebook](https://github.com/fhalab/LevSeq/blob/main/manuscript/notebooks/epPCR_10plates.ipynb)
+- **Troubleshooting**: See our [computational protocols wiki](https://github.com/fhalab/LevSeq/wiki/Computational-protocols)
+
+## Citing LevSeq
+
+If you find LevSeq useful, please cite our paper:
+
+```bibtex
+@article{long2024levseq,
+  title={LevSeq: Rapid Generation of Sequence-Function Data for Directed Evolution and Machine Learning},
+  author={Long, Yueming and Mora, Ariane and Li, Francesca-Zhoufan and Gürsoy, Emre and Johnston, Kadina E and Arnold, Frances H},
+  journal={ACS Synthetic Biology},
+  year={2024},
+  publisher={American Chemical Society}
+}
+```
+
+## Contact
+
+Leave a feature request in the issues or reach us via [email](mailto:levseqdb@gmail.com).

levseq-1.4.1/README.md

@@ -0,0 +1,140 @@
+# Variant Sequencing with Nanopore (LevSeq)
+
+LevSeq provides a streamlined pipeline for sequencing and analyzing genetic variants using Oxford Nanopore technology. In directed evolution experiments, LevSeq enables sequencing of every variant, enhancing data insight and creating datasets suitable for AI/ML methods. Sequence variants can be generated within a day at an extremely low cost.
+
+![Figure 1: LevSeq Workflow](manuscript/figures/LevSeq_Figure-1.jpeg)
+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.
+
+## Quick Start
+
+### Docker Installation (Recommended)
+
+1. Install Docker: [https://docs.docker.com/engine/install/](https://docs.docker.com/engine/install/)
+2. Pull the appropriate image:
+   ```bash
+   # For Linux/Windows x86 systems:
+   docker pull yueminglong/levseq:levseq-1.4-x86
+   
+   # For Mac M-series chips (M1, M2, M3, M4):
+   docker pull yueminglong/levseq:levseq-1.4-arm64
+   ```
+3. Run LevSeq:
+   ```bash
+   docker run --rm -v "/full/path/to/data:/levseq_results" yueminglong/levseq:levseq-1.4-arm64 my_experiment levseq_results/ levseq_results/ref.csv
+   ```
+
+### Pip Installation (Mac/Linux only)
+
+**IMPORTANT**: On Mac M-series chips (M1-M4), gcc 13 and 14 are **REQUIRED**:
+```bash
+brew install gcc@13 gcc@14
+```
+
+1. Create and activate conda environment:
+   ```bash
+   conda create --name levseq python=3.12 -y
+   conda activate levseq
+   ```
+
+2. Install dependencies:
+   ```bash
+   conda install -c bioconda -c conda-forge samtools minimap2
+   ```
+
+3. Install LevSeq:
+   ```bash
+   pip install levseq
+   ```
+
+4. Run LevSeq:
+   ```bash
+   levseq my_experiment /path/to/data/ /path/to/ref.csv
+   ```
+
+## Data and Visualization
+
+- **Test Data**: Sample data is available on Zenodo [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.13694463.svg)](https://doi.org/10.5281/zenodo.13694463)
+- **Visualization Tool**: A web application is available at [https://levseqdb.streamlit.app/](https://levseqdb.streamlit.app/) - simply upload your LevSeq output and LCMS results
+- **Self-hosted Solution**: You can deploy your own instance using our [LevSeq_db repository](https://github.com/fhalab/LevSeq_db)
+
+## Reference File Format (ref.csv)
+
+Your reference CSV file must contain the following columns:
+
+| barcode_plate | name   | refseq    |
+|---------------|--------|-----------|
+| 33            | Q97A76 | ATGCGC... |
+
+For oligopool experiments (multiple proteins per plate), use:
+
+| barcode_plate | name   | refseq    |
+|---------------|--------|-----------|
+| 33            | Q97A76 | ATGCGCAAG |
+| 33            | P96084 | ATGGATCA  |
+| 34            | P46209 | ATGGGGCAA |
+| 34            | Q60336 | ATGGGGCC  |
+
+## Command Line Arguments
+
+### Required Arguments
+1. **name**: Name of the experiment (output folder)
+2. **path**: Location of basecalled fastq files
+3. **summary**: Path to reference CSV file
+
+### Optional Arguments
+- `--skip_demultiplexing`: Skip the demultiplexing step
+- `--skip_variantcalling`: Skip the variant calling step
+- `--output`: Custom save location (defaults to current directory)
+- `--show_msa`: Show multiple sequence alignment for each well
+- `--oligopool`: Process data as oligopool experiment
+
+## Step-by-Step Tutorial
+
+1. **Prepare your sequencing data**:
+   - Your fastq files should be in a directory structure similar to Nanopore's output
+   - Prepare a reference CSV file with barcode plates, sample names, and reference sequences
+
+2. **Run LevSeq**:
+   ```bash
+   # Via Docker
+   docker run --rm -v "/path/to/data:/levseq_results" yueminglong/levseq:levseq-1.4-arm64 my_experiment levseq_results/ levseq_results/ref.csv
+   
+   # Via pip
+   levseq my_experiment /path/to/data/ /path/to/ref.csv
+   ```
+
+3. **Analyze results**:
+   - Output includes variant data (CSV) and interactive visualizations (HTML)
+   - Upload results to the LevSeq visualization tool for further analysis
+
+## Experimental Setup
+
+For the wet lab protocol:
+- Refer to the [wiki](https://github.com/fhalab/LevSeq/wiki/Experimental-protocols)
+- See the methods section of [our paper](https://pubs.acs.org/doi/10.1021/acssynbio.4c00625)
+- Order forward and reverse primers compatible with your plasmid
+- Install Oxford Nanopore's software for basecalling if needed
+
+## Additional Resources
+
+- **Example Notebook**: See `example/Example.ipynb` for a walkthrough
+- **Advanced Usage**: See the [manuscript notebook](https://github.com/fhalab/LevSeq/blob/main/manuscript/notebooks/epPCR_10plates.ipynb)
+- **Troubleshooting**: See our [computational protocols wiki](https://github.com/fhalab/LevSeq/wiki/Computational-protocols)
+
+## Citing LevSeq
+
+If you find LevSeq useful, please cite our paper:
+
+```bibtex
+@article{long2024levseq,
+  title={LevSeq: Rapid Generation of Sequence-Function Data for Directed Evolution and Machine Learning},
+  author={Long, Yueming and Mora, Ariane and Li, Francesca-Zhoufan and Gürsoy, Emre and Johnston, Kadina E and Arnold, Frances H},
+  journal={ACS Synthetic Biology},
+  year={2024},
+  publisher={American Chemical Society}
+}
+```
+
+## Contact
+
+Leave a feature request in the issues or reach us via [email](mailto:levseqdb@gmail.com).

{levseq-1.3.3 → levseq-1.4.1}/levseq/__init__.py

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

{levseq-1.3.3 → levseq-1.4.1}/levseq/interface.py

@@ -63,6 +63,9 @@ def build_cli_parser():
     optional_args_group.add_argument("--skip_variantcalling",
                                      action="store_true",
                                      help="Skip the variant calling step, default is false")
+    optional_args_group.add_argument("--oligopool",
+                                     action="store_true",
+                                     help="Whether this experiment came from an oligopool, default is false.")
     optional_args_group.add_argument("--show_msa",
                                      default=False,
                                      help="Skip showing msa")                                 
@@ -79,7 +82,10 @@ def execute_LevSeq():
     tqdm_fn = tqdm.tqdm
     # Run LevSeq
     try:
+        from levseq import __version__
+        print(f"Starting LevSeq v{__version__}...")
         run_LevSeq(CL_ARGS, tqdm_fn)
+        print(f"Run completed successfully. Results and logs stored in {os.path.join(CL_ARGS.get('output', CWD), CL_ARGS.get('name', ''))}")
     except Exception as e:
-        print(e)
-    print("Run Complete, add log info")
+        print(f"Error: {e}")
+        print(f"Check error logs for details in {os.path.join(CL_ARGS.get('output', CWD), CL_ARGS.get('name', ''))}")

{levseq-1.3.3 → levseq-1.4.1}/levseq/run_levseq.py

@@ -66,8 +66,14 @@ from importlib import resources
 from holoviews.streams import Tap
 
 # Utility function to configure logging
-def configure_logging(result_folder):
-    log_format = "%(asctime)s:%(levelname)s:%(message)s"
+def configure_logging(result_folder, cl_args):
+    import sys
+    from levseq import __version__
+    
+    # Define a more detailed log format with clean separation
+    log_format = "%(asctime)s : %(levelname)s : %(message)s"
+    
+    # Create log handlers
     info_handler = logging.FileHandler(os.path.join(result_folder, "LevSeq_run.log"))
     info_handler.setLevel(logging.INFO)
     info_handler.setFormatter(logging.Formatter(log_format))
@@ -76,7 +82,30 @@ def configure_logging(result_folder):
     error_handler.setLevel(logging.ERROR)
     error_handler.setFormatter(logging.Formatter(log_format))
 
+    # Set up basic configuration with both handlers
     logging.basicConfig(level=logging.INFO, handlers=[info_handler, error_handler])
+    
+    # Log version information and command used to run
+    command_used = " ".join(sys.argv)
+    logging.info(f"LevSeq Version: {__version__}")
+    logging.info(f"Command: {command_used}")
+    
+    # Log essential run parameters
+    logging.info(f"Run name: {cl_args.get('name', 'Not specified')}")
+    logging.info(f"Input path: {cl_args.get('path', 'Not specified')}")
+    logging.info(f"Summary file: {cl_args.get('summary', 'Not specified')}")
+    
+    # Log optional parameters if specified
+    if cl_args.get('output') and cl_args.get('output') != os.getcwd():
+        logging.info(f"Output directory: {cl_args.get('output')}")
+    if cl_args.get('oligopool'):
+        logging.info("Running in oligopool mode")
+    if cl_args.get('skip_demultiplexing'):
+        logging.info("Skipping demultiplexing step")
+    if cl_args.get('skip_variantcalling'):
+        logging.info("Skipping variant calling step")
+    if cl_args.get('threshold'):
+        logging.info(f"Using variant threshold: {cl_args.get('threshold')}")
 
 # Create result folder
 def create_result_folder(cl_args):
@@ -139,8 +168,15 @@ def cat_fastq_files(folder_path: str, output_path: str, reads_per_file: int = 40
         else:
             for fastq_file in fastq_files:
                 destination = output_path / fastq_file.name
-                shutil.copy(fastq_file, destination)
-                logging.info("Copied %s to %s", fastq_file, destination)
+                # Skip copying if source and destination are identical
+                if str(fastq_file) == str(destination):
+                    logging.info("Skipping copy of %s (source and destination are identical)", fastq_file)
+                    continue
+                try:
+                    shutil.copy(fastq_file, destination)
+                    logging.info("Copied %s to %s", fastq_file, destination)
+                except shutil.SameFileError:
+                    logging.info("Skipping copy of %s (source and destination are identical files)", fastq_file)
         logging.info("All FASTQ files processed successfully to %s", output_path)
         return str(output_path)
     except Exception as e:
@@ -221,13 +257,14 @@ def demux_fastq(file_to_fastq, result_folder, barcode_path):
         executable_path = package_root / "levseq" / "barcoding" / executable_name
     if not executable_path.exists():
         raise FileNotFoundError(f"Executable not found: {executable_path}")
-    seq_min = 200 
+    seq_min = 200
     seq_max = 10000
     prompt = f"{executable_path} -f {file_to_fastq} -d {result_folder} -b {barcode_path} -w 100 -r 100 -m {seq_min} -x {seq_max}"
     subprocess.run(prompt, shell=True, check=True)
 
 # Variant calling using VariantCaller class
-def call_variant(experiment_name, experiment_folder, template_fasta, filtered_barcodes):
+
+def call_variant(experiment_name, experiment_folder, template_fasta, filtered_barcodes, threshold=0.5, oligopool=False):
     try:
         vc = VariantCaller(
             experiment_name,
@@ -236,8 +273,9 @@ def call_variant(experiment_name, experiment_folder, template_fasta, filtered_ba
             filtered_barcodes,
             padding_start=0,
             padding_end=0,
+            oligopool=oligopool
         )
-        variant_df = vc.get_variant_df(threshold=0.5, min_depth=5)
+        variant_df = vc.get_variant_df(threshold=threshold, min_depth=5)
         logging.info("Variant calling to create consensus reads successful")
         return variant_df
     except Exception as e:
@@ -332,7 +370,7 @@ def create_df_v(variants_df):
 
     # 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)
+    restructured_df.columns = restructured_df.columns.str.lower().str.replace(r'[\s-]', '_', regex=True)
     # Fix the specific column name
     restructured_df.columns = restructured_df.columns.str.replace('p_adj._value', 'p_adj_value')
 
@@ -441,6 +479,63 @@ def save_csv(df, outputdir, name):
     file_path = os.path.join(outputdir, "Results", name + ".csv")
     df.to_csv(file_path)
 
+# Function to process the reference CSV and generate variants
+def process_ref_csv_oligopool(cl_args, tqdm_fn=tqdm.tqdm):
+    ref_df = pd.read_csv(cl_args["summary"])
+    result_folder = create_result_folder(cl_args)
+    variant_csv_path = os.path.join(result_folder, "variants.csv")
+    variant_df = pd.DataFrame(columns=["barcode_plate", "name", "refseq", "variant"])
+    
+    # First get the different barcode plates (these will be unique)
+    barcode_plates = ref_df["barcode_plate"].unique()
+    ref_df["barcode_index"] = [i for i in range(len(ref_df))]
+    barcode_to_index = dict(zip(ref_df.barcode_plate, ref_df.barcode_index))
+    for barcode_plate in barcode_plates:
+        if not cl_args["skip_demultiplexing"]:
+            i = barcode_to_index[barcode_plate]
+            name_folder = os.path.join(result_folder, f'RB{barcode_plate}')
+            os.makedirs(name_folder, exist_ok=True)
+            barcode_path = filter_bc(cl_args, name_folder, i)
+            output_dir = Path(result_folder) / f"{cl_args['name']}_fastq"
+            output_dir.mkdir(parents=True, exist_ok=True)
+            
+            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:
+                logging.error("An error occurred during demultiplexing for sample {}. Skipping this sample.".format(barcode_plate), exc_info=True)
+                continue
+            # Check this - need to see if the code works... ToDo: Ariane
+    # Now they are all demultiplexed, we can call variants
+    if not cl_args["skip_variantcalling"]:
+        for i, row in tqdm_fn(ref_df.iterrows(), total=len(ref_df), desc="Processing Samples"):
+            barcode_plate = row["barcode_plate"]
+            name = row["name"]
+            refseq = row["refseq"].upper()
+            # Get the name folder and barcode path
+            temp_fasta_path = os.path.join(result_folder, f"temp_{name}.fasta")
+            if not os.path.exists(temp_fasta_path):
+                with open(temp_fasta_path, "w") as f:
+                    f.write(f">{name}\n{refseq}\n")
+            else:
+                logging.info(f"Fasta file for {name} already exists. Skipping write.")
+            try:
+                filtered_barcodes = filter_bc(cl_args, result_folder, i)
+                variant_result = call_variant(f"{name}", result_folder, temp_fasta_path, filtered_barcodes,
+                                              oligopool=True)
+                variant_result["barcode_plate"] = barcode_plate
+                variant_result["name"] = name
+                variant_result["refseq"] = refseq
+                variant_df = pd.concat([variant_df, variant_result])
+            except Exception as e:
+                logging.error("An error occurred during variant calling for sample {}. Skipping this sample.".format(name), exc_info=True)
+                continue
+        
+        variant_df.to_csv(variant_csv_path, index=False)
+    # visualize it as well
+    return variant_df, ref_df
+
+
 # Function to process the reference CSV and generate variants
 def process_ref_csv(cl_args, tqdm_fn=tqdm.tqdm):
     ref_df = pd.read_csv(cl_args["summary"])
@@ -493,8 +588,9 @@ def process_ref_csv(cl_args, tqdm_fn=tqdm.tqdm):
         
         if not cl_args["skip_variantcalling"]:
             try:
+                threshold = cl_args.get("threshold") if cl_args.get("threshold") is not None else 0.5
                 variant_result = call_variant(
-                    f"{name}", name_folder, temp_fasta_path, barcode_path
+                    f"{name}", name_folder, temp_fasta_path, barcode_path, threshold=threshold
                 )
                 variant_result["barcode_plate"] = barcode_plate
                 variant_result["name"] = name
@@ -508,6 +604,7 @@ def process_ref_csv(cl_args, tqdm_fn=tqdm.tqdm):
     variant_df.to_csv(variant_csv_path, index=False)
     return variant_df, ref_df
 
+
 # Main function to run LevSeq and ensure saving of intermediate results if an error occurs
 def run_LevSeq(cl_args, tqdm_fn=tqdm.tqdm):
     result_folder = create_result_folder(cl_args)
@@ -515,13 +612,16 @@ def run_LevSeq(cl_args, tqdm_fn=tqdm.tqdm):
     ref_folder = os.path.join(result_folder, "ref")
     os.makedirs(ref_folder, exist_ok=True)
     
-    configure_logging(result_folder)
-    logging.info("Logging configured. Starting program.")
+    configure_logging(result_folder, cl_args)
+    logging.info("Logging configured. Starting analysis...")
 
     variant_df = pd.DataFrame(columns=["barcode_plate", "name", "refseq", "variant"])
-    
+
     try:
-        variant_df, ref_df = process_ref_csv(cl_args, tqdm_fn)
+        if cl_args["oligopool"]:
+            variant_df, ref_df = process_ref_csv_oligopool(cl_args, tqdm_fn)
+        else:
+            variant_df, ref_df = process_ref_csv(cl_args, tqdm_fn)
         ref_df_path = os.path.join(ref_folder, cl_args["name"]+".csv")
         ref_df.to_csv(ref_df_path, index=False)
 
@@ -544,6 +644,8 @@ def run_LevSeq(cl_args, tqdm_fn=tqdm.tqdm):
         df_variants, df_vis = create_df_v(variant_df)
         processed_csv = os.path.join(result_folder, "visualization_partial.csv")
         df_vis.to_csv(processed_csv, index=False)
+        if cl_args["oligopool"]:
+            make_oligopool_plates(df_vis, result_folder=result_folder, save_files=True)
     except Exception as e:
         processed_csv = os.path.join(result_folder, "visualization_partial.csv")
         if 'df_vis' in locals():

{levseq-1.3.3 → levseq-1.4.1}/levseq/utils.py

@@ -59,12 +59,13 @@ def translate(seq):
         'TTC': 'F', 'TTT': 'F', 'TTA': 'L', 'TTG': 'L',
         'TAC': 'Y', 'TAT': 'Y', 'TAA': '*', 'TAG': '*',
         'TGC': 'C', 'TGT': 'C', 'TGA': '*', 'TGG': 'W',
+        'GTS': "X"
     }
     protein = ""
     if len(seq) % 3 == 0:
         for i in range(0, len(seq), 3):
             codon = seq[i:i + 3]
-            protein += table[codon]
+            protein += table.get(codon, 'X')
     return protein
 
 
@@ -290,8 +291,7 @@ def get_reads_for_well(parent_name, bam_file_path: str, ref_str: str, msa_path=N
     insert_map = defaultdict(list)
     for read in bam.fetch(until_eof=True):
         # Ensure we have at least 75% coverage
-        if read.query_sequence is not None and len(read.query_sequence) > 0.75 * len(
-                ref_str) and read.cigartuples is not None:
+        if read.query_sequence is not None and read.cigartuples is not None: # and len(read.query_sequence) > 0.75 * len(ref_str) and read.cigartuples is not None:
             seq, ref, qual, ins = alignment_from_cigar(read.cigartuples, read.query_sequence, ref_str,
                                                        read.query_qualities)
             # Make it totally align
@@ -313,16 +313,17 @@ def get_reads_for_well(parent_name, bam_file_path: str, ref_str: str, msa_path=N
     # Do this for all wells
     seq_df = make_well_df_from_reads(seqs, read_ids, read_quals)
     alignment_count = len(seq_df.values)
-    rows_all = make_row_from_read_pileup_across_well(seq_df, ref_str, parent_name, insert_map)
-    bam.close()
-
-    if len(rows_all) > 2:  # Check if we have anything to return
-        seq_df = pd.DataFrame(rows_all)
-        seq_df.columns = ['gene_name', 'position', 'ref', 'most_frequent', 'freq_non_ref', 'total_other',
-                          'total_reads', 'p_value', 'percent_most_freq_mutation', 'A', 'p(a)', 'T', 'p(t)', 'G', 'p(g)',
-                          'C', 'p(c)', 'N', 'p(n)', 'I', 'p(i)', 'Warnings']
-        return calculate_mutation_significance_across_well(seq_df), alignment_count
-
+    if alignment_count > 0:
+        rows_all = make_row_from_read_pileup_across_well(seq_df, ref_str, parent_name, insert_map)
+        bam.close()
+
+        if len(rows_all) > 2:  # Check if we have anything to return
+            seq_df = pd.DataFrame(rows_all)
+            seq_df.columns = ['gene_name', 'position', 'ref', 'most_frequent', 'freq_non_ref', 'total_other',
+                              'total_reads', 'p_value', 'percent_most_freq_mutation', 'A', 'p(a)', 'T', 'p(t)', 'G', 'p(g)',
+                              'C', 'p(c)', 'N', 'p(n)', 'I', 'p(i)', 'Warnings']
+            return calculate_mutation_significance_across_well(seq_df), alignment_count
+    return None, 0
 def make_row_from_read_pileup_across_well(well_df, ref_str, label, insert_map):
     """
     Given a pileup of reads, we want to get some summary information about that sequence