stralln 0.1__tar.gz

stralln-0.1/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: stralln
+Version: 0.1
+Summary: A CLI tool for EMBOSS stretcher alignments parsing and VCF analysis
+Author: nikolienka24
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: PyVCF3
+Requires-Dist: pandas
+Requires-Dist: python-Levenshtein
+
+# straln: Stretcher Alignment & Alternative Mutation Finder
+
+`straln` is a bioinformatics tool designed to parse `.aln` files in `markx0` format generated by 
+the **EMBOSS stretcher** tool. 
+It converts pairwise alignments into genomic formats (BEDPE/BED) 
+and can optionally intersect these results with VCF files to identify 
+alternative genomic variations nearby.
+
+## Features
+* **Automated Parsing:** Converts EMBOSS stretcher `.aln` format to `BEDPE` and two separate `BED`.
+* **Coordinate Mapping:** Automatically extracts starting offsets from alignment headers or allows manual overrides.
+* **Mutation Analysis:** Compares alignment gaps/mismatches with a VCF file to find alternative mutations within a specified window.
+* **Refined Output:** Joins consecutive alignment blocks for cleaner downstream analysis.
+
+## Installation
+
+Since the project uses `setuptools`, you can install it in editable mode:
+
+```bash
+# From the root of the project (where setup.py is located)
+pip install -e .
+```
+
+```bash
+# Getting Help
+straln --help
+# only parse the alignment
+straln my_alignment.aln -o ./output_folder
+# parse alignment and find alternative mutations from a VCF (when using -vcf parameter -c is mandatory)
+straln my_alignment.aln -vcf variations.vcf -c 17 -d 150 -o ./output_folder
+```
+
+### Output files
+The tool generates the following files in the specified output folder:
+
+* **`parsed.bedpe`**: Raw alignment blocks in BEDPE format.
+* **`parsed.joined.bedpe`**: Merged consecutive alignment blocks for easier visualization of londer indels.
+* **`seq1.bed` / `seq2.bed`**: Separate tracks for each sequence.
+* **`stats.txt`**: A summary file containing the alignment length, number of mismatches, and total gaps.
+* **`alternative_mutations.csv`**: *(Generated only when using the `-vcf` flag)* A list of variants from your VCF file that were found near alignment discrepancies.

stralln-0.1/README.md

@@ -0,0 +1,40 @@
+# straln: Stretcher Alignment & Alternative Mutation Finder
+
+`straln` is a bioinformatics tool designed to parse `.aln` files in `markx0` format generated by 
+the **EMBOSS stretcher** tool. 
+It converts pairwise alignments into genomic formats (BEDPE/BED) 
+and can optionally intersect these results with VCF files to identify 
+alternative genomic variations nearby.
+
+## Features
+* **Automated Parsing:** Converts EMBOSS stretcher `.aln` format to `BEDPE` and two separate `BED`.
+* **Coordinate Mapping:** Automatically extracts starting offsets from alignment headers or allows manual overrides.
+* **Mutation Analysis:** Compares alignment gaps/mismatches with a VCF file to find alternative mutations within a specified window.
+* **Refined Output:** Joins consecutive alignment blocks for cleaner downstream analysis.
+
+## Installation
+
+Since the project uses `setuptools`, you can install it in editable mode:
+
+```bash
+# From the root of the project (where setup.py is located)
+pip install -e .
+```
+
+```bash
+# Getting Help
+straln --help
+# only parse the alignment
+straln my_alignment.aln -o ./output_folder
+# parse alignment and find alternative mutations from a VCF (when using -vcf parameter -c is mandatory)
+straln my_alignment.aln -vcf variations.vcf -c 17 -d 150 -o ./output_folder
+```
+
+### Output files
+The tool generates the following files in the specified output folder:
+
+* **`parsed.bedpe`**: Raw alignment blocks in BEDPE format.
+* **`parsed.joined.bedpe`**: Merged consecutive alignment blocks for easier visualization of londer indels.
+* **`seq1.bed` / `seq2.bed`**: Separate tracks for each sequence.
+* **`stats.txt`**: A summary file containing the alignment length, number of mismatches, and total gaps.
+* **`alternative_mutations.csv`**: *(Generated only when using the `-vcf` flag)* A list of variants from your VCF file that were found near alignment discrepancies.

stralln-0.1/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "stralln"
+version = "0.1"
+description = "A CLI tool for EMBOSS stretcher alignments parsing and VCF analysis"
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [
+    { name = "nikolienka24" }
+]
+
+dependencies = [
+    "PyVCF3",
+    "pandas",
+    "python-Levenshtein",
+]
+
+[project.scripts]
+straln = "stretcher_parser.__main__:main"
+
+[tool.setuptools]
+packages = ["stretcher_parser"]

stralln-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

stralln-0.1/setup.py

@@ -0,0 +1,17 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="straln",
+    version="0.1",
+    packages=find_packages(),
+    install_requires=[
+        "PyVCF3",
+        "pandas",
+        "Levenshtein"
+    ],
+    entry_points={
+        'console_scripts': [
+            'straln=stretcher_parser.__main__:main',
+        ],
+    },
+)

stralln-0.1/stralln.egg-info/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: stralln
+Version: 0.1
+Summary: A CLI tool for EMBOSS stretcher alignments parsing and VCF analysis
+Author: nikolienka24
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: PyVCF3
+Requires-Dist: pandas
+Requires-Dist: python-Levenshtein
+
+# straln: Stretcher Alignment & Alternative Mutation Finder
+
+`straln` is a bioinformatics tool designed to parse `.aln` files in `markx0` format generated by 
+the **EMBOSS stretcher** tool. 
+It converts pairwise alignments into genomic formats (BEDPE/BED) 
+and can optionally intersect these results with VCF files to identify 
+alternative genomic variations nearby.
+
+## Features
+* **Automated Parsing:** Converts EMBOSS stretcher `.aln` format to `BEDPE` and two separate `BED`.
+* **Coordinate Mapping:** Automatically extracts starting offsets from alignment headers or allows manual overrides.
+* **Mutation Analysis:** Compares alignment gaps/mismatches with a VCF file to find alternative mutations within a specified window.
+* **Refined Output:** Joins consecutive alignment blocks for cleaner downstream analysis.
+
+## Installation
+
+Since the project uses `setuptools`, you can install it in editable mode:
+
+```bash
+# From the root of the project (where setup.py is located)
+pip install -e .
+```
+
+```bash
+# Getting Help
+straln --help
+# only parse the alignment
+straln my_alignment.aln -o ./output_folder
+# parse alignment and find alternative mutations from a VCF (when using -vcf parameter -c is mandatory)
+straln my_alignment.aln -vcf variations.vcf -c 17 -d 150 -o ./output_folder
+```
+
+### Output files
+The tool generates the following files in the specified output folder:
+
+* **`parsed.bedpe`**: Raw alignment blocks in BEDPE format.
+* **`parsed.joined.bedpe`**: Merged consecutive alignment blocks for easier visualization of londer indels.
+* **`seq1.bed` / `seq2.bed`**: Separate tracks for each sequence.
+* **`stats.txt`**: A summary file containing the alignment length, number of mismatches, and total gaps.
+* **`alternative_mutations.csv`**: *(Generated only when using the `-vcf` flag)* A list of variants from your VCF file that were found near alignment discrepancies.

stralln-0.1/stralln.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+setup.py
+stralln.egg-info/PKG-INFO
+stralln.egg-info/SOURCES.txt
+stralln.egg-info/dependency_links.txt
+stralln.egg-info/entry_points.txt
+stralln.egg-info/requires.txt
+stralln.egg-info/top_level.txt
+stretcher_parser/__init__.py
+stretcher_parser/__main__.py
+stretcher_parser/parser.py
+stretcher_parser/reformat.py
+stretcher_parser/utils.py

stralln-0.1/stralln.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

stralln-0.1/stralln.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+straln = stretcher_parser.__main__:main

stralln-0.1/stralln.egg-info/requires.txt

@@ -0,0 +1,3 @@
+PyVCF3
+pandas
+python-Levenshtein

stralln-0.1/stralln.egg-info/top_level.txt

@@ -0,0 +1 @@
+stretcher_parser

stralln-0.1/stretcher_parser/__main__.py

@@ -0,0 +1,120 @@
+import sys
+import os
+import argparse
+
+import vcf
+import pandas as pd
+
+from . import parser, reformat
+from .utils import save_statistics, get_offsets_from_file
+from analysis import find_alternative_mutations
+
+
+def parse_arguments() -> argparse.Namespace:
+    parser_arg = argparse.ArgumentParser(
+        description="""
+    straln: Stretcher Alignment & Alternative Mutation Finder
+    ---------------------------------------------------------
+    Parses .aln files from EMBOSS stretcher into BEDPE/BED formats and optionally 
+    compares them with VCF files to identify alternative genomic variations.
+    """,
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+
+    # ----- POSITIONAL ARGUMENTS -----
+    parser_arg.add_argument("aln_input_file", help="path to the .aln alignment file from EMBOSS stretcher (.aln format)")
+
+    # ----- OPTIONAL ARGUMENTS -----
+    parser_arg.add_argument("-o", "--output_folder", type=str, default=None, help="path to output folder (default: current folder)")
+
+    # ----- MUTATION ANALYSIS GROUP (OPTIONAL) -----
+    mutation = parser_arg.add_argument_group('Alternative Mutation Analysis (Optional)')
+    mutation.add_argument(
+        "-vcf", "--vcf_input_file",
+        help="input VCF file, providing this triggers the search for alternative mutations"
+    )
+    parser_arg.add_argument(
+        "-c", "--chromosome", 
+        help="target chromosome (1-22, X, Y)")
+    mutation.add_argument(
+        "-d", "--distance", type=int, default=100,
+        help="window size (bp) for finding nearby alternative mutations (default: 100)"
+    )
+
+    # ----- ALIGNMENT METADATA GROUP -----
+    metadata = parser_arg.add_argument_group('Alignment Metadata & Offsets (Optional)')
+    metadata.add_argument("-s1", "--seq_name1", default="Seq1", help="label for the first sequence")
+    metadata.add_argument("-s2", "--seq_name2", default="Seq2", help="label for the second sequence")
+    metadata.add_argument("-off1", "--offset1", type=int, help="starting position for seq1 (if not provided, the tool automatically extracts it from the .aln header)")
+    metadata.add_argument("-off2", "--offset2", type=int, help="starting position for seq2 (if not provided, the tool automatically extracts it from the .aln header)")
+
+    return parser_arg.parse_args()
+
+
+def main() -> None:
+    args = parse_arguments()
+
+    # 0. parse input files =============================================================
+    aln_input_file = args.aln_input_file
+
+    vcf_input_file = None
+    chromosome = None
+    if args.vcf_input_file:
+        vcf_input_file = args.vcf_input_file
+        chromosome = args.chromosome
+
+    output_folder = "."
+    if args.output_folder:
+        output_folder = args.output_folder
+        os.makedirs(output_folder, exist_ok=True)
+
+    seq_name1, seq_name2 = "seq1", "seq2"
+    if args.seq_name1:
+        seq_name1 = args.seq_name1
+    if args.seq_name2:
+        seq_name2 = args.seq_name2
+
+    distance_threshold = None
+    if args.distance:
+        distance_threshold = args.distance
+
+    if args.offset1 is not None and args.offset2 is not None:
+        offset1 = args.offset1
+        offset2 = args.offset2
+    else:
+        # If one or both are missing, we fetch them from the alignment file
+        offset1, offset2 = get_offsets_from_file(aln_input_file)
+
+        # If the user provided one but not the other, the manual one takes precedence
+        if args.offset1 is not None:
+            offset1 = args.offset1
+        if args.offset2 is not None:
+            offset2 = args.offset2
+
+        print(f"Using offsets extracted from alignment header: {offset1}, {offset2}")
+
+    # 1. stretcher parser =================================================================
+    parsed_file = output_folder + "/parsed.bedpe"
+    length, mismatches, gaps = parser.run(aln_input_file, parsed_file, seq_name1, seq_name2, offset1, offset2)
+
+    output_stats = output_folder + "/stats.txt"
+    save_statistics(seq_name1, seq_name2, length, mismatches, gaps, output_stats)
+
+    # 2. join consecutive rows ============================================================
+    parsed_joined_file = output_folder + "/parsed.joined.bedpe"
+    reformat.join_consecutive_rows(parsed_file, parsed_joined_file)
+
+    # 3. convert bedpe to bed two separate bed files =======================================================
+    bed1, bed2 = output_folder + "/seq1.bed", output_folder + "/seq2.bed"                                       
+    reformat.bedpe_to_bed(parsed_joined_file, bed1, bed2)
+
+    # 4. find alternative mutations =======================================================
+    if vcf_input_file:
+        find_alternative_mutations.find(vcf_input_file, parsed_joined_file, output_folder, chromosome, distance_threshold)
+
+    # 5. print final information =======================================================
+    print("Output files saved to " + output_folder)
+
+
+if __name__ == "__main__":
+    main()

stralln-0.1/stretcher_parser/parser.py

@@ -0,0 +1,154 @@
+from typing import Tuple, List, Optional, Union
+from stretcher_parser.utils import get_offsets_from_file
+
+
+def _check_sequences(sequence_name1: str, sequence_name2: str,
+                     seq1_data: List[Union[str, int]], seq2_data: List[Union[str, int]],
+                     found_start: bool, buffer: List[str],
+                     prefix_a: Optional[str], prefix_b: Optional[str]) -> Tuple[str, int, int, int, bool, List[str], int, int, Optional[str], Optional[str]]:
+    """
+    Looks at the alignment letter-by-letter to find where the two sequences don't match.
+    It figures out the exact positions for mutations and handles insertions or deletions.
+    """
+    output = ""
+    p1, p2 = seq1_data[1], seq2_data[1]
+    seq1_chunk, seq2_chunk = seq1_data[0], seq2_data[0]
+
+    line_len, line_len_curr = 0, 0
+    line_mismatches, line_gaps = 0, 0
+
+    for a, b in zip(seq1_chunk, seq2_chunk):
+        if a != "-":
+            p1 += 1
+        if b != "-":
+            p2 += 1
+
+        if not found_start:
+            if a in ("A", "C", "G", "T") and b in ("A", "C", "G", "T"):
+                found_start = True
+            else:
+                continue
+
+        line_len_curr += 1
+
+        # 0-based BEDPE coordinates
+        pos1_start, pos1_end = p1 - 1, p1 - 1
+        pos2_start, pos2_end = p2 - 1, p2 - 1
+
+        if a != b:
+            if a != "-" and b == "-":  # deletion in seq2
+                out1 = prefix_a + a  # REF: prefix + deleted base(s)
+                pos1_end += 1
+                out2 = prefix_b  # ALT: prefix only
+            elif a == "-" and b != "-":  # deletion in seq1
+                out1 = prefix_a  # REF: prefix only
+                out2 = prefix_b + b  # ALT: prefix + inserted base(s)
+                pos2_end += 1
+            else:
+                # normal mismatch
+                out1 = a
+                out2 = b
+
+            buffer.append(
+                f"{sequence_name1}\t{pos1_start}\t{pos1_end}\t"
+                f"{sequence_name2}\t{pos2_start}\t{pos2_end}\t"
+                f"{out1}\t{out2}\n"
+            )
+
+            line_mismatches += 1
+            if a == "-" or b == "-":
+                line_gaps += 1
+
+        # Flush buffer on real aligned A/C/G/T pairs
+        if a in ("A", "C", "G", "T") and b in ("A", "C", "G", "T"):
+            output += "".join(buffer)
+            line_len += line_len_curr
+            line_len_curr = 0
+            buffer.clear()
+
+        if a in ("A", "C", "G", "T"):
+            prefix_a = a
+        if b in ("A", "C", "G", "T"):
+            prefix_b = b
+
+    return output, line_len, line_mismatches, line_gaps, found_start, buffer, p1, p2, prefix_a, prefix_b
+
+
+def _parse(input_file: str, output_file: str,
+           seq_name1: str, seq_name2:str,
+           offset_seq1: int = 0, offset_seq2: int = 0) -> Tuple[int, int, int]:
+    """
+    The main engine that opens the alignment file, skips the technical headers,
+    and reads the sequences line-by-line to find differences.
+    """
+
+    with open(input_file) as infile, open(output_file, 'w') as outfile:
+        # BEDPE header with 2 additional columns
+        outfile.write("chrom1\tstart1\tend1\tchrom2\tstart2\tend2\tnucleotide1\tnucleotide2\n")
+
+        found_start = False
+        buffer = []
+        seq_len, mismatches, gaps = 0, 0, 0
+
+        # read header
+        line = infile.readline()
+        while line.startswith("#"):
+            line = infile.readline()
+
+        line = infile.readline()
+        while line.startswith("#"):
+            line = infile.readline()
+
+        infile.readline()  # skip blank line at the end of header
+        # end read header
+
+        curr1, curr2 = offset_seq1, offset_seq2
+        prefix_a, prefix_b = None, None
+        while True:
+            if line.startswith("#") or not line:
+                break
+
+            seq1_line = infile.readline().strip().split()
+            infile.readline()  # match line
+            seq2_line = infile.readline().strip().split()
+            infile.readline()  # lower pos
+            infile.readline()  # blank line
+
+            if seq1_line[0].startswith("#") or seq2_line[0].startswith("#"):
+                break
+
+            seq1_seq = seq1_line[1]
+            seq2_seq = seq2_line[1]
+
+            if not seq2_seq:
+                break
+
+            out, line_length, mm_add, gaps_add, found_start, buffer, curr1, curr2, prefix_a, prefix_b = _check_sequences(
+                seq_name1, seq_name2,
+                [seq1_seq, curr1],
+                [seq2_seq, curr2],
+                found_start, buffer,
+                prefix_a, prefix_b
+            )
+            outfile.write(out)
+
+            seq_len += line_length
+            mismatches += mm_add
+            gaps += gaps_add
+
+            line = infile.readline()
+            if not line:
+                break
+
+        return seq_len, mismatches, gaps
+
+
+def run(in_file: str, out_file: str,
+        seq_name1: str, seq_name2: str,
+        offset1: int, offset2: int) -> Tuple[int, int, int]:
+    """
+    Starts the parsing process and returns a summary of the results,
+    including how long the sequences are and how many errors were found.
+    """
+    length, mismatches, gaps = _parse(in_file, out_file, seq_name1, seq_name2, offset1, offset2)
+    return length, mismatches, gaps

stralln-0.1/stretcher_parser/reformat.py

@@ -0,0 +1,118 @@
+from typing import List, TextIO
+
+### FORMAT CONVERSIONS ===========================================================
+def bedpe_to_bed(infile: str, out1: str, out2: str) -> None:
+    """
+    Splits the combined alignment file into two separate BED files,
+    one for each sequence, so they can be viewed individually.
+    """
+
+    with open(infile) as f, open(out1, "w") as bed1, open(out2, "w") as bed2:
+        header = next(f)
+        bed1.write("chrom\tstart\tend\tseq\n")
+        bed2.write("chrom\tstart\tend\tseq\n")
+
+        for line in f:
+            chrom1, start1, end1, chrom2, start2, end2, seq1, seq2 = line.rstrip().split("\t")
+            bed1.write(f"{chrom1}\t{start1}\t{end1}\t{seq1}\n")
+            bed2.write(f"{chrom2}\t{start2}\t{end2}\t{seq2}\n")
+
+
+### REFORMATTING =================================================================
+def _flush_buffer(buf: List[List[str]], out_fh: TextIO) -> None:
+    """
+    Merge consecutive positions in buffer and write a single BEDPE row.
+    - Coordinates: start = first position, end = last position
+    - Nucleotides: concatenate all nucleotides in the run, ignoring gaps
+    """
+    if not buf:
+        return
+
+    # assume that chrom1 and chrom2 are in the whole file same
+    chrom1 = buf[0][0]
+    chrom2 = buf[0][3]
+
+    # Get start/end coordinates for ref and alt
+    seq1, seq2 = "", ""
+    start1, end1 = None, None
+    start2, end2 = None, None
+    for idx, line in enumerate(buf):
+        if idx == 0:
+            start1 = line[1]
+            start2 = line[4]
+            seq1, seq2 = line[6], line[7]
+            continue
+
+        if len(line[6]) == 1 and len(line[7]) == 1:
+             seq1 += line[6]
+             seq2 += line[7]
+        elif len(line[6]) == 2 and len(line[7]) == 1:
+            seq1 += line[6][1]
+        elif len(line[6]) == 1 and len(line[7]) == 2:
+            seq2 += line[7][1]
+
+    end1, end2 = buf[-1][2], buf[-1][5]
+
+    out_fh.write(f"{chrom1}\t{start1}\t{end1}\t{chrom2}\t{start2}\t{end2}\t{seq1}\t{seq2}\n")
+
+
+def _is_consecutive(prev: List[str], curr: List[str]) -> bool:
+    """
+    Determine if two BEDPE rows are consecutive:
+    - consecutive in both sequences, or in ref-only or alt-only
+    """
+
+    prev1_start, prev1_end = prev[1], prev[2]
+    prev2_start, prev2_end = prev[4], prev[5]
+    curr1_start, curr1_end = curr[1], curr[2]
+    curr2_start, curr2_end = curr[4], curr[5]
+
+    # Both sequences advance
+    if int(prev1_end) == int(curr1_start) and int(prev2_end) + 1 == int(curr2_start) + 1:
+        return True
+    # Ref only
+    elif int(prev1_end) == int(curr1_start):
+        return True
+    # Alt only
+    elif int(prev2_end) == int(curr2_start):
+        return True
+
+    return False
+
+
+def join_consecutive_rows(input_file: str, output_file: str) -> None:
+    """
+    Reads through the alignment differences and merges nearby changes
+    into single rows. This makes the data much cleaner and easier to read.
+    """
+
+    with open(input_file, 'r') as in_fh, open(output_file, 'w') as out_fh:
+        out_fh.write("chrom1\tstart1\tend1\tchrom2\tstart2\tend2\tsequence1\tsequence2\n")
+
+        buffer = []
+        found_header = False
+        for line in in_fh:
+            if not found_header or not line.strip():
+                found_header = True
+                continue
+
+            row = line.strip().split("\t")
+            if len(row) < 8:
+                continue
+
+            # BEDPE row: chrom1, start1, end1, chrom2, start2, end2, nt1, nt2
+            chrom1, start1, end1, chrom2, start2, end2, nt1, nt2 = row
+            row_arr = [chrom1, start1, end1, chrom2, start2, end2, nt1, nt2]
+
+            if not buffer:
+                buffer.append(row_arr)
+                continue
+
+            if _is_consecutive(buffer[-1], row_arr):
+                buffer.append(row_arr)
+            else:
+                _flush_buffer(buffer, out_fh)
+                buffer = [row_arr]
+
+        # Flush remaining buffer
+        _flush_buffer(buffer, out_fh)

stralln-0.1/stretcher_parser/utils.py

@@ -0,0 +1,51 @@
+from typing import Tuple, Optional
+
+
+def save_statistics(seq_name1: str, seq_name2: str,
+                    length: int, mismatches: int, gaps: int,
+                    output_file: str) -> None:
+    """
+    Creates a summary report. It calculates the error percentages (mismatch and gap rates)
+    and saves all the final numbers into a text file.
+    """
+
+    with open(output_file, "w") as f:
+        f.write(f"Alignment statistics between '{seq_name1}' and '{seq_name2}':\n")
+        f.write(f"  Total aligned positions (excluding ignored ends): {length}\n")
+        f.write(f"  Base mismatches (including gaps): {mismatches}\n")
+        f.write(f"  Gaps detected: {gaps}\n")
+        if length > 0:
+            mismatch_rate = (mismatches + gaps) / length * 100
+            gap_rate = gaps / length * 100
+            f.write(f"  Mismatch rate (including gaps): {mismatch_rate:.8f}%\n")
+            f.write(f"  Gap rate: {gap_rate:.8f}%\n")
+
+
+def get_offsets_from_file(aln_file_path: str) -> Tuple[int, int]:
+    """
+    Reads the header of the Stretcher file to find the starting genomic positions.
+    It automatically figures out where your sequences begin on the chromosome.
+    """
+
+    offset_seq1 = None
+    offset_seq2 = None
+
+    with open(aln_file_path, "r") as f:
+        for line in f:
+            line = line.strip()
+            if line.startswith("# 1:"):
+                # Format: "# 1: 87413227-97757117"
+                parts = line.split(":")[1].strip().split("-")
+                offset_seq1 = int(parts[0])
+            elif line.startswith("# 2:"):
+                parts = line.split(":")[1].strip().split("-")
+                offset_seq2 = int(parts[0])
+
+            if offset_seq1 is not None and offset_seq2 is not None:
+                break
+
+    if offset_seq1 is None or offset_seq2 is None:
+        raise ValueError(f"Could not parse offsets from Stretcher file: {aln_file_path}")
+
+    return offset_seq1, offset_seq2
+