denseclass 0.1.0__py3-none-any.whl

denseclass/__init__.py

@@ -0,0 +1,12 @@
+"""Signal classification for nanopore reads.
+
+Split out of the ``densecall`` basecaller into this standalone package. Nothing
+here imports ``densecall``: the only helper that was shared
+(``convert_base_name``) is vendored in ``base_util.py``.
+
+Pipeline: label -> split -> gendata -> train -> predict -> evaluate
+"""
+
+from denseclass.cli import __version__, argparser, main, subcommands
+
+__all__ = ['main', 'argparser', 'subcommands', '__version__']

denseclass/__main__.py

@@ -0,0 +1,4 @@
+from denseclass.cli import main
+
+if __name__ == '__main__':
+    main()

denseclass/base_util.py

@@ -0,0 +1,41 @@
+"""Base-name to IUPAC regular-expression helpers.
+
+Vendored from ``densecall.mod_util`` so this package has no dependency on the
+basecaller. Only ``convert_base_name`` was ever used here; the rest of
+``mod_util`` pulls in remora/mappy, which this package does not need.
+"""
+
+# IUPAC degenerate codes expanded into character classes.
+_MERGE_BASES = {
+    "A": "A",
+    "C": "C",
+    "G": "G",
+    "T": "T",
+    "M": "[AC]",
+    "V": "[ACG]",
+    "R": "[AG]",
+    "H": "[ACT]",
+    "W": "[AT]",
+    "D": "[AGT]",
+    "S": "[CG]",
+    "B": "[CGT]",
+    "Y": "[CT]",
+    "N": "[ACGT]",
+    "K": "[GT]",
+}
+
+
+def convert_base_name(base_name):
+    """Expand a base string into a regular expression pattern.
+
+    Args:
+        base_name (str): Input base string to be converted, e.g. ``"NAY"``.
+
+    Returns:
+        str: Regular expression pattern equivalent to the input, e.g.
+        ``"[ACGT]A[CT]"``.
+    """
+    pattern = ""
+    for base in base_name:
+        pattern += _MERGE_BASES.get(base, base)
+    return pattern

denseclass/cli.py

@@ -0,0 +1,76 @@
+"""Command-line namespace for signal classification.
+
+``argparser()`` builds the subcommand tree for introspection and library use;
+``main()`` is the console entry point. Both share the same leaf registration,
+and ``main`` mirrors DenseCall's two-level layout (leaves hang directly off the
+top parser) so that ``denseclass <cmd> --help`` shows the leaf's help.
+"""
+
+from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
+
+__version__ = '0.1.0'
+
+subcommands = [
+    'label', 'split', 'gendata', 'train', 'predict',
+    'precision', 'evaluation', 'comparison'
+]
+
+__all__ = ['argparser', 'main', 'subcommands', '__version__']
+
+_DESCRIPTION = ('Signal classification: label map -> split -> gendata -> '
+                'train -> predict -> evaluate')
+
+
+def _leaves():
+    """Yield (name, module) for each subcommand."""
+    for name in subcommands:
+        mod = __import__(f"denseclass.{name}", fromlist=['argparser', 'main'])
+        yield name, mod
+
+
+def _add_subparsers(parser):
+    """Attach every subcommand to ``parser`` as a real subparser."""
+    sub = parser.add_subparsers(
+        title='subcommands', description='valid commands',
+        help='additional help', dest='subcommand'
+    )
+    sub.required = True
+    for name, mod in _leaves():
+        p = sub.add_parser(name, parents=[mod.argparser()])
+        p.set_defaults(func=mod.main)
+    return sub
+
+
+def argparser():
+    """The subcommand namespace on its own (``add_help=False``, since each leaf
+    carries its own ``-h``)."""
+    parser = ArgumentParser(
+        "denseclass",
+        formatter_class=ArgumentDefaultsHelpFormatter,
+        description=_DESCRIPTION,
+        add_help=False,
+    )
+    parser.add_argument(
+        '-v', '--version', action='version',
+        version='%(prog)s {}'.format(__version__)
+    )
+    _add_subparsers(parser)
+    return parser
+
+
+def main(args=None):
+    """Console entry point: leaves hang off the top parser so
+    ``denseclass <cmd> --help`` reaches the leaf."""
+    parser = ArgumentParser(
+        'denseclass',
+        formatter_class=ArgumentDefaultsHelpFormatter,
+        description=_DESCRIPTION,
+    )
+    parser.add_argument(
+        '-v', '--version', action='version',
+        version='%(prog)s {}'.format(__version__)
+    )
+    _add_subparsers(parser)
+
+    parsed = parser.parse_args(args)
+    parsed.func(parsed)