FastSTR 1.0.0__py3-none-any.whl

faststr/utils.py

@@ -0,0 +1,428 @@
+import math
+import numpy as np
+import regex
+from Bio import SeqIO
+
+
+# 获取每条染色体从start_index到end_index上的碱基序列
+def read_fasta(path, start_index=1, end_index=0):
+    sequences = []
+    with open(path, "r") as handle:
+        for record in SeqIO.parse(handle, "fasta"):
+            if end_index == 0:
+                record.seq = record.seq.upper()[start_index - 1:]
+            else:
+                record.seq = record.seq.upper()[start_index - 1:end_index]
+
+            sequences.append(record)
+    return sequences
+
+
+def make_sub_reads(gene_sequence, read_length, overlap_length):
+    sub_reads = []
+    if len(gene_sequence) <= read_length:
+        return [gene_sequence.seq]
+    # 滑动窗口提取sub_read
+    for start in range(0, (len(gene_sequence) // (read_length - overlap_length) + 1) * (read_length - overlap_length),
+                       read_length - overlap_length):
+        if start >= len(gene_sequence):
+            break
+        end = start + read_length
+        subsequence = gene_sequence.seq[start:min(end, len(gene_sequence))]
+        sub_reads.append(subsequence)
+
+    return sub_reads
+
+
+def get_anchors(sub_read):
+    anchor_dict = {i: set() for i in range(1, 9)}
+    anchor_mark_dict = {i: [0] * len(sub_read) for i in range(1, 9)}
+    same_bases = [[], [], [], []]
+    for p, c in enumerate(sub_read):
+        if c == 'A':
+            same_bases[0].append(p)
+        elif c == 'G':
+            same_bases[1].append(p)
+        elif c == 'C':
+            same_bases[2].append(p)
+        elif c == 'T':
+            same_bases[3].append(p)
+    for s_b in same_bases:
+        i = 0
+        for j in range(len(s_b)):
+            while s_b[j] - s_b[i] > 8:
+                i += 1
+            for k in range(i, j):
+                anchor_dict[s_b[j] - s_b[k]].add((s_b[k], s_b[j] - s_b[k]))
+                anchor_dict[s_b[j] - s_b[k]].add((s_b[j], s_b[j] - s_b[k]))
+                anchor_mark_dict[s_b[j] - s_b[k]][s_b[k]] = 1
+    return anchor_dict, anchor_mark_dict
+
+
+def if_motif_is_tr(motif):
+    if not motif:
+        return False
+    # 拼接字符串并移除首尾字符
+    doubled_motif = (motif + motif)[1:-1]
+    # 检查原字符串是否出现在移除首尾字符后的新字符串中
+    return motif in doubled_motif
+
+
+def tri_gram_model(sequence, n):
+    # 获取二元、三元计数和二元位置
+    tri_count = {}
+    bi_count = {'AA': 0, 'AG': 0, 'AC': 0, 'AT': 0, 'GA': 0, 'GG': 0, 'GC': 0, 'GT': 0, 'CA': 0, 'CG': 0, 'CC': 0,
+                'CT': 0, 'TA': 0, 'TG': 0, 'TC': 0, 'TT': 0}
+    bi_pos = {'AA': [], 'AG': [], 'AC': [], 'AT': [], 'GA': [], 'GG': [], 'GC': [], 'GT': [], 'CA': [], 'CG': [],
+              'CC': [], 'CT': [], 'TA': [], 'TG': [], 'TC': [], 'TT': []}
+    for i in range(len(sequence) - 2):
+        if not set(sequence[i:i + 3]).issubset({'A', 'G', 'T', 'C'}):
+            continue
+        if sequence[i:i + 3] not in tri_count:
+            tri_count[sequence[i:i + 3]] = 1
+        else:
+            tri_count[sequence[i:i + 3]] += 1
+        bi_pos[sequence[i:i + 2]].append(i)
+        bi_count[sequence[i:i + 2]] += 1
+        if i == len(sequence) - 3:
+            bi_pos[sequence[i + 1:i + 3]].append(i + 1)
+            bi_count[sequence[i + 1:i + 3]] += 1
+
+    # 根据种子获取备选motif
+    sorted_seed = sorted(bi_count, key=lambda x: bi_count[x], reverse=True)
+    if bi_count[sorted_seed[0]] < 2:
+        return None
+    # 如果motif长度为1
+    if n == 1:
+        return [sorted_seed[0][0]]
+    # 如果motif长度为2
+    if n == 2:
+        i = 0
+        while i < len(sorted_seed):
+            if sorted_seed[i][0] == sorted_seed[i][1] and bi_count[sorted_seed[i]] >= len(sequence) / 2:
+                return None
+            if sorted_seed[i][0] != sorted_seed[i][1] and bi_count[sorted_seed[i]] > 0:
+                return [sorted_seed[i]]
+            i += 1
+        return None
+    # 如果motif长度大于2小于7
+    motifs = set()
+    # true_motif = []
+    k = 0
+    while True:
+        max_seed = sorted_seed[k]
+        bipos_set = set(bi_pos[max_seed])
+
+        for pos in bi_pos[max_seed]:
+            if pos + n in bipos_set:
+                if if_motif_is_tr(sequence[pos:pos + n]):
+                    continue
+                if not set(sequence[pos:pos + n]).issubset({'A', 'G', 'T', 'C'}):
+                    continue
+                # if sequence[pos:pos + n] in m + m:
+                #     true_motif.append(sequence[pos:pos + n])
+                motifs.add(sequence[pos:pos + n])
+        if motifs and k == 2:
+            break
+        k += 1
+        if k > 15:
+            return None
+
+    # 计算各个motif的合理概率，得到最佳motif
+    tri_gram = {}
+    for tri, _ in tri_count.items():
+        if bi_count[tri[:2]] == 0:
+            continue
+        tri_gram[tri] = tri_count[tri] / bi_count[tri[:2]]
+    p_rationality = []
+    for mot in motifs:
+        p_r = 1
+        for b in range(n - 2):
+            p_r += math.log(tri_gram[mot[b:b + 3]])
+        p_rationality.append(p_r)
+    sorted_prationalty = sorted(p_rationality)
+    max_prationalty = sorted_prationalty[-1]
+    motifs = list(motifs)
+    alternative_motif = [str(motifs[index]) for index, value in enumerate(p_rationality) if value == max_prationalty]
+    final_motif = [alternative_motif[0]]
+    if len(alternative_motif) == 1:
+        return final_motif
+    for a_m in alternative_motif[1:]:
+        logo = 0
+        for f_m in final_motif:
+            if a_m in f_m + f_m:
+                logo = 1
+        if logo == 0:
+            final_motif.append(a_m)
+    return final_motif
+
+
+def get_realscan_sequence(sequence):
+    if len(sequence) < 40:
+        return sequence
+    elif len(sequence) < 800:
+        noisy_bases = round(len(sequence) * 0.05)
+        start_noisy_bases = noisy_bases // 2
+        end_noisy_bases = noisy_bases - start_noisy_bases
+        return sequence[start_noisy_bases:len(sequence) - end_noisy_bases]
+    else:
+        return sequence[20:len(sequence) - 20]
+
+
+def get_motif_marks(sequence, motif):
+    if len(motif) < 4:
+        pattern = f"({motif}){{s<=0}}"
+    elif len(motif) < 6:
+        pattern = f"({motif}){{s<=1}}"
+    else:
+        pattern = f"({motif}){{s<=2}}"
+    matches = regex.finditer(pattern, str(sequence))
+    positions = [match.start() for match in matches]
+    return positions
+
+
+def  high_motif_detection(sequence, n):
+    # 获取二元、三元计数和二元位置
+    tri_count = {}
+    bi_count = {'AA': 0, 'AG': 0, 'AC': 0, 'AT': 0, 'GA': 0, 'GG': 0, 'GC': 0, 'GT': 0, 'CA': 0, 'CG': 0, 'CC': 0,
+                'CT': 0, 'TA': 0, 'TG': 0, 'TC': 0, 'TT': 0}
+    bi_pos = {'AA': [], 'AG': [], 'AC': [], 'AT': [], 'GA': [], 'GG': [], 'GC': [], 'GT': [], 'CA': [], 'CG': [],
+              'CC': [], 'CT': [], 'TA': [], 'TG': [], 'TC': [], 'TT': []}
+    base_de_bruijn = np.zeros((4, 4))
+    base_mark = {'A': 0, 'G': 1, 'C': 2, 'T': 3}
+    base_annotation = {0: 'A', 1: 'G', 2: 'C', 3: 'T'}
+    for i in range(len(sequence) - 2):
+        if i > 0 and set(sequence[i - 1:i + 1]).issubset({'A', 'G', 'T', 'C'}):
+            base_de_bruijn[base_mark[sequence[i - 1]]][base_mark[sequence[i]]] += 1
+        if not set(sequence[i:i + 3]).issubset({'A', 'G', 'T', 'C'}):
+            continue
+        if sequence[i:i + 3] not in tri_count:
+            tri_count[sequence[i:i + 3]] = 1
+        else:
+            tri_count[sequence[i:i + 3]] += 1
+        bi_pos[sequence[i:i + 2]].append(i)
+        bi_count[sequence[i:i + 2]] += 1
+        if i == len(sequence) - 3:
+            bi_pos[sequence[i + 1:i + 3]].append(i + 1)
+            bi_count[sequence[i + 1:i + 3]] += 1
+            base_de_bruijn[base_mark[sequence[i]]][base_mark[sequence[i + 1]]] += 1
+            base_de_bruijn[base_mark[sequence[i + 1]]][base_mark[sequence[i + 2]]] += 1
+
+    # 根据种子获取备选motif
+    sorted_seed = sorted(bi_count, key=lambda x: bi_count[x], reverse=True)
+    if bi_count[sorted_seed[0]] < 2:
+        return None
+
+    motifs = set()
+    k = 0
+    while True:
+        max_seed = sorted_seed[k]
+        bipos_set = set(bi_pos[max_seed])
+
+        for pos in bi_pos[max_seed]:
+            if pos + n in bipos_set:
+                if if_motif_is_tr(sequence[pos:pos + n]):
+                    continue
+                if not set(sequence[pos:pos + n]).issubset({'A', 'G', 'T', 'C'}):
+                    continue
+                motifs.add(sequence[pos:pos + n])
+        if motifs and k == 2:
+            break
+        k += 1
+        if k > 15:
+            return None
+
+    # 计算各个motif的合理概率，得到最佳motif
+    tri_gram = {}
+    for tri, _ in tri_count.items():
+        if bi_count[tri[:2]] == 0:
+            continue
+        tri_gram[tri] = tri_count[tri] / bi_count[tri[:2]]
+    p_rationality = []
+    for mot in motifs:
+        p_r = 1
+        for b in range(n - 2):
+            p_r += math.log(tri_gram[mot[b:b + 3]])
+        p_rationality.append(p_r)
+    sorted_prationalty = sorted(p_rationality)
+    max_prationalty = sorted_prationalty[-1]
+    motifs_mar = []
+    motifs = list(motifs)
+    arfa = 0
+    if n == 5:
+        arfa = 0.3
+    elif n == 6:
+        arfa = 0.4
+    elif n == 7:
+        arfa = 0.8
+    else:
+        arfa = 1
+    for inde, mot in enumerate(motifs):
+        if max_prationalty - p_rationality[inde] <= arfa:
+            motifs_mar.append(mot)
+
+    # copy_vector_variance = []
+    # # copy = round(len(sequence) / n)
+    # copy = estimated_copy_number(sequence, n, base_de_bruijn)
+    # for mot in motifs_mar:
+    #     mot_copy_vector_variance = get_copy_vector(mot, n, copy, base_de_bruijn, base_mark)
+    #     if mot_copy_vector_variance != -1:
+    #         copy_vector_variance.append(mot_copy_vector_variance)
+    #
+    # if copy_vector_variance == []:
+    #     return None
+    # min_variance = min(copy_vector_variance)
+    # alternative_motif = [str(motifs_mar[index]) for index, value in enumerate(copy_vector_variance) if
+    #                      value == min_variance]
+    #
+    # final_motif = [alternative_motif[0]]
+    # if len(alternative_motif) == 1:
+    #     return final_motif
+    # for a_m in alternative_motif[1:]:
+    #     logo = 0
+    #     for f_m in final_motif:
+    #         if a_m in f_m + f_m:
+    #             logo = 1
+    #     if logo == 0:
+    #         final_motif.append(a_m)
+
+    copy = estimated_copy_number(sequence, n, base_de_bruijn)
+    Frequency = []
+    for mot in motifs_mar:
+        Frequency.append(calculate_base_frequencye(mot, copy, base_de_bruijn, base_mark))
+
+    max_frequency = max(Frequency)
+    alternative_motif = []
+    for index, value in enumerate(Frequency):
+        if value == max_frequency:
+            alternative_motif.append(str(motifs_mar[index]))
+
+    final_motif = [alternative_motif[0]]
+    if len(alternative_motif) == 1:
+        return final_motif
+    for a_m in alternative_motif[1:]:
+        logo = 0
+        for f_m in final_motif:
+            if a_m in f_m + f_m:
+                logo = 1
+        if logo == 0:
+            final_motif.append(a_m)
+    if len(final_motif) > 3:
+        copy = len(sequence) // n
+        Frequency = []
+        for mot in motifs_mar:
+            Frequency.append(calculate_base_frequencye(mot, copy, base_de_bruijn, base_mark))
+
+        max_frequency = max(Frequency)
+        alternative_motif = []
+        for index, value in enumerate(Frequency):
+            if value == max_frequency:
+                alternative_motif.append(str(motifs_mar[index]))
+
+        final_motif = [alternative_motif[0]]
+        if len(alternative_motif) == 1:
+            return final_motif
+        for a_m in alternative_motif[1:]:
+            logo = 0
+            for f_m in final_motif:
+                if a_m in f_m + f_m:
+                    logo = 1
+            if logo == 0:
+                final_motif.append(a_m)
+
+    return final_motif
+
+
+def estimated_copy_number(sequence, n, base_de_bruijn):
+    copy = len(sequence) // n
+    # 展开数组为一维
+    flattened = base_de_bruijn.flatten()
+    # 获取最大的前8个数
+    largest_eight = np.sort(flattened)[-8:][::-1]
+    large = largest_eight[0]
+    for i in range(1, n):
+        if i == n - 1 or largest_eight[i] < copy:
+            small = math.ceil(sum(largest_eight[:n]) / n)
+            break
+        if large - largest_eight[i] >= copy:
+            small = largest_eight[i]
+            break
+
+    common_divisor = large - small
+    max_common_divisor = min(common_divisor, small)
+    while max_common_divisor >= copy:
+        if small != max_common_divisor:
+            common_divisor = max(max_common_divisor, small) - min(small, max_common_divisor)
+            small = min(small, max_common_divisor)
+            max_common_divisor = min(common_divisor, small)
+        else:
+            if max_common_divisor % copy == 0:
+                max_common_divisor = copy
+                break
+            max_common_divisor = math.ceil(max_common_divisor / round(max_common_divisor / copy))
+            break
+    return math.ceil(max_common_divisor * 0.5 + copy * 0.5)
+
+
+def calculate_base_frequencye(motif, copy, base_de_bruijn, base_mark):
+    base_de_bruijn = base_de_bruijn.copy()
+    base_frequency = 0
+    for i in range(1, len(motif)):
+        if base_de_bruijn[base_mark[motif[i - 1]]][base_mark[motif[i]]] >= copy:
+            base_frequency += copy
+            base_de_bruijn[base_mark[motif[i - 1]]][base_mark[motif[i]]] -= copy
+        else:
+            if base_de_bruijn[base_mark[motif[i - 1]]][base_mark[motif[i]]] >= 0.6 * copy:
+                base_frequency += base_de_bruijn[base_mark[motif[i - 1]]][base_mark[motif[i]]]
+            else:
+                base_frequency += 0
+            if base_de_bruijn[base_mark[motif[i - 1]]][base_mark[motif[i]]] > 0:
+                base_de_bruijn[base_mark[motif[i - 1]]][base_mark[motif[i]]] = 0
+
+    return base_frequency
+
+
+def get_copy_vector(motif, n, copy, base_de_bruijn, base_mark):
+    motif_base_de_bruijn = np.zeros((4, 4))
+    for i in range(1, n):
+        motif_base_de_bruijn[base_mark[motif[i - 1]]][base_mark[motif[i]]] += 1
+
+    copy_vector = []
+    for r in range(4):
+        for l in range(4):
+            if motif_base_de_bruijn[r][l] > 0:
+                copy_vector.append(base_de_bruijn[r][l] / motif_base_de_bruijn[r][l])
+
+    return np.mean((np.array(copy_vector) - copy) ** 2)
+
+
+def find_most_frequent_substring_given(long_seq, four_mer_marker, k):
+    freq_map = {}  # 字符串 -> 频数
+    positions_map = {}  # 字符串 -> 出现位置列表
+    max_count = 0
+    most_frequent_string = ""
+
+    # Convert short_strings list to a set for O(1) lookup
+    short_strings_set = set(four_mer_marker)
+
+    # Traverse all substrings of length k using sliding window
+    for i in range(len(long_seq) - k + 1):
+        substring = long_seq[i:i + k]
+
+        # Only count the substring if it is in the set of given short strings
+        if substring in short_strings_set:
+            # Update frequency map
+            if substring in freq_map and i - positions_map[substring][-1] >= k:
+                freq_map[substring] += 1
+                positions_map[substring].append(i)
+            elif substring not in freq_map:
+                freq_map[substring] = 1
+                positions_map[substring] = [i]
+
+            # Update the most frequent substring if needed
+            if freq_map[substring] > max_count:
+                max_count = freq_map[substring]
+                most_frequent_string = substring
+
+    # Return the most frequent substring and its positions
+    return most_frequent_string, positions_map[most_frequent_string]

faststr-1.0.0.dist-info/METADATA

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: FastSTR
+Version: 1.0.0
+Summary: FastSTR: A high-performance tool for short tandem repeat (STR) detection and analysis from genome assemblies.
+Author-email: Wen Long <wenlong2024@mail.nwpu.edu.cn>
+Maintainer-email: Wen Long <wenlong2024@mail.nwpu.edu.cn>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/XL-BioGroup/FastSTR
+Project-URL: Repository, https://github.com/XL-BioGroup/FastSTR
+Project-URL: Issues, https://github.com/XL-BioGroup/FastSTR/issues
+Keywords: tandem repeat,STR,genome,bioinformatics,sequence alignment
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: biopython==1.83
+Requires-Dist: numpy==1.26.0
+Requires-Dist: pandas==2.2.2
+Requires-Dist: regex==2024.9.11
+Requires-Dist: scikit-learn==1.5.2
+
+# 🧬 FastSTR
+
+**FastSTR** — Ultra-fast and accurate identification of Short Tandem Repeats (STRs) from long-read DNA sequences. Developed for genome-wide STR detection, consensus construction, and comparative STR analysis.
+
+---
+
+## 📘 Table of Contents
+1. [Overview](#overview)
+2. [Installation](#installation)
+3. [Quick Start](#quick-start)
+4. [Command Line Options](#command-line-options)
+5. [Input & Output](#input--output)
+6. [Usage](#usage)
+7. [Performance](#performance)
+8. [Citation](#citation)
+9. [License](#license)
+10. [Changelog](#changelog)
+
+
+---
+
+## 🌍 Overview
+
+**FastSTR** is a novel and efficient tool for de novo detection of short tandem repeats (STRs) in genomic sequences. It combines fast motif recognition with accurate sequence alignment to achieve both high precision and completeness in STR identification. FastSTR is optimized for large-scale genomic datasets and enables rapid detection of repetitive elements without relying on predefined motif libraries or fixed repeat-length thresholds.
+
+Compared to classical tools like **TRF**, **T-reks**, and **TRASH**, FastSTR achieves:
+
+- ⚡ **High-speed parallel processing** — Processes genomic fragments in parallel, achieving **up to 10× faster runtime**.  
+- 🧠 **Context-aware motif recognition** — Uses an **N-gram + Markov** model to identify representative motifs without predefined motif libraries.  
+- 🧩 **Segmented global alignment** — Efficiently handles **ultra-long or complex STRs** while maintaining base-level precision.  
+- 🔍 **Smart interval merging** — Applies an **interval-gain decision** strategy to accurately resolve overlapping STRs.  
+- 🧬 **Enhanced detection in complex regions** — Identifies **confounding or nested repeat regions** (e.g., centromeric satellites) with a novel **density-based concentration test**.  
+- 💾 **Lightweight & scalable** — Requires few dependencies, easy to install and run, and supports **multiple operating systems**.  
+
+---
+
+## ⚙️ Installation
+
+### Option 1: Install via `pip`
+ 
+```bash
+pip install faststr
+```
+
+### Option 2: Install via `conda`
+*(coming soon)*  
+```bash
+conda install -c bioconda faststr
+```
+
+### Option 3: Local installation (development)
+```bash
+git clone https://github.com/yourname/faststr.git
+cd faststr
+pip install -e .
+```
+
+---
+
+## 🚀 Quick Start
+
+### Basic Command
+
+```bash
+faststr [--strict | --normal | --loose] [--default] genome.fa
+```
+
+### Example
+
+```bash
+faststr --strict --default genome.fa
+```
+
+This runs FastSTR in **strict mode** using the **default model** to identify STRs in the `genome.fa` file.
+
+---
+
+## ⚡ Command Line Options
+
+| Argument | Type | Default | Description |
+|-----------|------|----------|-------------|
+| `match` | int | 2 | Match score |
+| `mismatch` | int | 5 | Mismatch score |
+| `gap_open` | int | 7 | Gap opening penalty |
+| `gap_extend` | int | 3 | Gap extension penalty |
+| `p_indel` | int | 15 | Indel percentage threshold |
+| `p_match` | int | 80 | Match percentage threshold |
+| `score` | int | 50 | Alignment score threshold |
+| `quality_control` | bool | False | Enable read-level quality control |
+| `DNA_file` | str | — | Path to DNA FASTA input |
+| `-f` | str | — | Output directory |
+| `-s` | int | 1 | Start index |
+| `-e` | int | 0 | End index |
+| `-l` | int | 15000 | Sub-read length |
+| `-o` | int | 1000 | Overlap length |
+| `-p` | int | 1 | Number of CPU cores |
+| `-b` | float | 0.045 | Motif coverage threshold |
+
+---
+
+## 🧠 Alignment Modes
+
+| Mode | Description |
+|------|--------------|
+| `--strict` | High precision, recommended for curated assemblies |
+| `--normal` | Balanced mode, suitable for most datasets |
+| `--loose` | High sensitivity, tolerant of mismatches |
+
+---
+
+## 🧬 Model Presets
+
+| Preset | Description |
+|---------|-------------|
+| `--default` | Standard scoring model |
+| *(future)* `--sensitive` | Optimized for noisy long reads |
+| *(future)* `--speed` | Optimized for large-scale detection |
+
+---
+
+## 📥 Input & Output
+
+### Input
+- DNA sequences in **FASTA** format
+
+### Output
+| File Pattern   | Description |
+|----------------|-------------|
+| `*detail.dat`  | Contains all STR positions and motifs, quality statistics for each STR, and STR counts per chromosome. |
+| `*align.dat`   | Detailed alignment of all STRs against reference STRs, including mismatches and indels. |
+| `*.csv`        | Merged STR intervals with representative motifs and summary statistics for each interval. |
+| `*.log`        | Processing logs. |
+
+---
+
+## 🧪 Usage
+
+### 1️⃣ Identify STRs in a genome
+```bash
+faststr --normal --default human_genome.fa
+```
+
+### 2️⃣ Use multiple cores
+```bash
+faststr --strict --default genome.fa -p 8
+```
+
+---
+
+## 📈 Performance
+
+| Dataset             | Genome Size | Tool   | Runtime   | Recall | Precision |
+|--------------------|------------|--------|-----------|--------|-----------|
+| Human (T2T)        | 2.94 G     | TRF    | 18 h 31 min | -      | -         |
+|                    |            | FastSTR| 1 h 13 min  | 0.950  | 0.994     |
+| Mouse (GRCm39)     | 2.57 G     | TRF    | 1 h 41 min  | -      | -         |
+|                    |            | FastSTR| 38 min      | 0.966  | 0.997     |
+| Zebrafish (GRCz11) | 1.58 G     | TRF    | 2 h 51 min  | -      | -         |
+|                    |            | FastSTR| 25 min      | 0.945  | 0.998     |
+
+*Note: TRF is used as the ground-truth. FastSTR runs based on 72 CPUs.*
+
+
+---
+
+## 📚 Citation
+
+If you use **FastSTR** in your research, please cite:
+
+> Xingyu Liao *et al.*,  
+> **Efficient Identification of Short Tandem Repeats via Context-Aware Motif Discovery and Ultra-Fast Sequence Alignment**,  
+> *Nat. Methods*, 2025.
+
+---
+
+
+## 📄 License
+
+This project is licensed under the **MIT License**.  
+See [LICENSE](LICENSE) for more details.
+
+---
+
+## 🧾 Changelog
+
+### v1.0.0 (2025)
+- Initial release of FastSTR
+- Supports three alignment modes and one default model
+- Implemented parallel computation
+- Added `.csv`, `.dat`, `.log` outputs
+---
+
+
+
+
+

faststr-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+faststr/Segmented_Global_Alignment.py,sha256=iqPhqCNyL2N52sZwCZr5gSzdUTgmpQ_vunszW-4yGfM,26165
+faststr/__init__.py,sha256=-brodmEr8X1HxTfVQ7g5BXYbHDRWV52VGpxfoAlXLAI,46
+faststr/get_subread_trs.py,sha256=B3Yzk9_gxNq1oVDLnx2O4zoSMe3pjD7Ax_tfDQOIe9k,1325
+faststr/main.py,sha256=zkIH0faI4zj9P3CBkoWK0UpPV35GQhGyYZCFBMafhDg,16841
+faststr/make_consensus_TRs.py,sha256=GtixIOCCv_CtmPw0XrzVUHXRAKE7mZD7OpAh5ZUIOvg,20274
+faststr/scan_subread.py,sha256=v7yI3h1SKPnus2EIh2HGP17L40ZvTzq62VBUQioN41s,18030
+faststr/trs_align.py,sha256=wJoOqGqeAd5tyeblB5qbonMF6pmvG2QVI-ckM4MSFz8,37750
+faststr/utils.py,sha256=KZO7qUcRnD-CWZUuoCHoIGECYw9gdx_nbNF8kol0vkQ,16018
+faststr-1.0.0.dist-info/METADATA,sha256=qKCq0XkVMVSMu70jVBD5nvBgf03D8R0BbgLdAZ8h9Cc,7093
+faststr-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+faststr-1.0.0.dist-info/entry_points.txt,sha256=U2IgRO55zTgGvY5CxxQd05GEK7OdgUptGzXOWtsWrH4,46
+faststr-1.0.0.dist-info/top_level.txt,sha256=289H-XYZbLnN6h63Kc0OZw0tSZ-RMaSovsW-MP8kkk4,8
+faststr-1.0.0.dist-info/RECORD,,

faststr-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

faststr-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+faststr = faststr.main:main

faststr-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+faststr