jsrc 0.2.2__tar.gz → 0.2.3__tar.gz

{jsrc-0.2.2/src/jsrc.egg-info → jsrc-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsrc
-Version: 0.2.2
+Version: 0.2.3
 Summary: Python library for bioinformatics and scientific computing
 Author-email: Jiaoyuan <imjiaoyuan@gmail.com>
 License-Expression: MIT

{jsrc-0.2.2 → jsrc-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jsrc"
-version = "0.2.2"
+version = "0.2.3"
 description = "Python library for bioinformatics and scientific computing"
 readme = "README.md"
 requires-python = ">=3.10"

jsrc-0.2.3/src/jsrc/analyze/__init__.py

@@ -0,0 +1,41 @@
+import importlib
+from typing import Any
+
+_SUBCOMMANDS: dict[str, tuple[str, str]] = {
+    "phylo": ("jsrc.analyze.phylo", "Build phylogenetic trees"),
+    "motif": ("jsrc.analyze.motif", "Motif discovery and reporting"),
+    "qc": ("jsrc.analyze.qc", "Alignment/sequence QC"),
+    "msa_consensus": ("jsrc.analyze.msa_consensus", "MSA consensus statistics"),
+    "snpindel": ("jsrc.analyze.snpindel", "SNP/INDEL analysis from alignments"),
+    "bootstrap_phylo": ("jsrc.analyze.bootstrap_phylo", "Bootstrap phylogeny support"),
+}
+
+
+def _register_stub_subcommands(subparsers: Any) -> None:
+    for name, (_, help_text) in _SUBCOMMANDS.items():
+        subparsers.add_parser(name, help=help_text)
+
+
+def _register_selected_subcommand(subparsers: Any, selected: str) -> bool:
+    module_path, _ = _SUBCOMMANDS.get(selected, ("", ""))
+    if not module_path:
+        return False
+    mod = importlib.import_module(module_path)
+    reg = getattr(mod, "register", None)
+    if reg is None:
+        raise AttributeError(f"{module_path}: missing register")
+    reg(subparsers)
+    return True
+
+
+def register_subparser(
+    subparsers: Any, selected_subcommand: str | None = None
+) -> None:
+    analyze_parser = subparsers.add_parser("analyze", help="Analysis tools")
+    analyze_sub = analyze_parser.add_subparsers(dest="analyze_cmd")
+    analyze_parser.set_defaults(_group_parser=analyze_parser)
+    if selected_subcommand and _register_selected_subcommand(
+        analyze_sub, selected_subcommand
+    ):
+        return
+    _register_stub_subcommands(analyze_sub)

{jsrc-0.2.2 → jsrc-0.2.3}/src/jsrc/cli.py

@@ -1,5 +1,6 @@
 import argparse
 import importlib
+import inspect
 import logging
 import os
 import sys
@@ -24,6 +25,16 @@ MODULES = {
     "job": "jsrc.job",
 }
 
+MODULE_HELP = {
+    "seq": "Sequence tools",
+    "plot": "Visualization",
+    "analyze": "Analysis workflows",
+    "gs": "Genomic selection",
+    "grn": "GRN tools",
+    "vision": "Image analysis",
+    "job": "Background jobs",
+}
+
 
 def _iter_enabled_modules() -> list[str]:
     only = [x.strip() for x in os.getenv("JSRC_MODULES", "").split(",") if x.strip()]
@@ -34,31 +45,7 @@ def _iter_enabled_modules() -> list[str]:
     return [n for n in names if n in MODULES and n not in disabled]
 
 
-def _register_modules(
-    subparsers: argparse.Action, *, debug: bool = False
-) -> tuple[list[str], list[str]]:
-    loaded: list[str] = []
-    errors: list[str] = []
-    for name in _iter_enabled_modules():
-        try:
-            mod = importlib.import_module(MODULES[name])
-            reg = getattr(mod, "register_subparser", None)
-            if reg is None:
-                errors.append(f"{name}: missing register_subparser")
-                continue
-            reg(subparsers)
-            loaded.append(name)
-        except (ImportError, AttributeError) as exc:
-            if debug:
-                raise
-            errors.append(f"{name}: {exc}")
-    return loaded, errors
-
-
-def main() -> None:
-    debug_mode = "--debug" in sys.argv[1:]
-    verbose = "--verbose" in sys.argv[1:] or debug_mode
-    setup_logging(verbose=verbose)
+def _build_base_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="jsrc", description="General-purpose bioinformatics and data toolkit"
     )
@@ -69,17 +56,76 @@ def main() -> None:
         action="store_true",
         help="Show traceback for module loading and runtime errors",
     )
-    subparsers = parser.add_subparsers(dest="command", help="Available modules")
+    return parser
+
+
+def _register_stub_modules(
+    subparsers: argparse.Action, enabled_modules: list[str]
+) -> None:
+    for name in enabled_modules:
+        subparsers.add_parser(name, help=MODULE_HELP.get(name, f"{name} module"))
 
-    loaded, errors = _register_modules(subparsers, debug=debug_mode)
-    if errors:
-        logging.warning("some modules failed to load:")
-        for item in errors:
-            logging.warning("  - %s", item)
-    if not loaded:
+
+def _register_one_module(
+    subparsers: argparse.Action,
+    module_name: str,
+    *,
+    selected_subcommand: str | None = None,
+    debug: bool = False,
+) -> bool:
+    try:
+        mod = importlib.import_module(MODULES[module_name])
+        reg = getattr(mod, "register_subparser", None)
+        if reg is None:
+            raise AttributeError("missing register_subparser")
+        params = inspect.signature(reg).parameters
+        if "selected_subcommand" in params:
+            reg(subparsers, selected_subcommand=selected_subcommand)
+        else:
+            reg(subparsers)
+        return True
+    except (ImportError, AttributeError) as exc:
+        if debug:
+            raise
+        logging.error("Error: failed to load module '%s': %s", module_name, exc)
+        return False
+
+
+def _probe_route(argv: list[str]) -> tuple[str | None, str | None]:
+    probe = argparse.ArgumentParser(add_help=False)
+    probe.add_argument("--verbose", action="store_true")
+    probe.add_argument("--debug", action="store_true")
+    probe.add_argument("-v", "--version", action="store_true")
+    probe.add_argument("command", nargs="?")
+    probe.add_argument("subcommand", nargs="?")
+    args, _ = probe.parse_known_args(argv)
+    return args.command, args.subcommand
+
+
+def main() -> None:
+    argv = sys.argv[1:]
+    debug_mode = "--debug" in argv
+    verbose = "--verbose" in sys.argv[1:] or debug_mode
+    setup_logging(verbose=verbose)
+    enabled_modules = _iter_enabled_modules()
+    if not enabled_modules:
         logging.error("no module loaded")
         sys.exit(2)
 
+    requested_module, requested_subcommand = _probe_route(argv)
+    parser = _build_base_parser()
+    subparsers = parser.add_subparsers(dest="command", help="Available modules")
+    if requested_module and requested_module in enabled_modules:
+        if not _register_one_module(
+            subparsers,
+            requested_module,
+            selected_subcommand=requested_subcommand,
+            debug=debug_mode,
+        ):
+            sys.exit(2)
+    else:
+        _register_stub_modules(subparsers, enabled_modules)
+
     args = parser.parse_args()
     if not args.command:
         parser.print_help()

jsrc-0.2.3/src/jsrc/grn/__init__.py

@@ -0,0 +1,36 @@
+import importlib
+from typing import Any
+
+_SUBCOMMANDS: dict[str, tuple[str, str]] = {
+    "build": ("jsrc.grn.build", "Build GRN viewer package"),
+    "net2json": ("jsrc.grn.net2json", "Convert GRN edge table to grn.json"),
+    "anno2json": ("jsrc.grn.anno2json", "Convert annotation table to annotation.json"),
+    "serve": ("jsrc.grn.serve", "Start GRN viewer service"),
+    "centrality": ("jsrc.grn.centrality", "Compute GRN centrality metrics"),
+}
+
+
+def _register_stub_subcommands(subparsers: Any) -> None:
+    for name, (_, help_text) in _SUBCOMMANDS.items():
+        subparsers.add_parser(name, help=help_text)
+
+
+def _register_selected_subcommand(subparsers: Any, selected: str) -> bool:
+    module_path, _ = _SUBCOMMANDS.get(selected, ("", ""))
+    if not module_path:
+        return False
+    mod = importlib.import_module(module_path)
+    reg = getattr(mod, "register", None)
+    if reg is None:
+        raise AttributeError(f"{module_path}: missing register")
+    reg(subparsers)
+    return True
+
+
+def register_subparser(subparsers: Any, selected_subcommand: str | None = None) -> None:
+    grn_parser = subparsers.add_parser("grn", help="GRN conversion and local viewer")
+    grn_sub = grn_parser.add_subparsers(dest="grn_cmd")
+    grn_parser.set_defaults(_group_parser=grn_parser)
+    if selected_subcommand and _register_selected_subcommand(grn_sub, selected_subcommand):
+        return
+    _register_stub_subcommands(grn_sub)

jsrc-0.2.3/src/jsrc/gs/__init__.py

@@ -0,0 +1,36 @@
+import importlib
+from typing import Any
+
+_SUBCOMMANDS: dict[str, tuple[str, str]] = {
+    "build": ("jsrc.gs.build", "Build genomic selection datasets"),
+    "split": ("jsrc.gs.split", "Split GS datasets into folds"),
+    "train": ("jsrc.gs.train", "Train and evaluate GS models"),
+}
+
+
+def _register_stub_subcommands(subparsers: Any) -> None:
+    for name, (_, help_text) in _SUBCOMMANDS.items():
+        subparsers.add_parser(name, help=help_text)
+
+
+def _register_selected_subcommand(subparsers: Any, selected: str) -> bool:
+    module_path, _ = _SUBCOMMANDS.get(selected, ("", ""))
+    if not module_path:
+        return False
+    mod = importlib.import_module(module_path)
+    reg = getattr(mod, "register", None)
+    if reg is None:
+        raise AttributeError(f"{module_path}: missing register")
+    reg(subparsers)
+    return True
+
+
+def register_subparser(subparsers: Any, selected_subcommand: str | None = None) -> None:
+    gs_parser = subparsers.add_parser(
+        "gs", help="Genomic selection dataset and model workflows"
+    )
+    gs_sub = gs_parser.add_subparsers(dest="gs_cmd")
+    gs_parser.set_defaults(_group_parser=gs_parser)
+    if selected_subcommand and _register_selected_subcommand(gs_sub, selected_subcommand):
+        return
+    _register_stub_subcommands(gs_sub)

jsrc-0.2.3/src/jsrc/job/__init__.py

@@ -0,0 +1,38 @@
+import importlib
+from typing import Any
+
+_SUBCOMMANDS: dict[str, tuple[str, str]] = {
+    "submit": ("jsrc.job.submit", "Submit a background job"),
+    "ls": ("jsrc.job.ls", "List jobs"),
+    "show": ("jsrc.job.show", "Show one job"),
+    "logs": ("jsrc.job.logs", "Show job logs"),
+    "kill": ("jsrc.job.kill", "Terminate a running job"),
+    "history": ("jsrc.job.history", "Show job history"),
+    "gc": ("jsrc.job.gc", "Garbage-collect old job artifacts"),
+}
+
+
+def _register_stub_subcommands(subparsers: Any) -> None:
+    for name, (_, help_text) in _SUBCOMMANDS.items():
+        subparsers.add_parser(name, help=help_text)
+
+
+def _register_selected_subcommand(subparsers: Any, selected: str) -> bool:
+    module_path, _ = _SUBCOMMANDS.get(selected, ("", ""))
+    if not module_path:
+        return False
+    mod = importlib.import_module(module_path)
+    reg = getattr(mod, "register", None)
+    if reg is None:
+        raise AttributeError(f"{module_path}: missing register")
+    reg(subparsers)
+    return True
+
+
+def register_subparser(subparsers: Any, selected_subcommand: str | None = None) -> None:
+    job_parser = subparsers.add_parser("job", help="Track and manage background jobs")
+    job_sub = job_parser.add_subparsers(dest="job_cmd")
+    job_parser.set_defaults(_group_parser=job_parser)
+    if selected_subcommand and _register_selected_subcommand(job_sub, selected_subcommand):
+        return
+    _register_stub_subcommands(job_sub)

jsrc-0.2.3/src/jsrc/plot/__init__.py

@@ -0,0 +1,42 @@
+import importlib
+from typing import Any
+
+_SUBCOMMANDS: dict[str, tuple[str, str]] = {
+    "gene": ("jsrc.plot.gene", "Plot gene structure diagram"),
+    "exon": ("jsrc.plot.exon", "Plot exon structure diagram"),
+    "chromosome": ("jsrc.plot.chromosome", "Plot chromosome map"),
+    "domain": ("jsrc.plot.domain", "Plot protein domain architecture"),
+    "cis": ("jsrc.plot.cis", "Plot cis-regulatory elements"),
+    "heart": ("jsrc.plot.heart", "Plot heart curve"),
+    "rose": ("jsrc.plot.rose", "Plot 3D rose model"),
+    "dotplot": ("jsrc.plot.dotplot", "Sequence dotplot by exact k-mer matches"),
+    "circoslite": ("jsrc.plot.circoslite", "Simple circular tracks for genome stats"),
+}
+
+
+def _register_stub_subcommands(subparsers: Any) -> None:
+    for name, (_, help_text) in _SUBCOMMANDS.items():
+        subparsers.add_parser(name, help=help_text)
+
+
+def _register_selected_subcommand(subparsers: Any, selected: str) -> bool:
+    module_path, _ = _SUBCOMMANDS.get(selected, ("", ""))
+    if not module_path:
+        return False
+    mod = importlib.import_module(module_path)
+    reg = getattr(mod, "register", None)
+    if reg is None:
+        raise AttributeError(f"{module_path}: missing register")
+    reg(subparsers)
+    return True
+
+
+def register_subparser(
+    subparsers: Any, selected_subcommand: str | None = None
+) -> None:
+    plot_parser = subparsers.add_parser("plot", help="Visualization")
+    plot_sub = plot_parser.add_subparsers(dest="plot_cmd")
+    plot_parser.set_defaults(_group_parser=plot_parser)
+    if selected_subcommand and _register_selected_subcommand(plot_sub, selected_subcommand):
+        return
+    _register_stub_subcommands(plot_sub)

jsrc-0.2.3/src/jsrc/plot/heart.py

@@ -0,0 +1,82 @@
+import os
+import sys
+
+import numpy as np
+from argparse import Namespace
+from typing import Any
+
+
+def _load_interactive_pyplot() -> Any:
+    try:
+        import matplotlib
+    except ImportError as exc:
+        raise SystemExit(
+            "matplotlib is required for this command. Install it with: pip install matplotlib"
+        ) from exc
+
+    env_backend = os.getenv("MPLBACKEND", "").strip()
+    if env_backend:
+        import matplotlib.pyplot as plt
+
+        if "agg" in matplotlib.get_backend().lower():
+            raise SystemExit(
+                "jsrc plot heart requires an interactive matplotlib backend. "
+                "Current MPLBACKEND is non-interactive."
+            )
+        return plt
+
+    if sys.platform.startswith("linux") and not (
+        os.getenv("DISPLAY") or os.getenv("WAYLAND_DISPLAY")
+    ):
+        raise SystemExit(
+            "No graphical display detected. Set DISPLAY/WAYLAND_DISPLAY or run in a desktop session."
+        )
+
+    for backend in ("TkAgg", "QtAgg", "Qt5Agg", "GTK3Agg", "WXAgg", "MacOSX"):
+        try:
+            matplotlib.use(backend, force=True)
+            import matplotlib.pyplot as plt
+
+            if "agg" not in matplotlib.get_backend().lower():
+                return plt
+        except (ImportError, ValueError):
+            continue
+
+    raise SystemExit(
+        "No interactive matplotlib backend is available. "
+        "Install a GUI backend (for example python3-tk or PyQt6)."
+    )
+
+
+def cmd(args: Namespace) -> None:
+    plt = _load_interactive_pyplot()
+    x = np.arange(-1.8, 1.8, 0.005)
+
+    plt.figure(figsize=(12, 10))
+    plt.grid(True)
+    plt.axis([-3, 3, -2, 4])
+
+    plt.text(
+        0,
+        3.3,
+        r"$f(x)=x^{\frac{2}{3}}+0.9(3.3-x^2)^{\frac{1}{2}}\sin(\alpha\pi x)$",
+        fontsize=28,
+        ha="center",
+    )
+    txt = plt.text(-0.35, 2.9, "", fontsize=26, ha="left")
+    (line,) = plt.plot([], [], linewidth=3.5, color="#CD5555")
+
+    for alpha in np.arange(1, 20.01, 0.01):
+        y = np.cbrt(x**2) + 0.9 * np.sqrt(np.clip(3.3 - x**2, 0, None)) * np.sin(
+            alpha * np.pi * x
+        )
+        line.set_data(x, y)
+        txt.set_text(rf"$\alpha={alpha:.2f}$")
+        plt.pause(0.003)
+
+    plt.show()
+
+
+def register(subparsers: Any) -> None:
+    p = subparsers.add_parser("heart", help="Plot heart curve")
+    p.set_defaults(func=cmd)

jsrc-0.2.3/src/jsrc/seq/__init__.py

@@ -0,0 +1,41 @@
+import importlib
+from typing import Any
+
+_SUBCOMMANDS: dict[str, tuple[str, str]] = {
+    "extract": ("jsrc.seq.extract", "Extract sequences by IDs"),
+    "fetch": ("jsrc.seq.fetch", "Fetch sequences from remote databases"),
+    "digest": ("jsrc.seq.digest", "Simulate restriction enzyme digestion"),
+    "rename": ("jsrc.seq.rename", "Rename FASTA headers"),
+    "translate": ("jsrc.seq.translate", "Translate CDS/DNA to protein"),
+    "promoter": ("jsrc.seq.promoter", "Extract promoter sequences"),
+    "qc": ("jsrc.seq.qc", "Sequence quality statistics"),
+    "codon": ("jsrc.seq.codon", "Codon usage analysis"),
+    "kmer": ("jsrc.seq.kmer", "Count k-mer frequencies"),
+    "window": ("jsrc.seq.window", "Sliding-window sequence statistics"),
+}
+
+
+def _register_stub_subcommands(subparsers: Any) -> None:
+    for name, (_, help_text) in _SUBCOMMANDS.items():
+        subparsers.add_parser(name, help=help_text)
+
+
+def _register_selected_subcommand(subparsers: Any, selected: str) -> bool:
+    module_path, _ = _SUBCOMMANDS.get(selected, ("", ""))
+    if not module_path:
+        return False
+    mod = importlib.import_module(module_path)
+    reg = getattr(mod, "register", None)
+    if reg is None:
+        raise AttributeError(f"{module_path}: missing register")
+    reg(subparsers)
+    return True
+
+
+def register_subparser(subparsers: Any, selected_subcommand: str | None = None) -> None:
+    seq_parser = subparsers.add_parser("seq", help="Sequence operations")
+    seq_sub = seq_parser.add_subparsers(dest="seq_cmd")
+    seq_parser.set_defaults(_group_parser=seq_parser)
+    if selected_subcommand and _register_selected_subcommand(seq_sub, selected_subcommand):
+        return
+    _register_stub_subcommands(seq_sub)

jsrc-0.2.3/src/jsrc/vision/__init__.py

@@ -0,0 +1,40 @@
+import importlib
+from typing import Any
+
+_SUBCOMMANDS: dict[str, tuple[str, str]] = {
+    "extract": ("jsrc.vision.extract", "Extract objects from images"),
+    "efd": ("jsrc.vision.efd", "Elliptic Fourier descriptor analysis"),
+    "traits": ("jsrc.vision.traits", "Measure morphology traits"),
+}
+
+
+def _register_stub_subcommands(subparsers: Any) -> None:
+    for name, (_, help_text) in _SUBCOMMANDS.items():
+        subparsers.add_parser(name, help=help_text)
+
+
+def _register_selected_subcommand(subparsers: Any, selected: str) -> bool:
+    module_path, _ = _SUBCOMMANDS.get(selected, ("", ""))
+    if not module_path:
+        return False
+    mod = importlib.import_module(module_path)
+    reg = getattr(mod, "register", None)
+    if reg is None:
+        raise AttributeError(f"{module_path}: missing register")
+    reg(subparsers)
+    return True
+
+
+def register_subparser(
+    subparsers: Any, selected_subcommand: str | None = None
+) -> None:
+    vision_parser = subparsers.add_parser(
+        "vision", help="Image recognition and shape descriptors"
+    )
+    vision_sub = vision_parser.add_subparsers(dest="vision_cmd")
+    vision_parser.set_defaults(_group_parser=vision_parser)
+    if selected_subcommand and _register_selected_subcommand(
+        vision_sub, selected_subcommand
+    ):
+        return
+    _register_stub_subcommands(vision_sub)

{jsrc-0.2.2 → jsrc-0.2.3/src/jsrc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsrc
-Version: 0.2.2
+Version: 0.2.3
 Summary: Python library for bioinformatics and scientific computing
 Author-email: Jiaoyuan <imjiaoyuan@gmail.com>
 License-Expression: MIT

{jsrc-0.2.2 → jsrc-0.2.3}/tests/test_cli_module_flows.py

@@ -42,6 +42,62 @@ def test_cli_debug_mode_raises_original_exception(monkeypatch):
         cli.main()
 
 
+def test_cli_plot_help_imports_only_plot_module(monkeypatch):
+    imported: list[str] = []
+    real_import = cli.importlib.import_module
+
+    def _spy(name: str):
+        imported.append(name)
+        return real_import(name)
+
+    monkeypatch.setattr(cli.importlib, "import_module", _spy)
+    monkeypatch.setattr(sys, "argv", ["jsrc", "plot", "-h"])
+    with pytest.raises(SystemExit) as exc:
+        cli.main()
+    assert exc.value.code == 0
+    assert imported == ["jsrc.plot"]
+
+
+def test_cli_root_help_does_not_import_modules(monkeypatch):
+    imported: list[str] = []
+    real_import = cli.importlib.import_module
+
+    def _spy(name: str):
+        imported.append(name)
+        return real_import(name)
+
+    monkeypatch.setattr(cli.importlib, "import_module", _spy)
+    monkeypatch.setattr(sys, "argv", ["jsrc", "-h"])
+    with pytest.raises(SystemExit) as exc:
+        cli.main()
+    assert exc.value.code == 0
+    assert imported == []
+
+
+@pytest.mark.parametrize(
+    ("argv", "expected_imports"),
+    [
+        (["jsrc", "plot", "heart", "-h"], ["jsrc.plot", "jsrc.plot.heart"]),
+        (["jsrc", "seq", "window", "-h"], ["jsrc.seq", "jsrc.seq.window"]),
+        (["jsrc", "grn", "centrality", "-h"], ["jsrc.grn", "jsrc.grn.centrality"]),
+    ],
+)
+def test_cli_imports_only_selected_subcommand(monkeypatch, argv, expected_imports):
+    imported: list[str] = []
+    real_import = cli.importlib.import_module
+
+    def _spy(name: str):
+        imported.append(name)
+        return real_import(name)
+
+    monkeypatch.setattr(cli.importlib, "import_module", _spy)
+    monkeypatch.setattr(sys, "argv", argv)
+    with pytest.raises(SystemExit) as exc:
+        cli.main()
+    assert exc.value.code == 0
+    assert imported == expected_imports
+
+
 def test_job_submit_and_list_flow(tmp_path, capsys, monkeypatch):
     monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path / "xdg"))
     monkeypatch.setenv("JSRC_JOBS_FILE", str(tmp_path / "jobs.tsv"))

jsrc-0.2.2/src/jsrc/analyze/__init__.py

@@ -1,16 +0,0 @@
-from typing import Any
-
-from jsrc.analyze import bootstrap_phylo, motif, msa_consensus, phylo, qc, snpindel
-
-
-def register_subparser(subparsers: Any) -> None:
-    analyze_parser = subparsers.add_parser("analyze", help="Analysis tools")
-    analyze_sub = analyze_parser.add_subparsers(dest="analyze_cmd")
-    analyze_parser.set_defaults(_group_parser=analyze_parser)
-
-    phylo.register(analyze_sub)
-    motif.register(analyze_sub)
-    qc.register(analyze_sub)
-    msa_consensus.register(analyze_sub)
-    snpindel.register(analyze_sub)
-    bootstrap_phylo.register(analyze_sub)

jsrc-0.2.2/src/jsrc/grn/__init__.py

@@ -1,15 +0,0 @@
-from typing import Any
-
-from jsrc.grn import anno2json, build, centrality, net2json, serve
-
-
-def register_subparser(subparsers: Any) -> None:
-    grn_parser = subparsers.add_parser("grn", help="GRN conversion and local viewer")
-    grn_sub = grn_parser.add_subparsers(dest="grn_cmd")
-    grn_parser.set_defaults(_group_parser=grn_parser)
-
-    build.register(grn_sub)
-    net2json.register(grn_sub)
-    anno2json.register(grn_sub)
-    serve.register(grn_sub)
-    centrality.register(grn_sub)

jsrc-0.2.2/src/jsrc/gs/__init__.py

@@ -1,15 +0,0 @@
-from typing import Any
-
-from jsrc.gs import build, split, train
-
-
-def register_subparser(subparsers: Any) -> None:
-    gs_parser = subparsers.add_parser(
-        "gs", help="Genomic selection dataset and model workflows"
-    )
-    gs_sub = gs_parser.add_subparsers(dest="gs_cmd")
-    gs_parser.set_defaults(_group_parser=gs_parser)
-
-    build.register(gs_sub)
-    split.register(gs_sub)
-    train.register(gs_sub)

jsrc-0.2.2/src/jsrc/job/__init__.py

@@ -1,17 +0,0 @@
-from typing import Any
-
-from jsrc.job import gc, history, kill, logs, ls, show, submit
-
-
-def register_subparser(subparsers: Any) -> None:
-    job_parser = subparsers.add_parser("job", help="Track and manage background jobs")
-    job_sub = job_parser.add_subparsers(dest="job_cmd")
-    job_parser.set_defaults(_group_parser=job_parser)
-
-    submit.register(job_sub)
-    ls.register(job_sub)
-    show.register(job_sub)
-    logs.register(job_sub)
-    kill.register(job_sub)
-    history.register(job_sub)
-    gc.register(job_sub)

jsrc-0.2.2/src/jsrc/plot/__init__.py

@@ -1,29 +0,0 @@
-from typing import Any
-
-from jsrc.plot import (
-    chromosome,
-    circoslite,
-    cis,
-    domain,
-    dotplot,
-    exon,
-    gene,
-    heart,
-    rose,
-)
-
-
-def register_subparser(subparsers: Any) -> None:
-    plot_parser = subparsers.add_parser("plot", help="Visualization")
-    plot_sub = plot_parser.add_subparsers(dest="plot_cmd")
-    plot_parser.set_defaults(_group_parser=plot_parser)
-
-    gene.register(plot_sub)
-    exon.register(plot_sub)
-    chromosome.register(plot_sub)
-    domain.register(plot_sub)
-    cis.register(plot_sub)
-    heart.register(plot_sub)
-    rose.register(plot_sub)
-    dotplot.register(plot_sub)
-    circoslite.register(plot_sub)

jsrc-0.2.2/src/jsrc/plot/heart.py

@@ -1,37 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-from argparse import Namespace
-from typing import Any
-
-
-def cmd(args: Namespace) -> None:
-    x = np.arange(-1.8, 1.8, 0.005)
-
-    plt.figure(figsize=(12, 10))
-    plt.grid(True)
-    plt.axis([-3, 3, -2, 4])
-
-    plt.text(
-        0,
-        3.3,
-        r"$f(x)=x^{\frac{2}{3}}+0.9(3.3-x^2)^{\frac{1}{2}}\sin(\alpha\pi x)$",
-        fontsize=28,
-        ha="center",
-    )
-    txt = plt.text(-0.35, 2.9, "", fontsize=26, ha="left")
-    (line,) = plt.plot([], [], linewidth=3.5, color="#CD5555")
-
-    for alpha in np.arange(1, 20.01, 0.01):
-        y = np.cbrt(x**2) + 0.9 * np.sqrt(np.clip(3.3 - x**2, 0, None)) * np.sin(
-            alpha * np.pi * x
-        )
-        line.set_data(x, y)
-        txt.set_text(rf"$\alpha={alpha:.2f}$")
-        plt.pause(0.003)
-
-    plt.show()
-
-
-def register(subparsers: Any) -> None:
-    p = subparsers.add_parser("heart", help="Plot heart curve")
-    p.set_defaults(func=cmd)

jsrc-0.2.2/src/jsrc/seq/__init__.py

@@ -1,31 +0,0 @@
-from typing import Any
-
-from jsrc.seq import (
-    codon,
-    digest,
-    extract,
-    fetch,
-    kmer,
-    promoter,
-    qc,
-    rename,
-    translate,
-    window,
-)
-
-
-def register_subparser(subparsers: Any) -> None:
-    seq_parser = subparsers.add_parser("seq", help="Sequence operations")
-    seq_sub = seq_parser.add_subparsers(dest="seq_cmd")
-    seq_parser.set_defaults(_group_parser=seq_parser)
-
-    extract.register(seq_sub)
-    fetch.register(seq_sub)
-    digest.register(seq_sub)
-    rename.register(seq_sub)
-    translate.register(seq_sub)
-    promoter.register(seq_sub)
-    qc.register(seq_sub)
-    codon.register(seq_sub)
-    kmer.register(seq_sub)
-    window.register(seq_sub)

jsrc-0.2.2/src/jsrc/vision/__init__.py

@@ -1,15 +0,0 @@
-from typing import Any
-
-from jsrc.vision import efd, extract, traits
-
-
-def register_subparser(subparsers: Any) -> None:
-    vision_parser = subparsers.add_parser(
-        "vision", help="Image recognition and shape descriptors"
-    )
-    vision_sub = vision_parser.add_subparsers(dest="vision_cmd")
-    vision_parser.set_defaults(_group_parser=vision_parser)
-
-    extract.register(vision_sub)
-    efd.register(vision_sub)
-    traits.register(vision_sub)