gffkit 0.1.0__tar.gz → 0.3__tar.gz

{gffkit-0.1.0/src/gffkit.egg-info → gffkit-0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gffkit
-Version: 0.1.0
+Version: 0.3
 Summary: Region-aware GFF annotation integration toolkit
 Author: Qunjie Zhang
 License: MIT

{gffkit-0.1.0 → gffkit-0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gffkit"
-version = "0.1.0"
+version = "0.3"
 description = "Region-aware GFF annotation integration toolkit"
 readme = "README.md"
 requires-python = ">=3.8"

{gffkit-0.1.0 → gffkit-0.3}/src/gffkit/__init__.py

@@ -1,3 +1,3 @@
 """gffkit: region-aware GFF annotation integration utilities."""
 
-__version__ = "0.1.0"
+__version__ = "0.3"

{gffkit-0.1.0 → gffkit-0.3}/src/gffkit/complement_annotations.py

@@ -20,13 +20,14 @@ agat_sp_complement_annotations.pl 的 Python 改写版（纯 Python，不调用
 
 from __future__ import annotations
 
-import argparse
-import copy
-import re
-import sys
-from collections import defaultdict
-from dataclasses import dataclass, field
-from typing import Dict, Iterable, List, Optional, Tuple
+import argparse
+import copy
+import re
+import sys
+from collections import defaultdict
+from dataclasses import dataclass, field
+from concurrent.futures import ThreadPoolExecutor
+from typing import Dict, Iterable, List, Optional, Tuple
 
 
 GENE_LIKE_TYPES = {
@@ -570,16 +571,81 @@ def cds_size_nt(root: Feature) -> int:
     return total
 
 
-def any_feature_overlap(features_a: List[Feature], features_b: List[Feature]) -> bool:
-    """判断两组特征中是否存在任意一对重叠。"""
-    for fa in features_a:
-        for fb in features_b:
-            if fa.overlaps(fb):
-                return True
-    return False
-
-
-def should_add_root(add_root: Feature, ref_roots: List[Feature], size_min: int) -> bool:
+def any_feature_overlap(features_a: List[Feature], features_b: List[Feature]) -> bool:
+    """判断两组特征中是否存在任意一对重叠。"""
+    for fa in features_a:
+        for fb in features_b:
+            if fa.overlaps(fb):
+                return True
+    return False
+
+
+def split_source_names(source: str) -> List[str]:
+    """把第二列 source 拆成有序、去重的软件名列表。"""
+    names: List[str] = []
+    for item in re.split(r"[,|+]", source):
+        name = item.strip()
+        if name and name != "." and name not in names:
+            names.append(name)
+    return names
+
+
+def collect_source_names(root: Feature) -> List[str]:
+    """收集一棵特征树中出现过的 source 名称，保持首次出现顺序。"""
+    names: List[str] = []
+    for feat in root.iter_all():
+        for name in split_source_names(feat.source):
+            if name not in names:
+                names.append(name)
+    return names
+
+
+def merge_source_names(*source_groups: Iterable[str]) -> str:
+    """合并多组 source 名称并返回可写入 GFF 第二列的字符串。"""
+    merged: List[str] = []
+    for group in source_groups:
+        for source in group:
+            for name in split_source_names(source):
+                if name not in merged:
+                    merged.append(name)
+    return "|".join(merged) if merged else "."
+
+
+def set_tree_source(root: Feature, source: str) -> None:
+    """把整棵特征树的第二列 source 统一为指定值。"""
+    for feat in root.iter_all():
+        feat.source = source
+
+
+def update_overlapping_sources(add_root: Feature, ref_roots: List[Feature]) -> List[Feature]:
+    """
+    对与 add_root 重叠的已有一级特征，合并双方软件来源并写回第二列。
+
+    返回发生重叠的参考一级特征列表，供后续补充判断复用。
+    """
+    overlapping_refs = [r for r in ref_roots if add_root.overlaps(r)]
+    if not overlapping_refs:
+        return []
+
+    add_sources = collect_source_names(add_root)
+    combined_sources: List[str] = []
+    for ref_root in overlapping_refs:
+        for source in collect_source_names(ref_root):
+            if source not in combined_sources:
+                combined_sources.append(source)
+    for source in add_sources:
+        if source not in combined_sources:
+            combined_sources.append(source)
+
+    merged_source = merge_source_names(combined_sources)
+    set_tree_source(add_root, merged_source)
+    for ref_root in overlapping_refs:
+        set_tree_source(ref_root, merged_source)
+
+    return overlapping_refs
+
+
+def should_add_root(add_root: Feature, ref_roots: List[Feature], size_min: int) -> bool:
     """
     按原脚本说明中的规则，判断 add_root 是否应该加入参考注释。
 
@@ -596,7 +662,7 @@ def should_add_root(add_root: Feature, ref_roots: List[Feature], size_min: int)
     - 只要有一个重叠关系不满足条件，就不加入整个一级特征。
       这与原说明中“只要有一个 isoform 重叠，就阻止整个 gene 加入”的精神一致。
     """
-    overlapping_refs = [r for r in ref_roots if add_root.overlaps(r)]
+    overlapping_refs = [r for r in ref_roots if add_root.overlaps(r)]
 
     # 情况 1：完全不与参考一级特征重叠
     if not overlapping_refs:
@@ -724,7 +790,7 @@ def uniquify_feature_tree(root: Feature, existing_ids: set, existing_names: set)
             existing_names.add(feat.name)
 
 
-def complement_annotations(ref_set: AnnotationSet, add_set: AnnotationSet, size_min: int) -> int:
+def complement_annotations(ref_set: AnnotationSet, add_set: AnnotationSet, size_min: int) -> int:
     """
     把 add_set 中满足条件的一级特征补充到 ref_set 中。
     返回值：实际添加的一级特征数量。
@@ -733,15 +799,16 @@ def complement_annotations(ref_set: AnnotationSet, add_set: AnnotationSet, size_
     existing_ids = ref_set.all_ids()
     existing_names = ref_set.all_names()
 
-    for add_root in sorted(
-        add_set.roots,
-        key=lambda x: (x.seqid, x.start, x.end, x.feature_type, x.id or "")
-    ):
-        if should_add_root(add_root, ref_set.roots, size_min):
-            cloned = add_root.deep_clone()
-            uniquify_feature_tree(cloned, existing_ids, existing_names)
-            ref_set.roots.append(cloned)
-            added_count += 1
+    for add_root in sorted(
+        add_set.roots,
+        key=lambda x: (x.seqid, x.start, x.end, x.feature_type, x.id or "")
+    ):
+        update_overlapping_sources(add_root, ref_set.roots)
+        if should_add_root(add_root, ref_set.roots, size_min):
+            cloned = add_root.deep_clone()
+            uniquify_feature_tree(cloned, existing_ids, existing_names)
+            ref_set.roots.append(cloned)
+            added_count += 1
 
     return added_count
 
@@ -777,7 +844,7 @@ def print_complement_resume(before_counts: Dict[str, Dict[str, int]],
         eprint("\nNow the data contains:")
 
 
-def build_arg_parser() -> argparse.ArgumentParser:
+def build_arg_parser() -> argparse.ArgumentParser:
     """构建命令行参数解析器。"""
     parser = argparse.ArgumentParser(
         description="用一个或多个注释文件去补充参考注释（Python 版，纯 Python，不调用 Perl）。"
@@ -814,12 +881,16 @@ def build_arg_parser() -> argparse.ArgumentParser:
         default=100,
         help="从 suspicious.tsv 读取区间时，start/end 两端各扩展的 bp 数，默认 100"
     )
-    parser.add_argument("--output", "--out", "-o", default=None, help="输出文件路径；默认输出到 STDOUT")
-    parser.add_argument(
-        "-v", "--verbose", type=int, default=1,
-        help="日志详细程度（0~4），这里只简单保留该参数接口，默认 1"
-    )
-    return parser
+    parser.add_argument("--output", "--out", "-o", default=None, help="输出文件路径；默认输出到 STDOUT")
+    parser.add_argument(
+        "-t", "--threads", type=int, default=1,
+        help="并行线程数；多个 --add 文件会并行预解析，但仍按输入顺序合并，默认 1"
+    )
+    parser.add_argument(
+        "-v", "--verbose", type=int, default=1,
+        help="日志详细程度（0~4），这里只简单保留该参数接口，默认 1"
+    )
+    return parser
 
 
 def parse_swap_regions(raw_regions: Optional[List[List[str]]]) -> List[SwapRegion]:
@@ -852,7 +923,7 @@ def parse_swap_regions(raw_regions: Optional[List[List[str]]]) -> List[SwapRegio
     return parsed
 
 
-def parse_swap_regions_from_tsv(tsv_path: str, flank_bp: int = 100) -> List[SwapRegion]:
+def parse_swap_regions_from_tsv(tsv_path: str, flank_bp: int = 100) -> List[SwapRegion]:
     """
     从 detect_bridge_merged_genes.py 产生的 suspicious.tsv 读取区间。
 
@@ -928,12 +999,26 @@ def parse_swap_regions_from_tsv(tsv_path: str, flank_bp: int = 100) -> List[Swap
                     f" 当前行内容为：{line}"
                 ) from exc
 
-    return regions
+    return regions
+
+
+def parse_add_files(add_files: List[str], threads: int) -> List[Tuple[str, AnnotationSet]]:
+    """并行预解析补充注释文件，返回顺序与命令行 --add 顺序一致。"""
+    threads = max(1, threads)
+    if threads == 1 or len(add_files) <= 1:
+        return [(path, parse_annotation_file(path)) for path in add_files]
+
+    with ThreadPoolExecutor(max_workers=min(threads, len(add_files))) as executor:
+        parsed_sets = list(executor.map(parse_annotation_file, add_files))
+    return list(zip(add_files, parsed_sets))
 
 
 def main() -> int:
     parser = build_arg_parser()
-    args = parser.parse_args()
+    args = parser.parse_args()
+
+    if args.threads < 1:
+        parser.error("--threads/-t 必须是正整数")
 
     try:
         swap_regions = parse_swap_regions(args.swap_region)
@@ -959,11 +1044,11 @@ def main() -> int:
         for region in swap_regions:
             eprint(f"  - {region.seqid}:{region.start}-{region.end}")
 
-    # 2) 按用户给定顺序，逐个补充
-    for next_file in args.add:
-        add_set = parse_annotation_file(next_file)
-        eprint(f"{next_file} parsed")
-        add_set.info()
+    # 2) 按用户给定顺序，逐个补充；多个输入文件可并行预解析
+    parsed_add_sets = parse_add_files(args.add, args.threads)
+    for next_file, add_set in parsed_add_sets:
+        eprint(f"{next_file} parsed")
+        add_set.info()
 
         before_counts = ref_set.level_counts()
 
@@ -998,4 +1083,4 @@ def main() -> int:
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    sys.exit(main())

{gffkit-0.1.0 → gffkit-0.3}/src/gffkit/detect_bridge_merged_genes.py

@@ -43,9 +43,10 @@ detect_bridge_merged_genes.py
     bridge_members
 """
 
-import argparse
-import sys
-from collections import defaultdict
+import argparse
+import sys
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor
 
 
 # ----------------------------
@@ -343,7 +344,7 @@ def read_gff3(gff_file):
 # 核心检测逻辑
 # ----------------------------
 
-def analyze_gene(
+def analyze_gene(
     gene,
     min_gap=10000,
     cluster_gap=2000,
@@ -432,7 +433,13 @@ def analyze_gene(
         "cluster_members": ";".join(cluster_member_strs),
         "bridge_members": ";".join(bridge_member_strs)
     }
-    return result
+    return result
+
+
+def analyze_gene_task(task):
+    """ThreadPoolExecutor 需要顶层函数；返回 (gene_id, result)。"""
+    gid, gene, params = task
+    return gid, analyze_gene(gene, **params)
 
 
 # ----------------------------
@@ -469,15 +476,24 @@ def main():
         default=1,
         help="至少多少条真实桥接 transcript 才输出，默认 1"
     )
-    parser.add_argument(
-        "--no-use-cds-if-no-exon",
-        action="store_true",
-        help="若 transcript 没有 exon，则不要回退使用 CDS"
-    )
-
-    args = parser.parse_args()
-
-    use_cds_if_no_exon = not args.no_use_cds_if_no_exon
+    parser.add_argument(
+        "--no-use-cds-if-no-exon",
+        action="store_true",
+        help="若 transcript 没有 exon，则不要回退使用 CDS"
+    )
+    parser.add_argument(
+        "-t", "--threads",
+        type=int,
+        default=1,
+        help="并行分析 gene 的线程数，默认 1"
+    )
+
+    args = parser.parse_args()
+
+    if args.threads < 1:
+        parser.error("--threads/-t 必须是正整数")
+
+    use_cds_if_no_exon = not args.no_use_cds_if_no_exon
 
     genes = read_gff3(args.input)
 
@@ -499,25 +515,30 @@ def main():
     n_total = 0
     n_flagged = 0
 
-    with open(args.output, "w", encoding="utf-8") as out:
-        out.write("\t".join(out_fields) + "\n")
-
-        for gid in sorted(genes.keys()):
-            gene = genes[gid]
-            n_total += 1
-
-            result = analyze_gene(
-                gene,
-                min_gap=args.min_gap,
-                cluster_gap=args.cluster_gap,
-                min_core_tx_per_cluster=args.min_core_tx_per_cluster,
-                min_bridge_count=args.min_bridge_count,
-                use_cds_if_no_exon=use_cds_if_no_exon
-            )
-
-            if result:
-                n_flagged += 1
-                out.write("\t".join(str(result[f]) for f in out_fields) + "\n")
+    analyze_params = {
+        "min_gap": args.min_gap,
+        "cluster_gap": args.cluster_gap,
+        "min_core_tx_per_cluster": args.min_core_tx_per_cluster,
+        "min_bridge_count": args.min_bridge_count,
+        "use_cds_if_no_exon": use_cds_if_no_exon,
+    }
+    sorted_genes = [(gid, genes[gid], analyze_params) for gid in sorted(genes.keys())]
+
+    if args.threads == 1:
+        analyzed = [analyze_gene_task(task) for task in sorted_genes]
+    else:
+        with ThreadPoolExecutor(max_workers=args.threads) as executor:
+            analyzed = list(executor.map(analyze_gene_task, sorted_genes))
+
+    with open(args.output, "w", encoding="utf-8") as out:
+        out.write("\t".join(out_fields) + "\n")
+
+        for gid, result in analyzed:
+            n_total += 1
+
+            if result:
+                n_flagged += 1
+                out.write("\t".join(str(result[f]) for f in out_fields) + "\n")
 
     sys.stderr.write(
         f"[INFO] Total genes checked: {n_total}\n"
@@ -527,4 +548,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

{gffkit-0.1.0 → gffkit-0.3}/src/gffkit/main.py

@@ -25,7 +25,7 @@ def _run_legacy_main(func: Callable[[], object], prog: str, args: List[str]) ->
 
 def cmd_detect_bridge(args: argparse.Namespace, extra: List[str]) -> int:
     from . import detect_bridge_merged_genes as mod
-    cli = ["-i", args.input, "-o", args.output]
+    cli = ["-i", args.input, "-o", args.output, "-t", str(args.threads)]
     cli += extra
     return _run_legacy_main(mod.main, "gffkit detect-bridge", cli)
 
@@ -37,6 +37,7 @@ def cmd_complement(args: argparse.Namespace, extra: List[str]) -> int:
         cli += ["--add", add_file]
     if args.output:
         cli += ["--output", args.output]
+    cli += ["-t", str(args.threads)]
     cli += extra
     return _run_legacy_main(mod.main, "gffkit complement", cli)
 
@@ -69,6 +70,7 @@ def cmd_integrate(args: argparse.Namespace, extra: List[str]) -> int:
         "--cluster-gap", str(args.cluster_gap),
         "--min-core-tx-per-cluster", str(args.min_core_tx_per_cluster),
         "--min-bridge-count", str(args.min_bridge_count),
+        "-t", str(args.threads),
     ]
     if args.no_use_cds_if_no_exon:
         detect_cli.append("--no-use-cds-if-no-exon")
@@ -84,6 +86,7 @@ def cmd_integrate(args: argparse.Namespace, extra: List[str]) -> int:
         "--swap_region_flank", str(args.swap_region_flank),
         "--size_min", str(args.size_min),
         "--output", str(merged_gff),
+        "-t", str(args.threads),
     ]
     ret = _run_legacy_main(complement_mod.main, "gffkit complement", complement_cli)
     if ret != 0:
@@ -120,6 +123,7 @@ def build_parser() -> argparse.ArgumentParser:
     )
     p.add_argument("-i", "--input", required=True, help="Input GFF3 file, usually Annotation A.")
     p.add_argument("-o", "--output", required=True, help="Output suspicious.tsv file.")
+    p.add_argument("-t", "--threads", type=int, default=1, help="Number of worker threads.")
     p.set_defaults(handler=cmd_detect_bridge)
 
     p = subparsers.add_parser(
@@ -130,6 +134,7 @@ def build_parser() -> argparse.ArgumentParser:
     p.add_argument("--ref", "-r", "-i", required=True, help="Reference GFF/GTF file.")
     p.add_argument("--add", "-a", action="append", required=True, help="Supplementary GFF/GTF file; can be repeated.")
     p.add_argument("--output", "--out", "-o", default=None, help="Output GFF3 path. Default: stdout.")
+    p.add_argument("-t", "--threads", type=int, default=1, help="Number of worker threads.")
     p.set_defaults(handler=cmd_complement)
 
     p = subparsers.add_parser(
@@ -162,6 +167,7 @@ def build_parser() -> argparse.ArgumentParser:
     p.add_argument("--min-core-tx-per-cluster", type=int, default=1, help="Minimum core transcripts per cluster.")
     p.add_argument("--min-bridge-count", type=int, default=1, help="Minimum true bridge transcripts required.")
     p.add_argument("--no-use-cds-if-no-exon", action="store_true", help="Do not use CDS when transcript has no exon.")
+    p.add_argument("-t", "--threads", type=int, default=1, help="Number of worker threads used by detect and complement steps.")
 
     p.add_argument("--swap-region-flank", type=int, default=100, help="Flanking bp added to suspicious regions.")
     p.add_argument("--size-min", type=int, default=0, help="Minimum CDS size for non-overlapping supplementary roots.")

{gffkit-0.1.0 → gffkit-0.3/src/gffkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gffkit
-Version: 0.1.0
+Version: 0.3
 Summary: Region-aware GFF annotation integration toolkit
 Author: Qunjie Zhang
 License: MIT

{gffkit-0.1.0 → gffkit-0.3}/src/gffkit.egg-info/SOURCES.txt

@@ -12,4 +12,5 @@ src/gffkit.egg-info/PKG-INFO
 src/gffkit.egg-info/SOURCES.txt
 src/gffkit.egg-info/dependency_links.txt
 src/gffkit.egg-info/entry_points.txt
-src/gffkit.egg-info/top_level.txt
+src/gffkit.egg-info/top_level.txt
+tests/test_complement_sources.py

gffkit-0.3/tests/test_complement_sources.py

@@ -0,0 +1,62 @@
+from gffkit.complement_annotations import complement_annotations, parse_annotation_file
+
+
+def test_overlapping_gene_sources_are_merged(tmp_path):
+    ref_gff = tmp_path / "ref.gff3"
+    add_gff = tmp_path / "add.gff3"
+
+    ref_gff.write_text(
+        "\n".join(
+            [
+                "##gff-version 3",
+                "chr1\tEviAnn\tgene\t100\t500\t.\t+\t.\tID=gene1",
+                "chr1\tEviAnn\tmRNA\t100\t500\t.\t+\t.\tID=tx1;Parent=gene1",
+                "chr1\tEviAnn\texon\t100\t500\t.\t+\t.\tID=exon1;Parent=tx1",
+                "",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    add_gff.write_text(
+        "\n".join(
+            [
+                "##gff-version 3",
+                "chr1\tANNEVO\tgene\t120\t480\t.\t+\t.\tID=gene2",
+                "chr1\tANNEVO\tmRNA\t120\t480\t.\t+\t.\tID=tx2;Parent=gene2",
+                "chr1\tANNEVO\texon\t120\t480\t.\t+\t.\tID=exon2;Parent=tx2",
+                "",
+            ]
+        ),
+        encoding="utf-8",
+    )
+
+    ref_set = parse_annotation_file(str(ref_gff))
+    add_set = parse_annotation_file(str(add_gff))
+
+    added = complement_annotations(ref_set, add_set, size_min=0)
+
+    assert added == 0
+    assert len(ref_set.roots) == 1
+    assert {feature.source for feature in ref_set.roots[0].iter_all()} == {"EviAnn|ANNEVO"}
+
+
+def test_non_overlapping_gene_keeps_single_source(tmp_path):
+    ref_gff = tmp_path / "ref.gff3"
+    add_gff = tmp_path / "add.gff3"
+
+    ref_gff.write_text(
+        "chr1\tEviAnn\tgene\t100\t200\t.\t+\t.\tID=gene1\n",
+        encoding="utf-8",
+    )
+    add_gff.write_text(
+        "chr1\tANNEVO\tgene\t400\t500\t.\t+\t.\tID=gene2\n",
+        encoding="utf-8",
+    )
+
+    ref_set = parse_annotation_file(str(ref_gff))
+    add_set = parse_annotation_file(str(add_gff))
+
+    added = complement_annotations(ref_set, add_set, size_min=0)
+
+    assert added == 1
+    assert [root.source for root in ref_set.roots] == ["EviAnn", "ANNEVO"]