jsrc 0.1.0__tar.gz

jsrc-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JiaoYuan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jsrc-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: jsrc
+Version: 0.1.0
+Summary: Bioinformatics and phenotype analysis toolkit
+Author-email: Jiaoyuan <your.email@example.com>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: biopython>=1.80
+Requires-Dist: matplotlib>=3.5
+Requires-Dist: numpy>=1.20
+Requires-Dist: opencv-python>=4.5
+Requires-Dist: pandas>=1.3
+Requires-Dist: pillow>=9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Dynamic: license-file
+
+# jsrc
+
+Bioinformatics and phenotype analysis toolkit
+
+## Installation
+
+```bash
+pip install jsrc
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/imjiaoyuan/jsrc.git
+cd jsrc
+pip install -e .
+```
+
+## Commands
+
+**Sequence Operations**
+
+```bash
+jsrc seq extract -fa genome.fa -ids ids.txt -o output.fa
+jsrc seq rename -fa input.fa -map mapping.csv -o output.fa
+jsrc seq rename-by-gff -fa transcripts.fa -gff genes.gff -parent Parent -o output.fa
+jsrc seq translate -fa genome.fa -gff genes.gff -id ID -o proteins.fa
+```
+
+**Visualization**
+
+```bash
+jsrc plot gene-structure -gff genes.gff -ids genes.txt -o gene_structure.png
+jsrc plot exon-structure -gff genes.gff -ids genes.txt -o exon_structure.png
+jsrc plot chromosome-map -gff genes.gff -o chromosome_map.png
+jsrc plot protein-domain -tsv domains.tsv -o protein_domains.png
+jsrc plot cis-element -bed elements.bed -o cis_elements.png
+```
+
+**Analysis Tools**
+
+```bash
+jsrc analyze phylo-tree -fa sequences.fa -o tree.nwk -a nj
+jsrc analyze phylo-tree -fa sequences.fa -o tree.nwk -a ml
+jsrc analyze motif -fa promoters.fa -o motif_output -nmotifs 5
+```
+
+**Phenotype Image Analysis**
+
+```bash
+jsrc pheno split-fruit -i fruit_image.jpg -o output_dir
+jsrc pheno split-fruit-raw -i fruit_image.jpg -o output_dir
+jsrc pheno split-leaf -i leaf_image.jpg -o output_dir
+jsrc pheno split-leaf-edge -i leaf_image.jpg -o output_dir
+```

jsrc-0.1.0/README.md

@@ -0,0 +1,55 @@
+# jsrc
+
+Bioinformatics and phenotype analysis toolkit
+
+## Installation
+
+```bash
+pip install jsrc
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/imjiaoyuan/jsrc.git
+cd jsrc
+pip install -e .
+```
+
+## Commands
+
+**Sequence Operations**
+
+```bash
+jsrc seq extract -fa genome.fa -ids ids.txt -o output.fa
+jsrc seq rename -fa input.fa -map mapping.csv -o output.fa
+jsrc seq rename-by-gff -fa transcripts.fa -gff genes.gff -parent Parent -o output.fa
+jsrc seq translate -fa genome.fa -gff genes.gff -id ID -o proteins.fa
+```
+
+**Visualization**
+
+```bash
+jsrc plot gene-structure -gff genes.gff -ids genes.txt -o gene_structure.png
+jsrc plot exon-structure -gff genes.gff -ids genes.txt -o exon_structure.png
+jsrc plot chromosome-map -gff genes.gff -o chromosome_map.png
+jsrc plot protein-domain -tsv domains.tsv -o protein_domains.png
+jsrc plot cis-element -bed elements.bed -o cis_elements.png
+```
+
+**Analysis Tools**
+
+```bash
+jsrc analyze phylo-tree -fa sequences.fa -o tree.nwk -a nj
+jsrc analyze phylo-tree -fa sequences.fa -o tree.nwk -a ml
+jsrc analyze motif -fa promoters.fa -o motif_output -nmotifs 5
+```
+
+**Phenotype Image Analysis**
+
+```bash
+jsrc pheno split-fruit -i fruit_image.jpg -o output_dir
+jsrc pheno split-fruit-raw -i fruit_image.jpg -o output_dir
+jsrc pheno split-leaf -i leaf_image.jpg -o output_dir
+jsrc pheno split-leaf-edge -i leaf_image.jpg -o output_dir
+```

jsrc-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "jsrc"
+version = "0.1.0"
+description = "Bioinformatics and phenotype analysis toolkit"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+    {name = "Jiaoyuan", email = "your.email@example.com"}
+]
+
+dependencies = [
+    "biopython>=1.80",
+    "matplotlib>=3.5",
+    "numpy>=1.20",
+    "opencv-python>=4.5",
+    "pandas>=1.3",
+    "pillow>=9.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "black>=22.0", "ruff>=0.1"]
+
+[project.scripts]
+jsrc = "cli:main"
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+py-modules = ["cli", "common", "seq", "plot", "analyze", "pheno"]
+
+[tool.setuptools.package-dir]
+"" = "src"

jsrc-0.1.0/setup.cfg

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

jsrc-0.1.0/src/analyze.py

@@ -0,0 +1,56 @@
+import sys
+import os
+import tempfile
+from Bio import SeqIO, AlignIO, Phylo
+from common import sanitize_fasta_ids, check_external_tool
+
+def cmd_phylo_tree(args):
+    check_external_tool('mafft', 'conda install -c bioconda mafft')
+    
+    if args.a == 'ml':
+        check_external_tool('FastTree', 'conda install -c bioconda fasttree')
+    
+    with tempfile.TemporaryDirectory() as tmpdir:
+        clean_fa = os.path.join(tmpdir, 'clean.fa')
+        aln_fa = os.path.join(tmpdir, 'aligned.fa')
+        
+        id_map = sanitize_fasta_ids(args.fa, clean_fa)
+        
+        os.system(f'mafft --auto --quiet {clean_fa} > {aln_fa}')
+        
+        if args.a == 'nj':
+            from Bio.Phylo.TreeConstruction import DistanceCalculator, DistanceTreeConstructor
+            
+            alignment = AlignIO.read(aln_fa, 'fasta')
+            calculator = DistanceCalculator('identity')
+            dm = calculator.get_distance(alignment)
+            constructor = DistanceTreeConstructor(calculator)
+            tree = constructor.nj(dm)
+            
+        else:
+            tree_file = os.path.join(tmpdir, 'tree.nwk')
+            os.system(f'FastTree -nt -quiet {aln_fa} > {tree_file}')
+            tree = Phylo.read(tree_file, 'newick')
+        
+        for clade in tree.find_clades():
+            if clade.name and clade.name in id_map:
+                clade.name = id_map[clade.name]
+        
+        Phylo.write(tree, args.o, 'newick')
+    
+    print(f"Phylogenetic tree ({args.a}) saved to {args.o}")
+
+def cmd_motif(args):
+    check_external_tool('meme', 'conda install -c bioconda meme')
+    
+    os.makedirs(args.o, exist_ok=True)
+    
+    cmd = f'meme {args.fa} -dna -oc {args.o} -nmotifs {args.nmotifs} -minw {args.minw} -maxw {args.maxw} -mod zoops'
+    
+    ret = os.system(cmd)
+    
+    if ret != 0:
+        print(f"Error: MEME failed with exit code {ret}", file=sys.stderr)
+        sys.exit(1)
+    
+    print(f"Motif analysis complete. Results in {args.o}")

jsrc-0.1.0/src/cli.py

@@ -0,0 +1,140 @@
+import argparse
+import sys
+import seq, plot, analyze, pheno
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='jsrc',
+        description='Bioinformatics and phenotype analysis toolkit'
+    )
+    parser.add_argument('--version', action='version', version='1.0.0')
+    
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+    
+    seq_parser = subparsers.add_parser('seq', help='Sequence operations')
+    seq_sub = seq_parser.add_subparsers(dest='seq_cmd')
+    
+    p = seq_sub.add_parser('extract', help='Extract sequences by ID list')
+    p.add_argument('-fa', required=True, help='Input FASTA file')
+    p.add_argument('-ids', required=True, help='ID list file (one per line)')
+    p.add_argument('-o', required=True, help='Output FASTA file')
+    p.set_defaults(func=seq.cmd_extract)
+    
+    p = seq_sub.add_parser('rename', help='Rename sequences using mapping file')
+    p.add_argument('-fa', required=True, help='Input FASTA file')
+    p.add_argument('-map', required=True, help='ID mapping file (CSV: old,new)')
+    p.add_argument('-o', required=True, help='Output FASTA file')
+    p.set_defaults(func=seq.cmd_rename)
+    
+    p = seq_sub.add_parser('rename-by-gff', help='Rename sequences based on GFF')
+    p.add_argument('-fa', required=True, help='Input FASTA file')
+    p.add_argument('-gff', required=True, help='GFF annotation file')
+    p.add_argument('-parent', required=True, help='Parent attribute field name')
+    p.add_argument('-o', required=True, help='Output FASTA file')
+    p.set_defaults(func=seq.cmd_rename_by_gff)
+    
+    p = seq_sub.add_parser('translate', help='Extract CDS and translate to protein')
+    p.add_argument('-fa', required=True, help='Genome FASTA file')
+    p.add_argument('-gff', required=True, help='GFF annotation file')
+    p.add_argument('-id', required=True, help='Gene ID field in GFF')
+    p.add_argument('-o', required=True, help='Output protein FASTA')
+    p.set_defaults(func=seq.cmd_translate)
+    
+    plot_parser = subparsers.add_parser('plot', help='Visualization')
+    plot_sub = plot_parser.add_subparsers(dest='plot_cmd')
+    
+    p = plot_sub.add_parser('gene-structure', help='Plot gene structure diagram')
+    p.add_argument('-gff', required=True, help='GFF annotation file')
+    p.add_argument('-ids', required=True, help='Gene ID list file')
+    p.add_argument('-o', required=True, help='Output PNG file')
+    p.add_argument('-dpi', type=int, default=300, help='DPI (default: 300)')
+    p.set_defaults(func=plot.cmd_gene_structure)
+    
+    p = plot_sub.add_parser('exon-structure', help='Plot exon structure')
+    p.add_argument('-gff', required=True, help='GFF annotation file')
+    p.add_argument('-ids', required=True, help='Gene ID list file')
+    p.add_argument('-o', required=True, help='Output PNG file')
+    p.add_argument('-dpi', type=int, default=300, help='DPI (default: 300)')
+    p.set_defaults(func=plot.cmd_exon_structure)
+    
+    p = plot_sub.add_parser('chromosome-map', help='Plot chromosome map')
+    p.add_argument('-gff', required=True, help='GFF annotation file')
+    p.add_argument('-o', required=True, help='Output PNG file')
+    p.add_argument('-dpi', type=int, default=300, help='DPI (default: 300)')
+    p.set_defaults(func=plot.cmd_chromosome_map)
+    
+    p = plot_sub.add_parser('protein-domain', help='Plot protein domain architecture')
+    p.add_argument('-tsv', required=True, help='Domain TSV file')
+    p.add_argument('-o', required=True, help='Output PNG file')
+    p.add_argument('-dpi', type=int, default=300, help='DPI (default: 300)')
+    p.set_defaults(func=plot.cmd_protein_domain)
+    
+    p = plot_sub.add_parser('cis-element', help='Plot cis-regulatory elements')
+    p.add_argument('-bed', required=True, help='BED file with elements')
+    p.add_argument('-o', required=True, help='Output PNG file')
+    p.add_argument('-dpi', type=int, default=300, help='DPI (default: 300)')
+    p.set_defaults(func=plot.cmd_cis_element)
+    
+    analyze_parser = subparsers.add_parser('analyze', help='Analysis tools')
+    analyze_sub = analyze_parser.add_subparsers(dest='analyze_cmd')
+    
+    p = analyze_sub.add_parser('phylo-tree', help='Build phylogenetic tree')
+    p.add_argument('-fa', required=True, help='Input FASTA file')
+    p.add_argument('-o', required=True, help='Output tree file')
+    p.add_argument('-a', choices=['nj', 'ml'], default='nj', help='Algorithm (default: nj)')
+    p.set_defaults(func=analyze.cmd_phylo_tree)
+    
+    p = analyze_sub.add_parser('motif', help='Find motifs using MEME')
+    p.add_argument('-fa', required=True, help='Input FASTA file')
+    p.add_argument('-o', required=True, help='Output directory')
+    p.add_argument('-nmotifs', type=int, default=5, help='Number of motifs (default: 5)')
+    p.add_argument('-minw', type=int, default=6, help='Min motif width (default: 6)')
+    p.add_argument('-maxw', type=int, default=50, help='Max motif width (default: 50)')
+    p.set_defaults(func=analyze.cmd_motif)
+    
+    pheno_parser = subparsers.add_parser('pheno', help='Phenotype image analysis')
+    pheno_sub = pheno_parser.add_subparsers(dest='pheno_cmd')
+    
+    p = pheno_sub.add_parser('split-fruit', help='Segment fruit objects')
+    p.add_argument('-i', required=True, help='Input image file')
+    p.add_argument('-o', required=True, help='Output directory')
+    p.add_argument('-size', type=int, default=800, help='Target size (default: 800)')
+    p.set_defaults(func=pheno.cmd_split_fruit)
+    
+    p = pheno_sub.add_parser('split-fruit-raw', help='Segment fruit without resizing')
+    p.add_argument('-i', required=True, help='Input image file')
+    p.add_argument('-o', required=True, help='Output directory')
+    p.set_defaults(func=pheno.cmd_split_fruit_raw)
+    
+    p = pheno_sub.add_parser('split-leaf', help='Segment leaf objects')
+    p.add_argument('-i', required=True, help='Input image file')
+    p.add_argument('-o', required=True, help='Output directory')
+    p.add_argument('-size', type=int, default=800, help='Target size (default: 800)')
+    p.set_defaults(func=pheno.cmd_split_leaf)
+    
+    p = pheno_sub.add_parser('split-leaf-edge', help='Extract leaf edges')
+    p.add_argument('-i', required=True, help='Input image file')
+    p.add_argument('-o', required=True, help='Output directory')
+    p.set_defaults(func=pheno.cmd_split_leaf_edge)
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+    
+    if hasattr(args, 'func'):
+        args.func(args)
+    else:
+        if args.command == 'seq' and not args.seq_cmd:
+            seq_parser.print_help()
+        elif args.command == 'plot' and not args.plot_cmd:
+            plot_parser.print_help()
+        elif args.command == 'analyze' and not args.analyze_cmd:
+            analyze_parser.print_help()
+        elif args.command == 'pheno' and not args.pheno_cmd:
+            pheno_parser.print_help()
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()

jsrc-0.1.0/src/common.py

@@ -0,0 +1,135 @@
+import re
+import os
+import shutil
+from typing import Dict, List, Tuple, Optional
+import cv2
+import numpy as np
+
+def parse_gff_attributes(attr_string: str) -> Dict[str, str]:
+    attrs = {}
+    for item in attr_string.strip().strip(';').split(';'):
+        if '=' in item:
+            key, value = item.strip().split('=', 1)
+            attrs[key] = value.strip('"')
+        elif ' ' in item:
+            parts = item.strip().split(None, 1)
+            if len(parts) == 2:
+                attrs[parts[0]] = parts[1].strip('"')
+    return attrs
+
+def get_gene_structure(gff_file: str, gene_ids: List[str], 
+                       feature_types: Optional[List[str]] = None) -> Dict:
+    if feature_types is None:
+        feature_types = ['CDS', 'exon']
+    
+    target_set = set(gene_ids)
+    valid_mrna = {}
+    coords = {tid: [] for tid in gene_ids}
+    
+    with open(gff_file, 'r') as f:
+        for line in f:
+            if line.startswith('#'):
+                continue
+            parts = line.strip().split('\t')
+            if len(parts) < 9:
+                continue
+            
+            ftype = parts[2]
+            attr = parse_gff_attributes(parts[8])
+            
+            if ftype == 'mRNA':
+                pid = attr.get('Parent')
+                mid = attr.get('ID')
+                if pid in target_set:
+                    valid_mrna[mid] = pid
+            
+            elif ftype in feature_types:
+                pid = attr.get('Parent')
+                if pid in valid_mrna:
+                    gid = valid_mrna[pid]
+                    coords[gid].append((int(parts[3]), int(parts[4])))
+                elif pid in target_set:
+                    coords[pid].append((int(parts[3]), int(parts[4])))
+    
+    return coords
+
+def read_fasta_ids(fasta_file: str) -> List[str]:
+    ids = []
+    with open(fasta_file, 'r') as f:
+        for line in f:
+            if line.startswith('>'):
+                ids.append(line[1:].split()[0])
+    return ids
+
+def sanitize_fasta_ids(input_file: str, output_file: str) -> Dict[str, str]:
+    mapping = {}
+    with open(input_file, 'r') as fin, open(output_file, 'w') as fout:
+        for line in fin:
+            if line.startswith('>'):
+                old_id = line[1:].strip().split()[0]
+                new_id = re.sub(r'[^A-Za-z0-9_-]', '_', old_id)
+                mapping[new_id] = old_id
+                fout.write(f'>{new_id}\n')
+            else:
+                fout.write(line)
+    return mapping
+
+def setup_matplotlib():
+    import matplotlib
+    matplotlib.use('Agg')
+    import matplotlib.pyplot as plt
+    return plt
+
+def natural_sort_key(s):
+    return [int(t) if t.isdigit() else t.lower() for t in re.split(r'(\d+)', s)]
+
+def check_external_tool(tool_name: str, install_hint: str = None):
+    if not shutil.which(tool_name):
+        msg = f"Error: {tool_name} not found in PATH"
+        if install_hint:
+            msg += f"\nInstall with: {install_hint}"
+        raise RuntimeError(msg)
+
+def apply_morphology(mask, operation='close', kernel_size=5):
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size))
+    if operation == 'close':
+        return cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    elif operation == 'open':
+        return cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+    elif operation == 'dilate':
+        return cv2.dilate(mask, kernel)
+    elif operation == 'erode':
+        return cv2.erode(mask, kernel)
+    return mask
+
+def filter_contours(contours, min_area=100, max_area=None):
+    filtered = []
+    for cnt in contours:
+        area = cv2.contourArea(cnt)
+        if area < min_area:
+            continue
+        if max_area and area > max_area:
+            continue
+        filtered.append(cnt)
+    return filtered
+
+def extract_roi_with_alpha(image, contour, padding=10):
+    x, y, w, h = cv2.boundingRect(contour)
+    x1 = max(0, x - padding)
+    y1 = max(0, y - padding)
+    x2 = min(image.shape[1], x + w + padding)
+    y2 = min(image.shape[0], y + h + padding)
+    
+    roi = image[y1:y2, x1:x2].copy()
+    mask = np.zeros((y2-y1, x2-x1), dtype=np.uint8)
+    
+    shifted_contour = contour - np.array([[x1, y1]])
+    cv2.drawContours(mask, [shifted_contour], -1, 255, -1)
+    
+    if len(roi.shape) == 2:
+        roi = cv2.cvtColor(roi, cv2.COLOR_GRAY2BGR)
+    
+    b, g, r = cv2.split(roi)
+    rgba = cv2.merge([b, g, r, mask])
+    
+    return rgba

jsrc-0.1.0/src/jsrc.egg-info/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: jsrc
+Version: 0.1.0
+Summary: Bioinformatics and phenotype analysis toolkit
+Author-email: Jiaoyuan <your.email@example.com>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: biopython>=1.80
+Requires-Dist: matplotlib>=3.5
+Requires-Dist: numpy>=1.20
+Requires-Dist: opencv-python>=4.5
+Requires-Dist: pandas>=1.3
+Requires-Dist: pillow>=9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Dynamic: license-file
+
+# jsrc
+
+Bioinformatics and phenotype analysis toolkit
+
+## Installation
+
+```bash
+pip install jsrc
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/imjiaoyuan/jsrc.git
+cd jsrc
+pip install -e .
+```
+
+## Commands
+
+**Sequence Operations**
+
+```bash
+jsrc seq extract -fa genome.fa -ids ids.txt -o output.fa
+jsrc seq rename -fa input.fa -map mapping.csv -o output.fa
+jsrc seq rename-by-gff -fa transcripts.fa -gff genes.gff -parent Parent -o output.fa
+jsrc seq translate -fa genome.fa -gff genes.gff -id ID -o proteins.fa
+```
+
+**Visualization**
+
+```bash
+jsrc plot gene-structure -gff genes.gff -ids genes.txt -o gene_structure.png
+jsrc plot exon-structure -gff genes.gff -ids genes.txt -o exon_structure.png
+jsrc plot chromosome-map -gff genes.gff -o chromosome_map.png
+jsrc plot protein-domain -tsv domains.tsv -o protein_domains.png
+jsrc plot cis-element -bed elements.bed -o cis_elements.png
+```
+
+**Analysis Tools**
+
+```bash
+jsrc analyze phylo-tree -fa sequences.fa -o tree.nwk -a nj
+jsrc analyze phylo-tree -fa sequences.fa -o tree.nwk -a ml
+jsrc analyze motif -fa promoters.fa -o motif_output -nmotifs 5
+```
+
+**Phenotype Image Analysis**
+
+```bash
+jsrc pheno split-fruit -i fruit_image.jpg -o output_dir
+jsrc pheno split-fruit-raw -i fruit_image.jpg -o output_dir
+jsrc pheno split-leaf -i leaf_image.jpg -o output_dir
+jsrc pheno split-leaf-edge -i leaf_image.jpg -o output_dir
+```

jsrc-0.1.0/src/jsrc.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/analyze.py
+src/cli.py
+src/common.py
+src/pheno.py
+src/plot.py
+src/seq.py
+src/jsrc.egg-info/PKG-INFO
+src/jsrc.egg-info/SOURCES.txt
+src/jsrc.egg-info/dependency_links.txt
+src/jsrc.egg-info/entry_points.txt
+src/jsrc.egg-info/requires.txt
+src/jsrc.egg-info/top_level.txt

jsrc-0.1.0/src/jsrc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jsrc-0.1.0/src/jsrc.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jsrc = cli:main

jsrc-0.1.0/src/jsrc.egg-info/requires.txt

@@ -0,0 +1,11 @@
+biopython>=1.80
+matplotlib>=3.5
+numpy>=1.20
+opencv-python>=4.5
+pandas>=1.3
+pillow>=9.0
+
+[dev]
+pytest>=7.0
+black>=22.0
+ruff>=0.1

jsrc-0.1.0/src/jsrc.egg-info/top_level.txt

@@ -0,0 +1,6 @@
+analyze
+cli
+common
+pheno
+plot
+seq

jsrc-0.1.0/src/pheno.py

@@ -0,0 +1,142 @@
+import os
+import cv2
+import numpy as np
+from PIL import Image
+from common import apply_morphology, filter_contours, extract_roi_with_alpha
+
+def cmd_split_fruit(args):
+    os.makedirs(args.o, exist_ok=True)
+    
+    img = cv2.imread(args.i)
+    if img is None:
+        print(f"Error: Cannot read image {args.i}")
+        return
+    
+    h, w = img.shape[:2]
+    scale = args.size / max(h, w)
+    new_h, new_w = int(h * scale), int(w * scale)
+    img_resized = cv2.resize(img, (new_w, new_h))
+    
+    hsv = cv2.cvtColor(img_resized, cv2.COLOR_BGR2HSV)
+    
+    lower = np.array([0, 30, 30])
+    upper = np.array([180, 255, 255])
+    mask = cv2.inRange(hsv, lower, upper)
+    
+    mask = apply_morphology(mask, 'close', 15)
+    mask = apply_morphology(mask, 'open', 10)
+    
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+    contours = filter_contours(contours, min_area=500)
+    
+    for i, cnt in enumerate(contours):
+        roi = extract_roi_with_alpha(img_resized, cnt, padding=20)
+        
+        out_path = os.path.join(args.o, f'fruit_{i:03d}.png')
+        Image.fromarray(cv2.cvtColor(roi, cv2.COLOR_BGRA2RGBA)).save(out_path)
+    
+    print(f"Extracted {len(contours)} fruits to {args.o}")
+
+def cmd_split_fruit_raw(args):
+    os.makedirs(args.o, exist_ok=True)
+    
+    img = cv2.imread(args.i)
+    if img is None:
+        print(f"Error: Cannot read image {args.i}")
+        return
+    
+    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+    
+    lower = np.array([0, 30, 30])
+    upper = np.array([180, 255, 255])
+    mask = cv2.inRange(hsv, lower, upper)
+    
+    mask = apply_morphology(mask, 'close', 25)
+    mask = apply_morphology(mask, 'open', 15)
+    
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+    contours = filter_contours(contours, min_area=2000)
+    
+    for i, cnt in enumerate(contours):
+        roi = extract_roi_with_alpha(img, cnt, padding=30)
+        
+        out_path = os.path.join(args.o, f'fruit_raw_{i:03d}.png')
+        Image.fromarray(cv2.cvtColor(roi, cv2.COLOR_BGRA2RGBA)).save(out_path)
+    
+    print(f"Extracted {len(contours)} fruits (original size) to {args.o}")
+
+def cmd_split_leaf(args):
+    os.makedirs(args.o, exist_ok=True)
+    
+    img = cv2.imread(args.i)
+    if img is None:
+        print(f"Error: Cannot read image {args.i}")
+        return
+    
+    h, w = img.shape[:2]
+    scale = args.size / max(h, w)
+    new_h, new_w = int(h * scale), int(w * scale)
+    img_resized = cv2.resize(img, (new_w, new_h))
+    
+    hsv = cv2.cvtColor(img_resized, cv2.COLOR_BGR2HSV)
+    
+    lower = np.array([35, 40, 40])
+    upper = np.array([85, 255, 255])
+    mask = cv2.inRange(hsv, lower, upper)
+    
+    mask = apply_morphology(mask, 'close', 12)
+    mask = apply_morphology(mask, 'open', 8)
+    
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+    contours = filter_contours(contours, min_area=400)
+    
+    for i, cnt in enumerate(contours):
+        roi = extract_roi_with_alpha(img_resized, cnt, padding=15)
+        
+        out_path = os.path.join(args.o, f'leaf_{i:03d}.png')
+        Image.fromarray(cv2.cvtColor(roi, cv2.COLOR_BGRA2RGBA)).save(out_path)
+    
+    print(f"Extracted {len(contours)} leaves to {args.o}")
+
+def cmd_split_leaf_edge(args):
+    os.makedirs(args.o, exist_ok=True)
+    
+    img = cv2.imread(args.i)
+    if img is None:
+        print(f"Error: Cannot read image {args.i}")
+        return
+    
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    
+    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+    
+    edges = cv2.Canny(blurred, 50, 150)
+    
+    edges = apply_morphology(edges, 'dilate', 3)
+    edges = apply_morphology(edges, 'close', 5)
+    
+    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+    contours = filter_contours(contours, min_area=500)
+    
+    for i, cnt in enumerate(contours):
+        mask = np.zeros(img.shape[:2], dtype=np.uint8)
+        cv2.drawContours(mask, [cnt], -1, 255, 2)
+        
+        x, y, w, h = cv2.boundingRect(cnt)
+        x1, y1 = max(0, x-20), max(0, y-20)
+        x2, y2 = min(img.shape[1], x+w+20), min(img.shape[0], y+h+20)
+        
+        roi_edge = mask[y1:y2, x1:x2]
+        roi_img = img[y1:y2, x1:x2]
+        
+        b, g, r = cv2.split(roi_img)
+        rgba = cv2.merge([b, g, r, roi_edge])
+        
+        out_path = os.path.join(args.o, f'leaf_edge_{i:03d}.png')
+        Image.fromarray(cv2.cvtColor(rgba, cv2.COLOR_BGRA2RGBA)).save(out_path)
+    
+    print(f"Extracted {len(contours)} leaf edges to {args.o}")

jsrc-0.1.0/src/plot.py

@@ -0,0 +1,210 @@
+import sys
+import pandas as pd
+from common import setup_matplotlib, get_gene_structure, parse_gff_attributes, natural_sort_key
+plt = setup_matplotlib()
+
+def cmd_gene_structure(args):
+    with open(args.ids, 'r') as f:
+        gene_ids = [line.strip() for line in f if line.strip()]
+    
+    coords = get_gene_structure(args.gff, gene_ids, feature_types=['CDS'])
+    
+    gene_ids_sorted = sorted(gene_ids, key=natural_sort_key)
+    
+    fig, ax = plt.subplots(figsize=(12, max(6, len(gene_ids_sorted) * 0.5)))
+    
+    for i, gid in enumerate(gene_ids_sorted):
+        y = len(gene_ids_sorted) - i - 1
+        if gid not in coords or not coords[gid]:
+            continue
+        
+        cds_list = sorted(coords[gid])
+        gstart = min(c[0] for c in cds_list)
+        gend = max(c[1] for c in cds_list)
+        
+        ax.plot([gstart, gend], [y, y], 'k-', linewidth=1)
+        
+        for start, end in cds_list:
+            ax.add_patch(plt.Rectangle((start, y-0.15), end-start, 0.3, facecolor='steelblue', edgecolor='black'))
+    
+    ax.set_yticks(range(len(gene_ids_sorted)))
+    ax.set_yticklabels(gene_ids_sorted[::-1])
+    ax.set_xlabel('Genomic Position')
+    ax.set_title('Gene Structure')
+    
+    plt.tight_layout()
+    plt.savefig(args.o, dpi=args.dpi, bbox_inches='tight')
+    plt.close()
+    print(f"Gene structure plot saved to {args.o}")
+
+def cmd_exon_structure(args):
+    with open(args.ids, 'r') as f:
+        gene_ids = [line.strip() for line in f if line.strip()]
+    
+    coords = get_gene_structure(args.gff, gene_ids, feature_types=['exon'])
+    
+    gene_ids_sorted = sorted(gene_ids, key=natural_sort_key)
+    
+    fig, ax = plt.subplots(figsize=(12, max(6, len(gene_ids_sorted) * 0.5)))
+    
+    for i, gid in enumerate(gene_ids_sorted):
+        y = len(gene_ids_sorted) - i - 1
+        if gid not in coords or not coords[gid]:
+            continue
+        
+        exon_list = sorted(coords[gid])
+        gstart = min(c[0] for c in exon_list)
+        gend = max(c[1] for c in exon_list)
+        
+        ax.plot([gstart, gend], [y, y], 'k-', linewidth=1)
+        
+        for start, end in exon_list:
+            ax.add_patch(plt.Rectangle((start, y-0.2), end-start, 0.4, facecolor='green', edgecolor='black'))
+    
+    ax.set_yticks(range(len(gene_ids_sorted)))
+    ax.set_yticklabels(gene_ids_sorted[::-1])
+    ax.set_xlabel('Genomic Position')
+    ax.set_title('Exon Structure')
+    
+    plt.tight_layout()
+    plt.savefig(args.o, dpi=args.dpi, bbox_inches='tight')
+    plt.close()
+    print(f"Exon structure plot saved to {args.o}")
+
+def cmd_chromosome_map(args):
+    chr_lengths = {}
+    gene_positions = []
+    
+    with open(args.gff, 'r') as f:
+        for line in f:
+            if line.startswith('##sequence-region'):
+                parts = line.strip().split()
+                if len(parts) >= 4:
+                    chr_name = parts[1]
+                    chr_len = int(parts[3])
+                    chr_lengths[chr_name] = chr_len
+            elif not line.startswith('#'):
+                parts = line.strip().split('\t')
+                if len(parts) >= 9 and parts[2] == 'gene':
+                    chrom = parts[0]
+                    start = int(parts[3])
+                    end = int(parts[4])
+                    
+                    attr = parse_gff_attributes(parts[8])
+                    gene_id = attr.get('ID', '')
+                    
+                    gene_positions.append({
+                        'chr': chrom,
+                        'start': start,
+                        'end': end,
+                        'id': gene_id
+                    })
+                    
+                    if chrom not in chr_lengths:
+                        chr_lengths[chrom] = max(chr_lengths.get(chrom, 0), end)
+    
+    chr_sorted = sorted(chr_lengths.keys(), key=natural_sort_key)
+    
+    fig, ax = plt.subplots(figsize=(12, max(6, len(chr_sorted) * 0.5)))
+    
+    for i, chrom in enumerate(chr_sorted):
+        y = len(chr_sorted) - i - 1
+        chr_len = chr_lengths[chrom]
+        
+        ax.add_patch(plt.Rectangle((0, y-0.2), chr_len, 0.4, facecolor='lightgray', edgecolor='black'))
+        
+        chr_genes = [g for g in gene_positions if g['chr'] == chrom]
+        for gene in chr_genes:
+            mid = (gene['start'] + gene['end']) / 2
+            ax.plot([mid, mid], [y-0.15, y+0.15], 'r-', linewidth=0.5, alpha=0.5)
+    
+    ax.set_yticks(range(len(chr_sorted)))
+    ax.set_yticklabels(chr_sorted[::-1])
+    ax.set_xlabel('Position (bp)')
+    ax.set_title('Chromosome Map')
+    
+    plt.tight_layout()
+    plt.savefig(args.o, dpi=args.dpi, bbox_inches='tight')
+    plt.close()
+    print(f"Chromosome map saved to {args.o}")
+
+def cmd_protein_domain(args):
+    df = pd.read_csv(args.tsv, sep='\t', comment='#')
+    
+    required_cols = ['protein', 'domain', 'start', 'end']
+    if not all(col in df.columns for col in required_cols):
+        print(f"Error: TSV must have columns: {', '.join(required_cols)}", file=sys.stderr)
+        sys.exit(1)
+    
+    proteins = sorted(df['protein'].unique(), key=natural_sort_key)
+    
+    fig, ax = plt.subplots(figsize=(12, max(6, len(proteins) * 0.5)))
+    
+    for i, prot in enumerate(proteins):
+        y = len(proteins) - i - 1
+        prot_domains = df[df['protein'] == prot]
+        
+        max_pos = prot_domains['end'].max()
+        ax.plot([0, max_pos], [y, y], 'k-', linewidth=2)
+        
+        for _, row in prot_domains.iterrows():
+            start = row['start']
+            end = row['end']
+            domain = row['domain']
+            
+            ax.add_patch(plt.Rectangle((start, y-0.2), end-start, 0.4, 
+                                      facecolor='orange', edgecolor='black', alpha=0.7))
+            ax.text((start+end)/2, y, domain, ha='center', va='center', fontsize=8)
+    
+    ax.set_yticks(range(len(proteins)))
+    ax.set_yticklabels(proteins[::-1])
+    ax.set_xlabel('Position (aa)')
+    ax.set_title('Protein Domain Architecture')
+    
+    plt.tight_layout()
+    plt.savefig(args.o, dpi=args.dpi, bbox_inches='tight')
+    plt.close()
+    print(f"Protein domain plot saved to {args.o}")
+
+def cmd_cis_element(args):
+    elements = []
+    
+    with open(args.bed, 'r') as f:
+        for line in f:
+            if line.startswith('#') or not line.strip():
+                continue
+            parts = line.strip().split('\t')
+            if len(parts) >= 4:
+                elements.append({
+                    'chr': parts[0],
+                    'start': int(parts[1]),
+                    'end': int(parts[2]),
+                    'name': parts[3]
+                })
+    
+    chromosomes = sorted(set(e['chr'] for e in elements), key=natural_sort_key)
+    
+    fig, ax = plt.subplots(figsize=(12, max(6, len(chromosomes) * 0.5)))
+    
+    for i, chrom in enumerate(chromosomes):
+        y = len(chromosomes) - i - 1
+        chr_elements = [e for e in elements if e['chr'] == chrom]
+        
+        if chr_elements:
+            max_pos = max(e['end'] for e in chr_elements)
+            ax.plot([0, max_pos], [y, y], 'k-', linewidth=1)
+            
+            for elem in chr_elements:
+                mid = (elem['start'] + elem['end']) / 2
+                ax.plot([mid, mid], [y-0.3, y+0.3], 'b-', linewidth=2)
+                ax.text(mid, y+0.35, elem['name'], ha='center', fontsize=7, rotation=45)
+    
+    ax.set_yticks(range(len(chromosomes)))
+    ax.set_yticklabels(chromosomes[::-1])
+    ax.set_xlabel('Position (bp)')
+    ax.set_title('Cis-regulatory Elements')
+    
+    plt.tight_layout()
+    plt.savefig(args.o, dpi=args.dpi, bbox_inches='tight')
+    plt.close()
+    print(f"Cis-element plot saved to {args.o}")

jsrc-0.1.0/src/seq.py

@@ -0,0 +1,163 @@
+import sys
+import csv
+import re
+from Bio import SeqIO
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+
+def cmd_extract(args):
+    with open(args.ids, 'r') as f:
+        raw_ids = [line.strip() for line in f if line.strip()]
+        target_ids = {rid.lower().split('.')[0]: rid for rid in raw_ids}
+    
+    found_records = {}
+    
+    with open(args.fa, 'r') as infile:
+        current_header = None
+        current_seq_lines = []
+        
+        def save_record(header, seq_lines):
+            if not header:
+                return
+            full_header = header[1:]
+            first_word = full_header.split()[0]
+            
+            clean_id = first_word.lower().split('.')[0]
+            seq = ''.join(seq_lines)
+            
+            if clean_id in target_ids:
+                if clean_id not in found_records or len(seq) > len(found_records[clean_id]['seq']):
+                    found_records[clean_id] = {
+                        'header': target_ids[clean_id],
+                        'seq': seq
+                    }
+        
+        for line in infile:
+            line = line.strip()
+            if not line:
+                continue
+            if line.startswith('>'):
+                save_record(current_header, current_seq_lines)
+                current_header = line
+                current_seq_lines = []
+            else:
+                current_seq_lines.append(line)
+        
+        save_record(current_header, current_seq_lines)
+    
+    with open(args.o, 'w') as outfile:
+        for clean_id in target_ids:
+            if clean_id in found_records:
+                rec = found_records[clean_id]
+                outfile.write(f">{rec['header']}\n{rec['seq']}\n")
+    
+    print(f"Extracted {len(found_records)}/{len(target_ids)} sequences to {args.o}")
+
+def cmd_rename(args):
+    mapping = {}
+    with open(args.map, 'r') as f:
+        reader = csv.reader(f)
+        for row in reader:
+            if len(row) >= 2:
+                mapping[row[0].strip()] = row[1].strip()
+    
+    with open(args.fa, 'r') as fin, open(args.o, 'w') as fout:
+        for line in fin:
+            if line.startswith('>'):
+                old_id = line[1:].split()[0]
+                if old_id in mapping:
+                    fout.write(f">{mapping[old_id]}\n")
+                else:
+                    fout.write(line)
+            else:
+                fout.write(line)
+    
+    print(f"Renamed {len(mapping)} sequences to {args.o}")
+
+def cmd_rename_by_gff(args):
+    from common import parse_gff_attributes
+    
+    mapping = {}
+    
+    with open(args.gff, 'r') as f:
+        for line in f:
+            if line.startswith('#'):
+                continue
+            parts = line.strip().split('\t')
+            if len(parts) < 9:
+                continue
+            
+            if parts[2] == 'mRNA':
+                attr = parse_gff_attributes(parts[8])
+                tid = attr.get('ID')
+                pid = attr.get(args.parent)
+                if tid and pid:
+                    mapping[tid] = pid
+    
+    with open(args.fa, 'r') as fin, open(args.o, 'w') as fout:
+        for line in fin:
+            if line.startswith('>'):
+                old_id = line[1:].split()[0]
+                if old_id in mapping:
+                    fout.write(f">{mapping[old_id]}\n")
+                else:
+                    fout.write(line)
+            else:
+                fout.write(line)
+    
+    print(f"Renamed {len(mapping)} transcripts to {args.o}")
+
+def cmd_translate(args):
+    from common import parse_gff_attributes
+    
+    genome = SeqIO.to_dict(SeqIO.parse(args.fa, 'fasta'))
+    
+    cds_dict = {}
+    
+    with open(args.gff, 'r') as f:
+        for line in f:
+            if line.startswith('#'):
+                continue
+            parts = line.strip().split('\t')
+            if len(parts) < 9 or parts[2] != 'CDS':
+                continue
+            
+            chrom = parts[0]
+            start = int(parts[3]) - 1
+            end = int(parts[4])
+            strand = parts[6]
+            
+            attr = parse_gff_attributes(parts[8])
+            gene_id = attr.get(args.id)
+            
+            if not gene_id or chrom not in genome:
+                continue
+            
+            if gene_id not in cds_dict:
+                cds_dict[gene_id] = {'chrom': chrom, 'strand': strand, 'regions': []}
+            
+            cds_dict[gene_id]['regions'].append((start, end))
+    
+    proteins = []
+    
+    for gene_id, data in cds_dict.items():
+        chrom_seq = genome[data['chrom']].seq
+        
+        regions = sorted(data['regions'])
+        cds_seq = Seq('')
+        for start, end in regions:
+            cds_seq += chrom_seq[start:end]
+        
+        if data['strand'] == '-':
+            cds_seq = cds_seq.reverse_complement()
+        
+        try:
+            protein_seq = cds_seq.translate(to_stop=True)
+            if len(protein_seq) > 0:
+                proteins.append(SeqRecord(protein_seq, id=gene_id, description=''))
+        except Exception as e:
+            print(f"Warning: Failed to translate {gene_id}: {e}", file=sys.stderr)
+            continue
+    
+    SeqIO.write(proteins, args.o, 'fasta')
+    print(f"Translated {len(proteins)} genes to {args.o}")