gseda 0.0.1__tar.gz

gseda-0.0.1/.gitignore

@@ -0,0 +1,3 @@
+**/target/*
+ana/*
+*.png

gseda-0.0.1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.3
+Name: gseda
+Version: 0.0.1
+Summary: gsetl
+Project-URL: Homepage, https://github.com/keithyin/gsda
+Project-URL: Issues, https://github.com/keithyin/gsda/issues
+Author-email: keithyin <yinpenghhz@hotmail.com>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+gseda
+
+
+how to pack: https://cloud.tencent.com/developer/article/2401343

gseda-0.0.1/README.md

@@ -0,0 +1,4 @@
+gseda
+
+
+how to pack: https://cloud.tencent.com/developer/article/2401343

gseda-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "gseda"
+version = "0.0.1"
+authors = [
+  { name="keithyin", email="yinpenghhz@hotmail.com" },
+]
+description = "gsetl"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/keithyin/gsda"
+Issues = "https://github.com/keithyin/gsda/issues"
+
+# 构建后端，默认为 Hatchling
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

gseda-0.0.1/src/gseda/bam_filter/drop_multiple_mapping_reads.py

@@ -0,0 +1,47 @@
+import pysam
+from typing import List, Set
+import argparse
+import pysam.samtools
+from tqdm import tqdm
+
+
+def extract_non_multiple_mapping_reads(bam_file: str) -> Set[str]:
+    qname_cnts = {}
+    with pysam.AlignmentFile(filename=bam_file, mode="rb", threads=40) as bam_h:
+        for record in tqdm(
+            bam_h.fetch(), desc=f"extract_non_multiple_mapping_reads from {bam_file}"
+        ):
+            qname = record.query_name
+            if qname not in qname_cnts:
+                qname_cnts[qname] = 0
+            qname_cnts[qname] += 1
+    return set([qname for qname, cnt in qname_cnts.items() if cnt == 1])
+
+
+def dump_non_multiple_mapping_reads(bam_file: str, qname_set):
+    o_bam_file = "{}.non_multiple_mapping_reads.bam".format(
+        bam_file.rsplit(".", maxsplit=1)[0]
+    )
+
+    with pysam.AlignmentFile(filename=bam_file, mode="rb", threads=40) as bam_h:
+        with pysam.AlignmentFile(
+            filename=o_bam_file, mode="wb", threads=40, header=bam_h.header
+        ) as o_bam_h:
+            for record in tqdm(
+                bam_h.fetch(), desc=f"dump_non_multiple_mapping_reads to {o_bam_file}"
+            ):
+                if record.query_name in qname_set:
+                    o_bam_h.write(record)
+
+    pysam.samtools.index("-@", "40", "-b", o_bam_file)
+
+
+def main(args):
+    qname_set = extract_non_multiple_mapping_reads(args.bam)
+    dump_non_multiple_mapping_reads(args.bam, qname_set)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(prog="")
+    parser.add_argument("bam")
+    main(args=parser.parse_args())

gseda-0.0.1/src/gseda/bam_surgery/insert_cs_to_sbr_bam.py

@@ -0,0 +1,45 @@
+import pysam
+import os
+import sys
+from tqdm import tqdm
+import argparse
+
+pre_dir = os.path.abspath(__file__).rsplit("/", maxsplit=2)[0]
+sys.path.append(pre_dir)
+
+
+def insert_cs_to_sbr_bam(sbr_bam: str, smc_bam: str):
+    out_bam = "{}.with-cs.bam".format(sbr_bam.rsplit(".", maxsplit=1)[0])
+
+    with pysam.AlignmentFile(sbr_bam, mode="rb", threads=40, check_sq=False) as in_h:
+        with pysam.AlignmentFile(
+            out_bam, mode="wb", threads=40, check_sq=False, header=in_h.header
+        ) as out_h:
+            for record in tqdm(in_h.fetch(until_eof=True), desc=f"dumping1 {out_bam}"):
+                out_h.write(record)
+
+            with pysam.AlignmentFile(
+                smc_bam, mode="rb", threads=40, check_sq=False
+            ) as in_h:
+                for in_record in tqdm(
+                    in_h.fetch(until_eof=True), desc=f"dumping2 {out_bam}"
+                ):
+                    qname = in_record.query_name
+                    record = pysam.AlignedSegment()
+                    record.query_name = f"00_{qname}"
+                    record.query_sequence = in_record.query_sequence
+                    record.set_tag("ch", int(in_record.get_tag("ch")), value_type="I")
+                    out_h.write(record)
+
+
+def main(args):
+    insert_cs_to_sbr_bam(args.sbr_bam, args.smc_bam)
+    pass
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(prog="")
+    parser.add_argument("--sbr-bam", dest="sbr_bam")
+    parser.add_argument("--smc-bam", dest="smc_bam")
+
+    main(args=parser.parse_args())

gseda-0.0.1/src/gseda/bam_surgery/insert_ref_to_sbr_bam.py

@@ -0,0 +1,58 @@
+import pysam
+import os
+import sys
+from tqdm import tqdm
+import argparse
+
+pre_dir = os.path.abspath(__file__).rsplit("/", maxsplit=2)[0]
+sys.path.append(pre_dir)
+
+import gseda.utils as gseda_utils
+
+
+def insert_ref_to_sbr_bam(sbr_bam: str, smc2ref_bam: str, ref_file: str):
+    out_bam = "{}.with-ref.bam".format(sbr_bam.rsplit(".", maxsplit=1)[0])
+    ref_data = gseda_utils.read_fastx_file(ref_file)
+
+    channel_refs = {}
+    with pysam.AlignmentFile(smc2ref_bam, mode="rb", threads=40) as smc2ref_bam_h:
+        for record in tqdm(smc2ref_bam_h.fetch(), desc=f"extracting channel ref"):
+            ch = int(record.get_tag("ch"))
+            ref_start = record.reference_start
+            ref_end = record.reference_end
+            ref_name = record.reference_name
+            ref_len = len(ref_data[ref_name][0])
+
+            ref_start = max(0, ref_start - 10)
+            ref_end = min(ref_len, ref_end + 11)
+
+            ref_sub_seq = ref_data[ref_name][0][ref_start:ref_end]
+            assert ch not in channel_refs
+            channel_refs[ch] = ref_sub_seq
+    with pysam.AlignmentFile(sbr_bam, mode="rb", threads=40, check_sq=False) as in_h:
+        with pysam.AlignmentFile(
+            out_bam, mode="wb", threads=40, check_sq=False, header=in_h.header
+        ) as out_h:
+            for record in tqdm(in_h.fetch(until_eof=True), desc=f"dumping1 {out_bam}"):
+                out_h.write(record)
+
+            for ch, ref_seq in tqdm(channel_refs.items(), desc=f"dumping2 {out_bam}"):
+                record = pysam.AlignedSegment()
+                record.query_name = f"09_REF_{ch}"
+                record.query_sequence = ref_seq
+                record.set_tag("ch", ch, value_type="I")
+                out_h.write(record)
+
+
+def main(args):
+    insert_ref_to_sbr_bam(args.sbr_bam, args.smc2ref_bam, args.ref_file)
+    pass
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(prog="")
+    parser.add_argument("--sbr-bam", dest="sbr_bam")
+    parser.add_argument("--smc2ref-bam", dest="smc2ref_bam")
+    parser.add_argument("--ref-file", dest="ref_file")
+
+    main(args=parser.parse_args())

gseda-0.0.1/src/gseda/fact_table_ana/polars_init.py

@@ -0,0 +1,8 @@
+import os
+
+
+def polars_env_init():
+    os.environ["POLARS_FMT_TABLE_ROUNDED_CORNERS"] = "1"
+    os.environ["POLARS_FMT_MAX_COLS"] = "100"
+    os.environ["POLARS_FMT_MAX_ROWS"] = "300"
+    os.environ["POLARS_FMT_STR_LEN"] = "100"

gseda-0.0.1/src/gseda/fact_table_ana/pred_baseq_and_emperical_baseq.py

@@ -0,0 +1,186 @@
+import os
+import sys
+
+cur_dir = os.path.abspath(__file__).rsplit("/", maxsplit=1)[0]
+sys.path.insert(0, cur_dir)
+
+import pysam
+import utils
+import polars as pl
+import argparse
+from tqdm import tqdm
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+
+class BaseQStat:
+    def __init__(self, pred_q):
+        self.pred_q = pred_q
+        self.eq = 0
+        self.diff = 0
+        self.insertion = 0
+        self.deletion = 0
+        self.depth = 0
+
+    def add_eq(self, num=1):
+        self.eq += num
+
+    def add_diff(self, num=1):
+        self.diff += num
+
+    def add_insertion(self, num=1):
+        self.insertion += num
+
+    def add_deletion(self, num=1):
+        self.deletion += num
+
+
+def stat_one_record(aligned_pairs, qual, baseq2baseq_stat, query_seq, refseq, ref_end):
+    ref_pos_cursor = None
+    query_pos_cursor = None
+
+    for qpos, rpos in aligned_pairs:
+
+        if qpos is not None:
+            query_pos_cursor = qpos
+        if rpos is not None:
+            ref_pos_cursor = rpos
+
+        if ref_pos_cursor is None:
+            continue
+
+        if query_pos_cursor is None:
+            continue
+
+        baseq_stat = baseq2baseq_stat.setdefault(
+            qual[query_pos_cursor], BaseQStat(qual[query_pos_cursor])
+        )
+        assert isinstance(baseq_stat, BaseQStat)
+        if rpos is None:
+            baseq_stat.add_insertion()
+            if ref_pos_cursor == (ref_end - 1):
+                break
+            continue
+
+        if qpos is None:
+            baseq_stat.add_deletion()
+        else:
+            if refseq[rpos] == query_seq[qpos]:
+                baseq_stat.add_eq()
+            else:
+                baseq_stat.add_diff()
+
+        if ref_pos_cursor == (ref_end - 1):
+            break
+
+
+def stat(aligned_bam_file: str, ref_file: str):
+    ref_data = utils.read_fastx_file(ref_file)
+
+    baseq2baseq_stat = {}
+
+    with pysam.AlignmentFile(aligned_bam_file, mode="rb") as bam_h:
+        for refname, refseq in ref_data.items():
+
+            for record in tqdm(
+                bam_h.fetch(contig=refname), desc=f"processing {refname}"
+            ):
+                if record.is_secondary or record.is_supplementary or record.is_unmapped:
+                    continue
+
+                ref_pos_cursor = None
+                query_pos_cursor = None
+
+                ref_start = record.reference_start
+                ref_end = record.reference_end
+                query_start = record.query_alignment_start
+                query_end = record.query_alignment_end
+
+                qual = record.query_qualities
+                query_seq = record.query_sequence
+
+                stat_one_record(
+                    record.get_aligned_pairs(),
+                    qual,
+                    baseq2baseq_stat,
+                    query_seq,
+                    refseq,
+                    ref_end,
+                )
+                # for qpos, rpos in record.get_aligned_pairs():
+
+                #     if qpos is not None:
+                #         query_pos_cursor = qpos
+                #     if rpos is not None:
+                #         ref_pos_cursor = rpos
+
+                #     if ref_pos_cursor is None:
+                #         continue
+
+                #     if query_pos_cursor is None:
+                #         continue
+
+                #     baseq_stat = baseq2baseq_stat.setdefault(
+                #         qual[query_pos_cursor], BaseQStat(qual[query_pos_cursor])
+                #     )
+                #     assert isinstance(baseq_stat, BaseQStat)
+                #     if rpos is None:
+                #         baseq_stat.add_insertion()
+                #         if ref_pos_cursor == (ref_end - 1):
+                #             break
+                #         continue
+
+                #     if qpos is None:
+                #         baseq_stat.add_deletion()
+                #     else:
+                #         if refseq[rpos] == query_seq[qpos]:
+                #             baseq_stat.add_eq()
+                #         else:
+                #             baseq_stat.add_diff()
+
+                #     if ref_pos_cursor == (ref_end - 1):
+                #         break
+    baseqs = []
+    eqs = []
+    diffs = []
+    insertions = []
+    deletions = []
+
+    for bq, stat in baseq2baseq_stat.items():
+        assert isinstance(stat, BaseQStat)
+        baseqs.append(bq)
+        eqs.append(stat.eq)
+        diffs.append(stat.diff)
+        insertions.append(stat.insertion)
+        deletions.append(stat.deletion)
+
+    return pl.DataFrame(
+        {"baseq": baseqs, "eq": eqs, "diff": diffs, "ins": insertions, "del": deletions}
+    )
+
+
+def main(args):
+    df = stat(args.aln_bam, args.ref_file)
+    df = df.with_columns(
+        [
+            (pl.col("eq") / (pl.col("eq") + pl.col("diff") + pl.col("ins"))).alias(
+                "emp_rq"
+            )
+        ]
+    ).with_columns([utils.q2phreq_expr("emp_rq", "emp_phreq")])
+    figure = plt.figure(figsize=(20, 10))
+    axs = figure.add_subplot(1, 1, 1)
+    sns.scatterplot(df.to_pandas(), x="baseq", y="emp_phreq", ax=axs)
+
+    print(df.head(10))
+    figure.savefig(fname="baseq2empq")
+
+
+if __name__ == "__main__":
+
+    params = {
+        "aln_bam": "/data/ccs_data/ccs_eval2024q4/output-all/smc2ref.bam",
+        "ref_file": "/data/ccs_data/MG1655.fa",
+    }
+
+    main(argparse.Namespace(**params))

gseda-0.0.1/src/gseda/fact_table_ana/preq-baseq-and-emp-q.py

@@ -0,0 +1,64 @@
+import pysam
+import os
+import sys
+
+cur_dir = os.path.abspath(__file__).rsplit("/", maxsplit=1)[0]
+sys.path.insert(0, cur_dir)
+
+import utils
+import polars as pl
+import argparse
+from tqdm import tqdm
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+
+import polars_init
+
+
+def main(args):
+    # plt.grid(True, linestyle=":", linewidth=0.5, color="gray")
+
+    df = pl.read_csv(args.data, separator="\t")
+    df = df.with_columns(
+        [
+            (pl.col("eq") / (pl.col("eq") + pl.col("diff") + pl.col("ins"))).alias(
+                "emp_rq"
+            )
+        ]
+    ).with_columns([utils.q2phreq_expr("emp_rq", "emp_phreq")])
+    figure = plt.figure(figsize=(10, 10))
+    axs = figure.add_subplot(1, 1, 1)
+    plt.sca(axs)
+    plt.grid(True, linestyle=":", linewidth=0.5, color="gray")
+
+    sns.scatterplot(df.to_pandas(), x="baseq", y="emp_phreq", ax=axs)
+    axs.set_xticks(list(range(0, 60, 2)))
+    axs.set_yticks(list(range(0, 60, 2)))
+    axs.set_xlabel("PredictedBaseQ", fontdict={"size": 16})
+    axs.set_ylabel("EmpericalBaseQ", fontdict={"size": 16})
+    perfect_line = pl.DataFrame(
+        {
+            "x": list(range(0, 60)),
+            "y": list(range(0, 60)),
+        }
+    )
+
+    sns.lineplot(
+        perfect_line.to_pandas(), x="x", y="y", ax=axs, color="blue", linestyle="--"
+    )
+
+    print(df.head(10))
+    figure.savefig(fname="baseq2empq.png")
+
+
+if __name__ == "__main__":
+    polars_init.polars_env_init()
+    params = {
+        "data": "/data/ccs_data/ccs_eval2024q3/Ludaopei/subread_bak/output-all/analysis/fact_baseq_stat.csv",
+    }
+
+    main(argparse.Namespace(**params))
+
+
+# Z:\BC\共享文件夹\four\20241115_Sync_Y0701_03_H01_Run0003_called.bam  . 中南 STR

gseda-0.0.1/src/gseda/fact_table_ana/query_error_locus_ana.py

@@ -0,0 +1,62 @@
+import pysam
+import polars as pl
+import argparse
+
+import os
+import sys
+
+cur_dir = os.path.abspath(__file__).rsplit("/", maxsplit=1)[0]
+sys.path.insert(0, cur_dir)
+
+import polars_init
+
+
+def error_channel_analysis(
+    fact_aligned_bam_bam_basic: str, fact_error_query_locus_info: str
+):
+
+    basic = pl.read_csv(fact_aligned_bam_bam_basic, separator="\t")
+    query_error_locus = pl.read_csv(fact_error_query_locus_info, separator="\t")
+
+    basic = basic.filter((pl.col("np") == 7).and_(pl.col("iy") < 0.999)).select(
+        [
+            pl.col("qname"),
+            pl.col("np"),
+            pl.col("rq"),
+            pl.col("iy"),
+            pl.col("qlen"),
+            pl.col("fwd"),
+        ]
+    )
+
+    df = (
+        basic.join(query_error_locus, on="qname", how="inner")
+        .with_columns(
+            [
+                pl.when(pl.col("fwd"))
+                .then(pl.col("qstart"))
+                .otherwise(pl.col("qlen") - pl.col("qend"))
+                .alias("qstart"),
+                pl.when(pl.col("fwd"))
+                .then(pl.col("qend"))
+                .otherwise(pl.col("qlen") - pl.col("qstart"))
+                .alias("qend"),
+            ]
+        )
+        .sort(by=["qname", "rstart"], descending=[True, False])
+    )
+    print(df.head(100))
+
+
+def main(args):
+    error_channel_analysis(args.bam_basic, args.error_query_locus)
+    pass
+
+
+if __name__ == "__main__":
+    polars_init.polars_env_init()
+
+    parser = argparse.ArgumentParser(prog="")
+    parser.add_argument("bam_basic")
+    parser.add_argument("error_query_locus")
+    main(parser.parse_args())

gseda-0.0.1/src/gseda/fact_table_ana/ref_locus_ana.py

@@ -0,0 +1,74 @@
+import polars as pl
+import os
+import sys
+
+cur_dir = os.path.abspath(__file__).rsplit("/", maxsplit=1)[0]
+sys.path.insert(0, cur_dir)
+
+import polars_init
+import argparse
+
+
+def variant_calling(df: pl.DataFrame):
+    v = (
+        df.with_columns([(pl.col("eq") + pl.col("diff")).alias("eq_and_diff")])
+        .with_columns(
+            [
+                (pl.col("eq") / pl.col("eq_and_diff")).alias("eq_in_eqdiff"),
+                (pl.col("diff") / pl.col("eq_and_diff")).alias("diff_in_eqdiff"),
+            ]
+        )
+        .filter((pl.col("eq_in_eqdiff") > 0.2).and_(pl.col("diff_in_eqdiff") > 0.2))
+        .filter(pl.col("diffDetail").str.split(",").list.len() < 2)
+        .shape[0]
+    )
+
+    print("variant calling ratio: {} / {} = {}".format(v, df.shape[0], v / df.shape[0]))
+
+
+def del_calling(df: pl.DataFrame):
+    v = (
+        df.with_columns([(pl.col("del") / pl.col("depth")).alias("del_ratio")])
+        .filter((pl.col("del_ratio") > 0.4))
+        .shape[0]
+    )
+
+    print("del ratio: {} / {} = {}".format(v, df.shape[0], v / df.shape[0]))
+
+
+def ana(filepath: str):
+    df = pl.read_csv(filepath, separator="\t")
+    print(df.head(2))
+
+    df = (
+        df.with_columns(
+            [
+                (
+                    pl.col("eq")
+                    / (pl.col("eq") + pl.col("diff") + pl.col("ins") + pl.col("del"))
+                ).alias("eq_rate"),
+                (pl.col("eq") / pl.col("depth")).alias("eq_rate2"),
+            ]
+        )
+        # .filter(pl.col("curIsHomo").eq(0).and_(pl.col("nextIsHomo").eq(0)))
+        .sort(by=["eq_rate2"], descending=[False])
+    )
+
+    print(df.head(100))
+
+    print(df.select((pl.col("eq_rate2") < 0.5).sum() / pl.len()))
+
+    variant_calling(df=df)
+    del_calling(df=df)
+
+    # print(df.head(200))
+
+
+if __name__ == "__main__":
+    polars_init.polars_env_init()
+
+    parser = argparse.ArgumentParser(prog="")
+    parser.add_argument("fp", metavar="fact_aligned_bam_ref_locus_info.csv")
+    args = parser.parse_args()
+    ana(filepath=args.fp)
+    pass

gseda-0.0.1/src/gseda/fact_table_ana/utils.py

@@ -0,0 +1,36 @@
+import pysam
+from typing import Mapping, Tuple
+from tqdm import tqdm
+import polars as pl
+
+
+def read_bam_file(bam_file: str) -> Mapping[str, Tuple[str, int]]:
+    res = {}
+    with pysam.AlignmentFile(bam_file, mode="rb", threads=40, check_sq=False) as bam_h:
+        for record in tqdm(
+            bam_h.fetch(until_eof=True), desc=f"read_bam_file:>> reading {bam_file}"
+        ):
+            res[record.query_name] = (record.query_sequence, f"00_{record.query_name}")
+
+    return res
+
+
+def read_fastx_file(fname: str) -> Mapping[str, Tuple[str, int]]:
+    fh = pysam.FastxFile(fname)
+    res = {}
+    for entry in fh:
+        res[entry.name] = (entry.sequence, f"00_{entry.name}")
+    return res
+
+
+def q2phreq_expr(inp_name, oup_name=None):
+    oup_name = oup_name if oup_name is not None else inp_name
+    return (
+        -10.0
+        * (
+            1
+            - pl.when(pl.col(inp_name) > (1 - 1e-6))
+            .then(1 - 1e-6)
+            .otherwise(pl.col(inp_name))
+        ).log10()
+    ).alias(oup_name)

gseda-0.0.1/src/gseda/msa_view/msa_view.py

@@ -0,0 +1,417 @@
+"""
+this script is used to visualize the msa.
+the result can be used in two ways:
+    * copy the fasta info and past to the jalview, jalview is used for the plot. OR
+    * generate the msa picture directly
+
+the whole pipeline is:
+1) do alignment (pairwise alignment)  mini_align -P -m -r ref_filepath.fa -i inp.fa -t 1 -p calls2draft
+2) use this script to generate msa pic
+
+"""
+
+import argparse
+import pysam
+import numpy as np
+import tempfile
+import os
+from typing import Mapping
+from tqdm import tqdm
+from typing import Dict
+
+
+def read_fastx_file(fname: str):
+    fh = pysam.FastxFile(fname)
+    res = {}
+    for entry in fh:
+        res[entry.name] = entry.sequence
+    return res
+
+
+def read_bam_file(bam_file: str) -> Mapping[str, str]:
+    res = {}
+    with pysam.AlignmentFile(bam_file, mode="rb", threads=40, check_sq=False) as bam_h:
+        for record in tqdm(
+            bam_h.fetch(until_eof=True), desc=f"read_bam_file:>> reading {bam_file}"
+        ):
+            res[record.query_name] = record.query_sequence
+
+    return res
+
+
+class Name2Seq:
+    def __init__(self, fname: str):
+        if (
+            fname.endswith("fa")
+            or fname.endswith("fasta")
+            or fname.endswith("fna")
+            or fname.endswith("fq")
+            or fname.endswith("fastq")
+        ):
+            self.qname2seq = read_fastx_file(fname)
+        elif fname.endswith("bam"):
+            self.qname2seq = read_bam_file(fname)
+        else:
+            raise ValueError(f"invalid file format, {fname}")
+
+    def fetch(self, name):
+        return self.qname2seq[name]
+
+
+def build_query_name(align_seg: pysam.AlignedSegment):
+    return f"{align_seg.query_name}_SE_{align_seg.query_alignment_start}_{align_seg.query_alignment_end}"
+
+
+def init_matrix(num_rows, num_cols):
+    """init matrix using "." """
+    matrix = np.empty(shape=[num_rows, num_cols], dtype=np.str_)
+    matrix.fill(".")
+    return matrix
+
+
+class ResultMatrix:
+    """msa alignment matrix"""
+
+    def __init__(
+        self,
+        ref_start,
+        ref_end,
+        query_names,
+        refpos2length: Dict[int, int],
+        ref_name=None,
+    ) -> None:
+        self.num_records = len(query_names) + 1  # +ref
+        self.query_names = sorted(query_names)
+        self.query2idx = {
+            query_name: idx for idx, query_name in enumerate(self.query_names, start=1)
+        }
+        self.ref_name = "REF" if ref_name is None else ref_name
+        self.ref_name = f"{self.ref_name}_{ref_start}_{ref_end}"
+        self.matrix = init_matrix(self.num_records, sum(refpos2length.values()))
+
+        refpos2length_list = sorted(list(refpos2length.items()), key=lambda x: x[0])
+        rpos2matrix_col = [[refpos2length_list[0][0], 0]]
+        for i in range(1, len(refpos2length_list)):
+            cur_item = refpos2length_list[i]
+            rpos2matrix_col.append(
+                [cur_item[0], refpos2length_list[i - 1][1] + rpos2matrix_col[-1][1]]
+            )
+
+        print(refpos2length_list)
+        print(rpos2matrix_col)
+        self.rpos2matrix_col = {
+            rpos: matrix_col for rpos, matrix_col in rpos2matrix_col
+        }
+
+        self.ref_end = ref_end  # exclusive
+        self.ref_start = ref_start
+
+        print(f"self.end={self.ref_end}")
+
+    def update(self, record: pysam.AlignedSegment, ref: str = None):
+
+        idx = self.query2idx[build_query_name(record)]
+
+        rpos_cursor = None
+        # qpos_cursor = None
+        offset = 0
+        query_seq = record.query_sequence
+
+        ref_aligned = []
+        query_aligned = []
+
+        qpos_start = None
+        qpos_end = None
+
+        for qpos, rpos in record.get_aligned_pairs():
+            if rpos is not None:
+                rpos_cursor = rpos
+            if rpos_cursor is None:
+                continue
+            if rpos_cursor < self.ref_start or rpos_cursor >= self.ref_end:
+                continue
+
+            if qpos_start is None and qpos is not None:
+                qpos_start = qpos
+
+            if qpos is not None:
+                qpos_end = qpos
+
+            if rpos_cursor not in self.rpos2matrix_col:
+                print(
+                    rpos_cursor, " not in ", sorted(list(self.rpos2matrix_col.keys()))
+                )
+                raise ValueError()
+
+            ref_aligned.append("-" if rpos is None else ref[rpos])
+            query_aligned.append("-" if qpos is None else query_seq[qpos])
+
+            matrix_init_col = self.rpos2matrix_col[rpos_cursor]
+            if rpos is None:
+                offset += 1
+            else:
+                offset = 0
+                self.matrix[0, matrix_init_col] = ref[rpos]
+
+            matrix_col = matrix_init_col + offset
+            if qpos is not None:
+                self.matrix[idx, matrix_col] = query_seq[qpos]
+
+        # ref_aligned = "".join(ref_aligned)
+        # query_aligned = "".join(query_aligned)
+        # info = f"qname:{record.query_name}\n{ref_aligned}\n{query_aligned}"
+        # print(info)
+
+        seq_len = record.query_length
+        if record.is_reverse:
+            qpos_start, qpos_end = seq_len - qpos_end, seq_len - qpos_start
+
+        called_start = None
+        called_end = None
+        if record.has_tag("be"):
+            shift = record.get_tag("be")[0]
+            called_start = qpos_start + shift
+            called_end = qpos_end + shift
+
+        print(
+            f"{record.query_name}: sbr:{qpos_start}-{qpos_end}, called:{called_start}-{called_end}"
+        )
+
+    def get_raw_result(self):
+        return self.matrix
+
+    def get_query_names(self):
+        names = [self.ref_name]
+        names.extend(self.query_names)
+        return names
+
+    def get_result(self):
+        """may the matrix has invalid rows, trim it and return"""
+        return self.get_raw_result()
+
+    def get_result_str(self):
+        """valid matrix to string"""
+        res = self.get_result()
+        names = [self.ref_name]
+        names.extend(self.query_names)
+        result_strs = []
+        for row_idx in range(res.shape[0]):
+
+            q_name = names[row_idx]
+            result_strs.append(f">{q_name}")
+            result_strs.append("".join(res[row_idx].tolist()))
+
+        return "\n".join(result_strs)
+
+    @staticmethod
+    def init_matrix(num_rows, num_cols):
+        """init matrix using "." """
+        matrix = np.empty(shape=[num_rows, num_cols], dtype=np.str_)
+        matrix.fill(".")
+        return matrix
+
+
+def extract_reference(ref_filename):
+    """extract reference from fasta file"""
+    with open(ref_filename, mode="r", encoding="utf8") as file:
+        lines = file.readlines()
+        ref_name = lines[0].split(" ")[0][1:]
+        return (ref_name.strip(), "".join(lines[1:]))
+
+
+def build_ref_pos_maxins(
+    sam_file: pysam.AlignmentFile, contig: str, ref_start: int, ref_end: int
+):
+    rpos2max_ins = {rpos: 0 for rpos in range(ref_start, ref_end)}
+
+    for query in sam_file.fetch(contig=contig):
+        rpos_cursor = None
+        cur_query_ins = 0
+        for _, rpos in query.get_aligned_pairs():
+
+            if rpos is not None:
+                rpos_cursor = rpos
+
+            if rpos_cursor is None:
+                continue
+            if rpos_cursor < ref_start:
+                continue
+
+            if rpos_cursor >= ref_end:
+                break
+
+            if rpos is None:
+                cur_query_ins += 1
+            else:
+                if rpos_cursor > ref_start:
+                    rpos2max_ins[rpos_cursor - 1] = max(
+                        cur_query_ins, rpos2max_ins[rpos_cursor - 1]
+                    )
+                cur_query_ins = 0
+
+        if rpos_cursor > ref_start and rpos_cursor <= ref_end:
+            rpos2max_ins[rpos_cursor - 1] = max(
+                cur_query_ins, rpos2max_ins[rpos_cursor - 1]
+            )
+
+    return rpos2max_ins
+
+
+def bam2fa4jalview(
+    aligned_bam_filename,
+    ref_filename,
+    ref_name,
+    interested_ref_start=None,
+    interested_ref_end=None,
+):
+    """generate the fasta info that can be used in jalview from bam file and [ref file]
+    Params:
+        aligned_bam_filename
+        contig
+        ref_filename
+    """
+    samfile = pysam.AlignmentFile(aligned_bam_filename, mode="rb", threads=40)
+
+    fastx_data = Name2Seq(ref_filename)
+
+    ref_seq = fastx_data.fetch(ref_name)
+
+    ref_start = 2**32
+    ref_end = 0
+    query_names = []
+
+    for query in samfile.fetch(contig=ref_name):
+        if (
+            interested_ref_start is not None
+            and query.reference_end <= interested_ref_start
+        ):
+            continue
+        if (
+            interested_ref_end is not None
+            and query.reference_start >= interested_ref_end
+        ):
+            continue
+        ref_start = min([query.reference_start, ref_start])
+        ref_end = max([query.reference_end, ref_end])
+        query_names.append(build_query_name(query))
+
+    interested_ref_start = (
+        ref_start if interested_ref_start is None else interested_ref_start
+    )
+    interested_ref_end = ref_end if interested_ref_end is None else interested_ref_end
+
+    print(
+        f"interested_ref_start={interested_ref_start}, interested_ref_end={interested_ref_end}"
+    )
+
+    rpos2maxins = build_ref_pos_maxins(
+        samfile,
+        contig=ref_name,
+        ref_start=interested_ref_start,
+        ref_end=interested_ref_end,
+    )
+
+    rpos2length = {pos: ins + 1 for pos, ins in rpos2maxins.items()}
+
+    result_matrix = ResultMatrix(
+        ref_start=interested_ref_start,
+        ref_end=interested_ref_end,
+        query_names=query_names,
+        refpos2length=rpos2length,
+        ref_name=ref_name,
+    )
+
+    for query in samfile.fetch(contig=ref_name):
+        if query.reference_end <= interested_ref_start:
+            continue
+        if query.reference_start >= interested_ref_end:
+            continue
+        result_matrix.update(query, ref=ref_seq)
+
+    return result_matrix
+
+
+def plot_msa_align(inp_filename, oup_filename=None):
+    """plot the msa align according to the fasta file"""
+
+    from pymsaviz import MsaViz
+
+    mv = MsaViz(
+        inp_filename,
+        wrap_length=150,
+        show_count=True,
+        show_grid=True,
+        color_scheme="Identity",
+    )
+    if oup_filename is None:
+        oup_filename = f"{inp_filename}.png"
+    mv.savefig(oup_filename)
+
+
+def main(args):
+    res = bam2fa4jalview(
+        args.bam,
+        ref_filename=args.ref_fasta,
+        ref_name=args.ref_name,
+        interested_ref_start=args.start,
+        interested_ref_end=args.end,
+    )
+
+    res_str = res.get_result_str()
+    if args.o_fasta is not None:
+        with open(args.o_fasta, "w", encoding="utf8") as file:
+            file.write(res_str)
+    else:
+        print(res_str)
+
+    if args.o_pic is not None:
+        if args.o_fasta is not None:
+            plot_msa_align(inp_filename=args.o_fasta, oup_filename=args.o_pic)
+
+        else:
+            with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+                tmp.write(res_str)
+                tmp.close()
+                print(f"temp file name: {tmp.name}")
+                plot_msa_align(inp_filename=tmp.name, oup_filename=args.o_pic)
+            os.remove(tmp.name)
+
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser(
+        "mas_view",
+        description="""
+        the whole pipeline is:
+            1) do alignment (pairwise alignment), minimap2 is an option;
+            2) use this script to generate msa pic
+    """,
+    )
+    p.add_argument("--bam", type=str, help="subreads2smc alignment", required=True)
+    p.add_argument(
+        "--ref-fastx-or-bam",
+        type=str,
+        help="smc.fa/smc.fq/.bam,",
+        required=True,
+        dest="ref_fasta",
+    )
+
+    p.add_argument("--ref-name", required=True, type=str, dest="ref_name")
+    p.add_argument(
+        "--ref-start", type=int, default=None, help="contig end", dest="start"
+    )
+    p.add_argument("--ref-end", type=int, default=None, help="contig start", dest="end")
+
+    p.add_argument(
+        "--o-fasta",
+        default=None,
+        help="output fasta file, if not provided, this content will be output to the stdout",
+        dest="o_fasta",
+    )
+    p.add_argument(
+        "--o-pic",
+        default=None,
+        help="visualization picture file path, if not provided, the plot procedure will be skipped",
+        dest="o_pic",
+    )
+    args = p.parse_args()
+    main(args)