levseq 1.4.0__tar.gz → 1.4.2__tar.gz

levseq-1.4.2/PKG-INFO

@@ -0,0 +1,202 @@
+Metadata-Version: 2.1
+Name: levseq
+Version: 1.4.2
+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
+   ```
+4. Connect function data to your sequence data
+   ```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 --fitness_files "levseq_results/20250712_epPCR_Q06714_37.csv,levseq_results/20250712_epPCR_Q06714_39.csv,levseq_results/20250712_epPCR_Q06714_40.csv" --smiles 'O=P(OC1=CC=CC=C1)(OC2=CC=CC=C2)OC3=CC=CC=C3>>O=P(O)(OC4=CC=CC=C4)OC5=CC=CC=C5' --compound dPPi --variant_df "levseq_results/visualization_partial.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
+   ```
+
+5. Combine function data:
+   ```bash
+   levseq my_experiment /path/to/data/ /path/to/ref.csv  "LCMS_file_{barcode1}.csv,LCMS_file_{barcode2}.csv," --smiles 'reaction_smiles_string' --compound "name_of_compound_in_LCMS_file" --variant_df "visualization_partial.csv"
+   ```
+
+Note for function data we currently expect a LCMS file e.g. with the columns: 
+- `Sample Vial Number` (corresponding to the well that the sample was from). 
+- `Area` (which becomes fitness value). 
+- `Compound Name` which is the name of the compound we filter for that is passed as a parameter.
+- The last `_X.csv` needs to be the barcode number to match that sample to your plate e.g. if you ran LevSeq with barcode 33 for plate 2 you need to have `_33.csv` for the fitness file for plate 2. e.g. `some_fitnes_for_plate_2_33.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.2/README.md

@@ -0,0 +1,155 @@
+# 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
+   ```
+4. Connect function data to your sequence data
+   ```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 --fitness_files "levseq_results/20250712_epPCR_Q06714_37.csv,levseq_results/20250712_epPCR_Q06714_39.csv,levseq_results/20250712_epPCR_Q06714_40.csv" --smiles 'O=P(OC1=CC=CC=C1)(OC2=CC=CC=C2)OC3=CC=CC=C3>>O=P(O)(OC4=CC=CC=C4)OC5=CC=CC=C5' --compound dPPi --variant_df "levseq_results/visualization_partial.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
+   ```
+
+5. Combine function data:
+   ```bash
+   levseq my_experiment /path/to/data/ /path/to/ref.csv  "LCMS_file_{barcode1}.csv,LCMS_file_{barcode2}.csv," --smiles 'reaction_smiles_string' --compound "name_of_compound_in_LCMS_file" --variant_df "visualization_partial.csv"
+   ```
+
+Note for function data we currently expect a LCMS file e.g. with the columns: 
+- `Sample Vial Number` (corresponding to the well that the sample was from). 
+- `Area` (which becomes fitness value). 
+- `Compound Name` which is the name of the compound we filter for that is passed as a parameter.
+- The last `_X.csv` needs to be the barcode number to match that sample to your plate e.g. if you ran LevSeq with barcode 33 for plate 2 you need to have `_33.csv` for the fitness file for plate 2. e.g. `some_fitnes_for_plate_2_33.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.0 → levseq-1.4.2}/levseq/__init__.py

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

levseq-1.4.2/levseq/interface.py

@@ -0,0 +1,150 @@
+###############################################################################
+#                                                                             #
+#    This program is free software: you can redistribute it and/or modify     #
+#    it under the terms of the GNU General Public License as published by     #
+#    the Free Software Foundation, either version 3 of the License, or        #
+#    (at your option) any later version.                                      #
+#                                                                             #
+#    This program is distributed in the hope that it will be useful,          #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of           #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            #
+#    GNU General Public License for more details.                             #
+#                                                                             #
+#    You should have received a copy of the GNU General Public License        #
+#    along with this program. If not, see <http://www.gnu.org/licenses/>.     #
+#                                                                             #
+###############################################################################
+"""
+Contain argument parsers used for command line interface and web interface
+"""
+# Import packages
+import os
+import tqdm
+import argparse
+import pandas as pd
+
+# Import local packages
+from levseq.run_levseq import run_LevSeq
+
+# Get the working directory
+CWD = os.getcwd()
+
+# Set default arguments 
+padding_start = 0
+padding_end = 0
+min_depth = 5
+threshold = 0.2
+basecall_model = 'sup'
+
+
+# Build the CLI argparser
+def build_cli_parser():
+    # Initialize
+    parser = argparse.ArgumentParser()
+
+    # Add required arguments
+    required_args_group = parser.add_argument_group("Required Arguments", "Arguments required for each run")
+    required_args_group.add_argument('name',
+            help = 'User defined name for the output folder')
+    required_args_group.add_argument("path",
+            help="Path to folder containing fastq.pass or pod5_pass files.")
+    required_args_group.add_argument("summary",
+            help="CSV file containig barcodes used, name of each plate and reference sequence in string")
+    # Add optional arguments
+    optional_args_group = parser.add_argument_group("Optional Arguments", "Aditional arguments")
+    optional_args_group.add_argument("--output",
+                                     help="Save location for run. Defaults to current working directory.",
+                                     required=False,
+                                     default=CWD)
+    optional_args_group.add_argument("--perform_basecalling",
+                                     action="store_true",
+                                     help="Skip the basecalling step, default is false")
+    optional_args_group.add_argument("--skip_demultiplexing",
+                                     action="store_true",
+                                     help="Skip the demultiplexing step, default is false")
+    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")  
+    # if cl_args.get('fitness_files') and cl_args.get('smiles'):
+    optional_args_group.add_argument("--fitness_files",
+                                    default=None,
+                                    help="A comma separated list of fitness files (full path) with string quotation marks around them.")
+    optional_args_group.add_argument("--smiles",
+                                default=None,
+                                help="A smiles string of the reaction with quotation marks around.")
+    optional_args_group.add_argument("--compound",
+                            default=None,
+                            help="The compound in the fitness files (e.g. pDT or pdt - case sensitive).")     
+    optional_args_group.add_argument("--variant_df",
+                        default=None,
+                        help="The variant dataframe to combine with fitness data.")                                   
+    return parser
+
+
+def combine_seq_func_data(cl_args):
+    # Also check if we have any fitness data 
+    if cl_args.get('fitness_files') and cl_args.get('smiles') and cl_args.get('variant_df'):
+        variant_filename = cl_args.get('variant_df')
+        variant_df = pd.read_csv(variant_filename)
+        # Combine the fitness data with the plate data (note the barcode has to be the last _[barcode])
+        # The smiles has to be the reaction smiles
+        function_files = cl_args.get('fitness_files')
+        compound_name = cl_args.get('compound') if cl_args.get('compound') else 'pdt'
+        print(function_files, compound_name)
+        all_function_df = pd.DataFrame()
+        for function_file in function_files.split(','):
+            barcode = function_file.split('.csv')[0].split('_')[-1]
+            function_df = pd.read_csv(f'{function_file}')
+            function_df.columns = [c.replace('\n', ' ') for c in function_df.columns]
+            function_df['function_well'] = [x.split('-')[-1] if isinstance(x, str) else None for x in function_df['Sample Vial Number'].values]
+            function_df['function_barcode_plate'] = barcode
+            function_df = function_df[function_df['Compound Name'] == compound_name] # We only use pdt or Pdt
+            # Convert it to numeric 
+            function_df['Area'] = pd.to_numeric(function_df['Area'], errors='coerce')
+
+            function_df['barcode_well'] = [f'{p}_{w}' for w, p in function_df[['function_well', 'function_barcode_plate']].values]
+            function_df['filename'] = function_file
+            print(function_df.head())
+            all_function_df = pd.concat([all_function_df, function_df])
+        # Join this with the variant_df barcode plate
+        variant_df['barcode_well'] = [f'{p}_{w}' for w, p in variant_df[['Well', 'barcode_plate']].values]
+        # Join the two
+        variant_df.set_index('barcode_well', inplace=True)
+        all_function_df.set_index('barcode_well', inplace=True)
+        variant_df = variant_df.join(all_function_df, how='left')
+        reaction_smiles = cl_args.get('smiles')
+        variant_df['smiles_string'] = reaction_smiles.split('>>')[-1]
+        variant_df['reaction_smiles'] = reaction_smiles
+        variant_df.columns = [c.lower().replace(' ', '_') for c in variant_df.columns]
+        variant_df.rename(columns={'area': 'fitness_value'}, inplace=True)
+        variant_df.to_csv(f'{variant_filename.replace(".csv", "_seqfunc.csv")}')
+        
+        # levseq levseq_4.1 ref.csv fitness --fitness_files "20250712_epPCR_Q06714_37.csv,20250712_epPCR_Q06714_38.csv,20250712_epPCR_Q06714_39.csv,20250712_epPCR_Q06714_40.csv" --smiles 'O=P(OC1=CC=CC=C1)(OC2=CC=CC=C2)OC3=CC=CC=C3>>O=P(O)(OC4=CC=CC=C4)OC5=CC=CC=C5'  --compound dPPi --variant_df visualization_partial.csv
+        return variant_df
+        
+# Execute LevSeq
+def execute_LevSeq():
+    # Build parser
+    parser = build_cli_parser()
+    # Parse the arguments
+    CL_ARGS = vars(parser.parse_args())
+    if CL_ARGS.get('fitness_files') and CL_ARGS.get('smiles') and CL_ARGS.get('variant_df'):
+        print('Combining LevSeq')
+        return combine_seq_func_data(CL_ARGS)
+    # Set up progres bar
+    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(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.4.0 → levseq-1.4.2}/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:
@@ -334,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')
 
@@ -566,6 +602,7 @@ def process_ref_csv(cl_args, tqdm_fn=tqdm.tqdm):
                 continue
     
     variant_df.to_csv(variant_csv_path, index=False)
+
     return variant_df, ref_df
 
 
@@ -576,8 +613,8 @@ 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"])
 

{levseq-1.4.0 → levseq-1.4.2}/levseq/variantcaller.py

@@ -141,15 +141,15 @@ class VariantCaller:
             # Alignment using minimap2
             minimap_cmd = f"minimap2 -ax map-ont -A {scores[0]} -B {scores[1]} -O {scores[2]},24 '{self.template_fasta}' '{fastq_files}' > '{output_dir}/{alignment_name}.sam'"
             subprocess.run(minimap_cmd, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            print(minimap_cmd)
+            # print(minimap_cmd)
             # Convert SAM to BAM and sort
             view_cmd = f"samtools view -bS '{output_dir}/{alignment_name}.sam' > '{output_dir}/{alignment_name}.bam'"
             subprocess.run(view_cmd, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            print(view_cmd)
+            # print(view_cmd)
 
             sort_cmd = f"samtools sort '{output_dir}/{alignment_name}.bam' -o '{output_dir}/{alignment_name}.bam'"
             subprocess.run(sort_cmd, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            print(sort_cmd)
+            # print(sort_cmd)
 
             # Index the BAM file
             index_cmd = f"samtools index '{output_dir}/{alignment_name}.bam'"