mi-pimento 0.0.1__tar.gz

mi_pimento-0.0.1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

mi_pimento-0.0.1/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.2
+Name: mi-pimento
+Version: 0.0.1
+Summary: A PrIMEr infereNce TOolkit to facilitate large-scale calling of metabarcoding amplicon sequence variants
+Author-email: MGnify team <metagenomics-help@ebi.ac.uk>
+License: Apache Software License 2.0
+Keywords: bioinformatics,pipelines,metagenomics,primers,reads,sequencing
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: biopython==1.82
+Requires-Dist: numpy==1.26.0
+Requires-Dist: pandas==2.0.2
+Requires-Dist: regex==2023.12.25
+Requires-Dist: click==8.1.7
+Requires-Dist: pyfastx>=2.2.0
+Requires-Dist: rich==13.9.4
+Provides-Extra: tests
+Requires-Dist: pytest==7.4.0; extra == "tests"
+Requires-Dist: pytest-md==0.2.0; extra == "tests"
+Requires-Dist: pytest-workflow==2.0.1; extra == "tests"
+Requires-Dist: biopython==1.82; extra == "tests"
+Requires-Dist: pandas==2.0.2; extra == "tests"
+Requires-Dist: numpy==1.26.0; extra == "tests"
+Requires-Dist: regex==2023.12.25; extra == "tests"
+Requires-Dist: click==8.1.7; extra == "tests"
+Requires-Dist: pyfastx>=2.2.0; extra == "tests"
+Requires-Dist: rich==13.9.4; extra == "tests"
+Provides-Extra: dev
+Requires-Dist: mi-pimento[tests]; extra == "dev"
+Requires-Dist: pre-commit==3.8.0; extra == "dev"
+Requires-Dist: black==24.8.0; extra == "dev"
+Requires-Dist: flake8==7.1.1; extra == "dev"
+Requires-Dist: pep8-naming==0.14.1; extra == "dev"
+
+# PIMENTO
+A PrIMEr infereNce TOolkit to facilitate large-scale calling of metabarcoding amplicon sequence variants

mi_pimento-0.0.1/README.md

@@ -0,0 +1,2 @@
+# PIMENTO
+A PrIMEr infereNce TOolkit to facilitate large-scale calling of metabarcoding amplicon sequence variants

mi_pimento-0.0.1/bin/are_there_primers.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2024 EMBL - European Bioinformatics Institute
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pathlib import Path
+import numpy as np
+
+from bin.pimento_utils import (
+    get_read_count,
+    compute_windowed_base_conservation,
+    build_list_of_base_counts,
+    fetch_read_substrings,
+)
+
+from bin.thresholds import ATP_WINDOW_SIZE, ATP_PREFIX_LENGTH
+
+
+def atp_in_this_sample(input_fastq: Path, rev: bool = False) -> bool:
+    """
+    Predict the presence of primers based on windows of base conservation.
+
+    Takes a fastq file as input. Extracts proportion of most common base for the first 100 bases.
+    Computes the a threshold (Q3 - 0.15) based on this proportion and counts the number of bases below
+    it in windows of 10 bases.
+    If at least one of the first two windows contains at most one such a base, then the presence
+    of a primer is flagged as true. A primer is also flagged as true if the combined count
+    of bases below Q3 is at most 4.
+
+    The output of this function is a boolean flag:
+        True if a primer was identified
+        False if a primer was not identified
+    """
+
+    read_count = get_read_count(
+        input_fastq, file_type="fastq"
+    )  # Get read count for fastq file
+
+    read_substring_count_dict = fetch_read_substrings(
+        input_fastq, ATP_PREFIX_LENGTH, rev=rev
+    )  # substring dict where key is the substring and value is the count
+    base_counts = build_list_of_base_counts(
+        read_substring_count_dict, ATP_PREFIX_LENGTH
+    )  # list of base conservation dicts for substrings
+    base_conservation, cons_seq = compute_windowed_base_conservation(
+        base_counts, read_count
+    )  # get list of max base conservations for each index
+
+    # Counter that will reset to 0 every 10 bases
+    window_count = 0
+    # Will append the window count to this list every 10 bases
+    window_count_list = []
+    # Compute Q3-based threshold
+    max_cons = np.quantile(base_conservation, 0.75)
+    threshold = max_cons - 0.15
+
+    if max_cons < 0.75:
+        threshold = 0.75
+    # Immediately return false (no primer) if the max conservation is less than 0.6
+    if max_cons < 0.6:
+        return False
+
+    # Loop through every base
+    for counter, val in enumerate(base_conservation):
+        if (
+            counter % ATP_WINDOW_SIZE == 0 and counter != 0
+        ):  # After looping through a window..
+            window_count_list.append(window_count)  # ..append window count
+            window_count = 0  # ..reset window count
+
+        if (
+            val < threshold
+        ):  # If the conservation at i is less than threshold, increment count for the window
+            window_count += 1
+
+    primer_flag = False  # Initialise primer flag as false
+
+    if (
+        1 in window_count_list[:2] or 0 in window_count_list[:2]
+    ):  # If window count is at most 1 of first two windows...
+        primer_flag = True  # ..primer flag is true
+    elif (
+        sum(window_count_list[:2]) <= 4
+    ):  # If sum of window counts of the first two windows is at most 4..
+        primer_flag = True  # ..primer flag is true
+
+    return primer_flag
+
+
+def write_atp_output(results: tuple[bool, bool], output_prefix: str) -> None:
+    """
+    Save primer presence flags into output .txt file.
+
+    1: primer exists
+    0: primer doesn't exist
+
+    First line will be the forward strand
+    Second line will be the reverse strand
+    """
+
+    with open(f"{output_prefix}_general_primer_out.txt", "w") as fw:
+        fw.write(f"{results[0]}\n")
+        fw.write(f"{results[1]}\n")

mi_pimento-0.0.1/bin/choose_primer_cutoff.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2024 EMBL - European Bioinformatics Institute
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from Bio.Seq import Seq
+from pathlib import Path
+import numpy as np
+
+from bin.pimento_utils import (
+    get_read_count,
+    compute_windowed_base_conservation,
+    build_list_of_base_counts,
+    fetch_read_substrings,
+)
+from bin.thresholds import CONSENSUS_BASE_THRESHOLD, MAX_READ_COUNT
+
+
+def choose_cutoff_for_single_strand(
+    input_fastq: Path, cutoff_list: list[int], rev: bool = False
+) -> None:
+    """
+    Assess inflection point list, selecting one for automatic primer trimming.
+
+    Takes as input a fastq file and a list of inflection points generated by "find_cutoffs.py".
+    Computes the average conservation of bases before inflection point and after.
+    Gets the difference in avg. conservation between the pre- and post- points.
+    Selects the inflection point with the maximum difference as the cutoff.
+    If an inf point has a similar difference and is earlier than the max, we make a 'conservative' choice and
+    replace it with the earlier cutoff.
+
+    Returns the cutoff point and the consensus sequence 'forming' the automatically predicted primer
+    """
+
+    start_confs = []  # pre-inf point conservations
+    end_confs = []  # post-inf point conservations
+    start_cons_lens = []  # list for storing lengths of pre-inflection point sequences
+    cons_seq_list = []  # list for storing consensus sequences pre-inflection points
+
+    do_not_include_list = [
+        i + 5 for i in cutoff_list
+    ]  # ignore conservation of inflection point in calculation
+
+    read_count = get_read_count(input_fastq)  # get readcount from fastq
+
+    max_line_count = 0
+    if read_count > MAX_READ_COUNT:
+        max_line_count = MAX_READ_COUNT
+
+    for start in cutoff_list:  # Looping through the pre-inflection point substrings
+        substring_len = (
+            start + 4
+        )  # length of pre-inf substrings is inflection point + 4
+
+        read_substring_count_dict = fetch_read_substrings(
+            input_fastq, substring_len, rev=rev, max_line_count=max_line_count
+        )  # get base count dict
+        base_counts = build_list_of_base_counts(
+            read_substring_count_dict, substring_len
+        )  # list of base conservation dicts for substrings
+        base_conservation, cons_seq = compute_windowed_base_conservation(
+            base_counts,
+            read_count,
+            CONSENSUS_BASE_THRESHOLD,
+            do_not_include_list,
+            max_line_count=max_line_count,
+        )  # get list of max base conservations for each index
+        # also get consensus sequence
+        cons_seq_list.append(cons_seq)
+        start_confs.append(np.mean(base_conservation))
+        start_cons_lens.append(len(cons_seq))
+
+    for i, end in enumerate(
+        cutoff_list
+    ):  # Looping through the post-inflection point substrings
+        substring_len = end + 5  # length of pre-inf substrings is inflection point + 5
+        subs_len = start_cons_lens[i]  # length of respective pre-inf point sequence
+
+        read_substring_count_dict = fetch_read_substrings(
+            input_fastq, subs_len, rev, substring_len, max_line_count=max_line_count
+        )
+        base_counts = build_list_of_base_counts(read_substring_count_dict, subs_len)
+        base_conservation, cons_seq = compute_windowed_base_conservation(
+            base_counts,
+            read_count,
+            CONSENSUS_BASE_THRESHOLD,
+            do_not_include_list,
+            subs_len,
+            max_line_count=max_line_count,
+        )
+
+        end_confs.append(np.mean(base_conservation))
+
+    diff_res = [
+        start_confs[i] - end_confs[i] for i in range(len(start_confs))
+    ]  # get differences between pre- and -post avg conservation values
+    diff_res_sorted = sorted(
+        diff_res, reverse=True
+    )  # sort differences from highest to lowest
+
+    ini_max_res = diff_res_sorted[0]  # maximum differences
+    curr_max_index = diff_res.index(ini_max_res)  # index of maximum differences
+
+    for res in diff_res_sorted[1:]:  # Loop through the rest of the differences
+        curr_res_index = np.where(diff_res == res)[0][0]
+
+        index_diff = cutoff_list[curr_max_index] - cutoff_list[curr_res_index]
+
+        # if difference between the max and the current is negligible and the index of the current is earlier then..
+        if ini_max_res - res < 0.05 and (index_diff <= 3 and index_diff > 0):
+            curr_max_index = (
+                curr_res_index  # replace the selected index with the current one
+            )
+
+    cutoff = cutoff_list[curr_max_index] + 5  # cutoff is the inflection point index + 5
+    primer = cons_seq_list[
+        curr_max_index
+    ]  # grab the correct consensus sequence as primer
+
+    # if the requested strand is reverse..
+    if rev:
+        primer = str(
+            Seq(primer).complement()
+        )  # ..get the complement of consensus sequence
+
+    return cutoff, primer

mi_pimento-0.0.1/bin/find_cutoffs.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2025 EMBL - European Bioinformatics Institute
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections import defaultdict
+
+import numpy as np
+
+from bin.thresholds import MAX_CUTOFF_WINDOW_START, MIN_CUTOFF_WINDOW_START
+
+
+def find_bcv_inflection_points(bcv_df):
+    """
+    Find inflection points from an bcv_df file output by "generate_bcv.py"
+
+    Takes the list of average base conservations and gets the derivative of the curve
+    Keep any points of the derivative where value is above the 80th percentile
+
+    Outputs a dictionary with key-val pairs where vals are lists:
+        'strand' -> strand list
+        'inf_point' -> inf_point list
+
+    """
+
+    inf_point_dict = defaultdict(list)
+    start_indices = [int(i) for i in bcv_df.columns.tolist()]
+
+    for i in range(len(bcv_df)):  # Loop through both possible strands of the bcv_df
+        strand = bcv_df.index[i]
+        props = bcv_df.iloc[i].tolist()
+        props = [-val for val in props]
+
+        prop_diff = np.diff(props) / np.diff(start_indices)  # Get the derivative
+        infl_points = np.where(prop_diff > np.percentile(prop_diff, 80))[
+            0
+        ]  # Grab points above 80th percentile
+
+        for ind in infl_points:
+            inf_point = start_indices[ind]
+
+            if (
+                inf_point < MIN_CUTOFF_WINDOW_START
+                or inf_point > MAX_CUTOFF_WINDOW_START
+            ):  # Rule to facilitate results - won't accept
+                continue  # points below index 10 or above index 20
+                # 10 means a cutoff of 15 and 20 a cutoff of 25
+                # literature points to no primers existing that are
+                # shorter or bigger  than these lengths
+
+            inf_point_dict["strand"].append(strand)
+            inf_point_dict["inf_point"].append(inf_point)
+
+    return inf_point_dict

mi_pimento-0.0.1/bin/generate_bcv.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2025 EMBL - European Bioinformatics Institute
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections import defaultdict
+from pathlib import Path
+
+import pandas as pd
+import numpy as np
+
+from bin.pimento_utils import (
+    get_read_count,
+    compute_windowed_base_conservation,
+    build_list_of_base_counts,
+    fetch_read_substrings,
+)
+from bin.thresholds import MAX_READ_COUNT, BCV_WINDOW_SIZE
+
+
+def generate_bcv_for_single_strand(path: Path, rev: bool = False) -> defaultdict[float]:
+    """
+    Generate base-conservation vectors in a stepwise and windowed manner for a fastq file.
+
+    For a continuous range of starting indices (2 to 25), generate substrings of window size of 5 bases.
+    Calculate the average conservation of the most common base at each index of a window.
+    The resulting list of base-conservations can be considered a conservation vector and used to
+    identify inflection points where the conservation suddenly changes.
+
+    Output a dictionary where:
+        key -> an index starting point e.g. base 10
+        val -> the avg conservation of the most common base for the substring window from base 10 to 15 (inclusive)
+    """
+
+    res_dict = defaultdict(float)
+    start_range = range(2, 25, 1)  # Range of starting indices
+
+    for start in start_range:
+
+        read_count = get_read_count(
+            path, file_type="fastq"
+        )  # get read count for fastq file
+
+        max_line_count = 0
+        if read_count > MAX_READ_COUNT:
+            max_line_count = MAX_READ_COUNT
+
+        read_substring_count_dict = fetch_read_substrings(
+            path, BCV_WINDOW_SIZE, rev, start, max_line_count
+        )  # get substring count dict
+        base_counts = build_list_of_base_counts(
+            read_substring_count_dict, BCV_WINDOW_SIZE
+        )  # list of base conservation dicts for substring
+        base_conservation, cons_seq = compute_windowed_base_conservation(
+            base_counts, read_count, max_line_count=max_line_count
+        )  # get list of max base conservations for each index
+
+        res_dict[start] = np.mean(base_conservation)  # compute the mean
+
+    return res_dict
+
+
+def write_bcv_output(
+    fwd_out: defaultdict[float] = {}, rev_out: defaultdict[float] = {}
+):
+    """
+    Generate Pandas dataframe out of bcv dictionary.
+
+    Output looks like this (when both F and R are requested):
+        2	3	4
+    F	0.7814975041597337	0.8736772046589019	0.9434276206322796
+    R	0.9010981697171381	0.9082861896838601	0.90369384359401
+
+    Columns are the starting indices. Row labels are the strand.
+    """
+
+    final_res_dict = defaultdict(list)
+    df_ind = []
+
+    # Check if fwd strand was requested
+    if fwd_out:
+        [final_res_dict[key].append(fwd_out[key]) for key in fwd_out.keys()]
+        df_ind.append("F")
+
+    # Check if rev strand was requested
+    if rev_out:
+        [final_res_dict[key].append(rev_out[key]) for key in rev_out.keys()]
+        df_ind.append("R")
+
+    res_df = pd.DataFrame.from_dict(final_res_dict)
+    res_df.index = df_ind
+
+    return res_df