rdkit-cli 0.1.0__py3-none-any.whl

rdkit_cli/__init__.py

@@ -0,0 +1,4 @@
+"""rdkit-cli: A comprehensive CLI tool for RDKit cheminformatics operations."""
+
+__version__ = "0.1.0"
+__author__ = "Vitruves"

rdkit_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m rdkit_cli."""
+
+from rdkit_cli.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

rdkit_cli/cli.py

@@ -0,0 +1,162 @@
+"""Main CLI entry point for rdkit-cli."""
+
+import argparse
+import sys
+from typing import Optional
+
+from rich_argparse import RichHelpFormatter
+
+from rdkit_cli import __version__
+
+
+class RdkitHelpFormatter(RichHelpFormatter):
+    """Custom formatter with adjusted styles and command-first ordering."""
+
+    styles = {
+        **RichHelpFormatter.styles,
+        "argparse.args": "cyan",
+        "argparse.groups": "bold yellow",
+        "argparse.metavar": "green",
+        "argparse.prog": "bold magenta",
+    }
+
+
+def add_common_io_options(parser: argparse.ArgumentParser):
+    """Add common I/O options to a parser."""
+    parser.add_argument(
+        "-i", "--input",
+        required=True,
+        metavar="FILE",
+        help="Input file (CSV, TSV, SMI, SDF, or Parquet)",
+    )
+    parser.add_argument(
+        "-o", "--output",
+        required=True,
+        metavar="FILE",
+        help="Output file",
+    )
+
+
+def add_common_processing_options(parser: argparse.ArgumentParser):
+    """Add common processing options to a parser."""
+    parser.add_argument(
+        "-n", "--ncpu",
+        type=int,
+        default=-1,
+        metavar="N",
+        help="Number of CPU cores (-1 for all, default: -1)",
+    )
+    parser.add_argument(
+        "--smiles-column",
+        default="smiles",
+        metavar="COL",
+        help="Name of SMILES column (default: smiles)",
+    )
+    parser.add_argument(
+        "--name-column",
+        default=None,
+        metavar="COL",
+        help="Name of molecule name column",
+    )
+    parser.add_argument(
+        "--no-header",
+        action="store_true",
+        help="Input file has no header row",
+    )
+    parser.add_argument(
+        "-q", "--quiet",
+        action="store_true",
+        help="Suppress progress output",
+    )
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create the main argument parser."""
+    parser = argparse.ArgumentParser(
+        prog="rdkit-cli",
+        description="A comprehensive CLI tool for RDKit cheminformatics operations.",
+        epilog="Use 'rdkit-cli <command> --help' for command-specific help.",
+        formatter_class=RdkitHelpFormatter,
+    )
+
+    # Version
+    parser.add_argument(
+        "-V", "--version",
+        action="version",
+        version=f"rdkit-cli {__version__}",
+    )
+
+    # Create subparsers for commands
+    subparsers = parser.add_subparsers(
+        title="Commands",
+        dest="command",
+        metavar="<command>",
+    )
+
+    # Register all command modules
+    _register_commands(subparsers)
+
+    return parser
+
+
+def _register_commands(subparsers):
+    """Register all command subparsers."""
+    from rdkit_cli.commands import (
+        descriptors,
+        fingerprints,
+        filter,
+        convert,
+        standardize,
+        similarity,
+        conformers,
+        reactions,
+        scaffold,
+        enumerate,
+        fragment,
+        diversity,
+        mcs,
+        depict,
+    )
+
+    # Each module has a register_parser(subparsers) function
+    descriptors.register_parser(subparsers)
+    fingerprints.register_parser(subparsers)
+    filter.register_parser(subparsers)
+    convert.register_parser(subparsers)
+    standardize.register_parser(subparsers)
+    similarity.register_parser(subparsers)
+    conformers.register_parser(subparsers)
+    reactions.register_parser(subparsers)
+    scaffold.register_parser(subparsers)
+    enumerate.register_parser(subparsers)
+    fragment.register_parser(subparsers)
+    diversity.register_parser(subparsers)
+    mcs.register_parser(subparsers)
+    depict.register_parser(subparsers)
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Main entry point."""
+    parser = create_parser()
+    parsed_args = parser.parse_args(args)
+
+    if parsed_args.command is None:
+        parser.print_help()
+        return 1
+
+    # Each command has a run(args) function via set_defaults(func=...)
+    try:
+        return parsed_args.func(parsed_args)
+    except KeyboardInterrupt:
+        sys.stderr.write("\nInterrupted.\n")
+        return 130
+    except BrokenPipeError:
+        # Handle broken pipe gracefully (e.g., piping to head)
+        return 0
+    except Exception as e:
+        sys.stderr.write(f"Error: {e}\n")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

rdkit_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command implementations."""

rdkit_cli/commands/conformers.py

@@ -0,0 +1,220 @@
+"""Conformers command implementation."""
+
+import sys
+from pathlib import Path
+
+from rdkit_cli.cli import RdkitHelpFormatter, add_common_io_options, add_common_processing_options
+
+
+def register_parser(subparsers):
+    """Register the conformers command and subcommands."""
+    parser = subparsers.add_parser(
+        "conformers",
+        help="Generate and optimize 3D conformers",
+        description="Generate and optimize 3D molecular conformers.",
+        formatter_class=RdkitHelpFormatter,
+    )
+
+    conf_subparsers = parser.add_subparsers(
+        title="Subcommands",
+        dest="subcommand",
+        metavar="<subcommand>",
+    )
+
+    # conformers generate
+    gen_parser = conf_subparsers.add_parser(
+        "generate",
+        help="Generate 3D conformers",
+        formatter_class=RdkitHelpFormatter,
+    )
+    add_common_io_options(gen_parser)
+    add_common_processing_options(gen_parser)
+    gen_parser.add_argument(
+        "--num",
+        type=int,
+        default=10,
+        metavar="N",
+        help="Number of conformers to generate (default: 10)",
+    )
+    gen_parser.add_argument(
+        "-m", "--method",
+        choices=["etkdgv3", "etkdgv2", "etdg"],
+        default="etkdgv3",
+        help="Embedding method (default: etkdgv3)",
+    )
+    gen_parser.add_argument(
+        "--no-optimize",
+        action="store_true",
+        help="Skip force field optimization",
+    )
+    gen_parser.add_argument(
+        "-f", "--force-field",
+        choices=["mmff", "uff"],
+        default="mmff",
+        help="Force field for optimization (default: mmff)",
+    )
+    gen_parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed (default: 42)",
+    )
+    gen_parser.add_argument(
+        "--prune-rms",
+        type=float,
+        default=0.5,
+        metavar="THRESH",
+        help="RMSD threshold for pruning similar conformers (default: 0.5)",
+    )
+    gen_parser.add_argument(
+        "--energy-window",
+        type=float,
+        default=None,
+        metavar="KCAL",
+        help="Keep only conformers within N kcal/mol of lowest energy",
+    )
+    gen_parser.add_argument(
+        "--add-hydrogens",
+        action="store_true",
+        default=True,
+        help="Add hydrogens before embedding (default: True)",
+    )
+    gen_parser.add_argument(
+        "--no-hydrogens",
+        action="store_true",
+        help="Don't add hydrogens",
+    )
+    gen_parser.add_argument(
+        "--use-basic-knowledge",
+        action="store_true",
+        help="Use basic knowledge about conformer preferences",
+    )
+    gen_parser.add_argument(
+        "--max-attempts",
+        type=int,
+        default=0,
+        metavar="N",
+        help="Maximum embedding attempts per conformer (0 = auto)",
+    )
+    gen_parser.set_defaults(func=run_generate)
+
+    # conformers optimize
+    opt_parser = conf_subparsers.add_parser(
+        "optimize",
+        help="Optimize existing 3D structures",
+        formatter_class=RdkitHelpFormatter,
+    )
+    add_common_io_options(opt_parser)
+    add_common_processing_options(opt_parser)
+    opt_parser.add_argument(
+        "-f", "--force-field",
+        choices=["mmff", "uff"],
+        default="mmff",
+        help="Force field for optimization (default: mmff)",
+    )
+    opt_parser.add_argument(
+        "--max-iter",
+        type=int,
+        default=200,
+        help="Maximum optimization iterations (default: 200)",
+    )
+    opt_parser.set_defaults(func=run_optimize)
+
+    # Set default for main parser
+    parser.set_defaults(func=lambda args: parser.print_help() or 1)
+
+
+def run_generate(args) -> int:
+    """Run conformer generation."""
+    # Lazy imports
+    from rdkit_cli.core.conformers import ConformerGenerator
+    from rdkit_cli.io import create_reader, create_writer, FileFormat
+    from rdkit_cli.parallel.batch import process_molecules
+
+    generator = ConformerGenerator(
+        num_conformers=args.num,
+        method=args.method,
+        optimize=not args.no_optimize,
+        force_field=args.force_field,
+        random_seed=args.seed,
+    )
+
+    input_path = Path(args.input)
+    if not input_path.exists():
+        print(f"Error: Input file not found: {input_path}", file=sys.stderr)
+        return 1
+
+    reader = create_reader(
+        input_path,
+        smiles_column=args.smiles_column,
+        name_column=args.name_column,
+        has_header=not args.no_header,
+    )
+
+    # Force SDF output for 3D structures
+    output_path = Path(args.output)
+    writer = create_writer(output_path, format_override=FileFormat.SDF)
+
+    with reader, writer:
+        result = process_molecules(
+            reader=reader,
+            writer=writer,
+            processor=generator.generate,
+            n_workers=args.ncpu,
+            quiet=args.quiet,
+        )
+
+    if not args.quiet:
+        print(
+            f"Generated conformers for {result.successful}/{result.total_processed} molecules "
+            f"({result.failed} failed) in {result.elapsed_time:.1f}s",
+            file=sys.stderr,
+        )
+
+    return 0 if result.failed == 0 else 1
+
+
+def run_optimize(args) -> int:
+    """Run conformer optimization."""
+    # Lazy imports
+    from rdkit_cli.core.conformers import ConformerOptimizer
+    from rdkit_cli.io import create_reader, create_writer, FileFormat
+    from rdkit_cli.parallel.batch import process_molecules
+
+    optimizer = ConformerOptimizer(
+        force_field=args.force_field,
+        max_iterations=args.max_iter,
+    )
+
+    input_path = Path(args.input)
+    if not input_path.exists():
+        print(f"Error: Input file not found: {input_path}", file=sys.stderr)
+        return 1
+
+    reader = create_reader(
+        input_path,
+        smiles_column=args.smiles_column,
+        name_column=args.name_column,
+        has_header=not args.no_header,
+    )
+
+    output_path = Path(args.output)
+    writer = create_writer(output_path, format_override=FileFormat.SDF)
+
+    with reader, writer:
+        result = process_molecules(
+            reader=reader,
+            writer=writer,
+            processor=optimizer.optimize,
+            n_workers=args.ncpu,
+            quiet=args.quiet,
+        )
+
+    if not args.quiet:
+        print(
+            f"Optimized {result.successful}/{result.total_processed} molecules "
+            f"({result.failed} failed) in {result.elapsed_time:.1f}s",
+            file=sys.stderr,
+        )
+
+    return 0 if result.failed == 0 else 1

rdkit_cli/commands/convert.py

@@ -0,0 +1,162 @@
+"""Convert command implementation."""
+
+import sys
+from pathlib import Path
+
+from rdkit_cli.cli import RdkitHelpFormatter, add_common_io_options, add_common_processing_options
+
+# Define formats here to avoid loading io module at startup
+FILE_FORMATS = ["csv", "tsv", "smi", "sdf", "parquet"]
+
+
+def register_parser(subparsers):
+    """Register the convert command."""
+    parser = subparsers.add_parser(
+        "convert",
+        help="Convert between molecular file formats",
+        description="Convert molecules between different file formats and representations.",
+        formatter_class=RdkitHelpFormatter,
+    )
+
+    add_common_io_options(parser)
+    add_common_processing_options(parser)
+
+    parser.add_argument(
+        "--in-format",
+        choices=FILE_FORMATS,
+        help="Input format (auto-detected from extension if not specified)",
+    )
+    parser.add_argument(
+        "--out-format",
+        choices=FILE_FORMATS,
+        help="Output format (auto-detected from extension if not specified)",
+    )
+    parser.add_argument(
+        "--canonical",
+        action="store_true",
+        default=True,
+        help="Canonicalize SMILES output (default: True)",
+    )
+    parser.add_argument(
+        "--no-canonical",
+        action="store_false",
+        dest="canonical",
+        help="Don't canonicalize SMILES output",
+    )
+    parser.add_argument(
+        "--add-inchi",
+        action="store_true",
+        help="Add InChI column to output",
+    )
+    parser.add_argument(
+        "--add-inchikey",
+        action="store_true",
+        help="Add InChIKey column to output",
+    )
+
+    parser.set_defaults(func=run_convert)
+
+
+def run_convert(args) -> int:
+    """Run the convert command."""
+    # Lazy imports
+    from typing import Optional, Any
+    from rdkit import Chem
+    from rdkit.Chem.inchi import MolToInchi, MolToInchiKey
+    from rdkit_cli.io import create_reader, create_writer, FileFormat, detect_format
+    from rdkit_cli.io.readers import MoleculeRecord
+    from rdkit_cli.parallel.batch import process_molecules
+
+    class FormatConverter:
+        """Convert molecules between formats."""
+
+        def __init__(
+            self,
+            canonical: bool = True,
+            add_inchi: bool = False,
+            add_inchikey: bool = False,
+        ):
+            self.canonical = canonical
+            self.add_inchi = add_inchi
+            self.add_inchikey = add_inchikey
+
+        def convert(self, record: MoleculeRecord) -> Optional[dict[str, Any]]:
+            """Convert a molecule record."""
+            if record.mol is None:
+                return None
+
+            result: dict[str, Any] = {}
+
+            # Generate canonical SMILES
+            result["smiles"] = Chem.MolToSmiles(record.mol, canonical=self.canonical)
+
+            if record.name:
+                result["name"] = record.name
+
+            # Add InChI if requested
+            if self.add_inchi:
+                try:
+                    result["inchi"] = MolToInchi(record.mol)
+                except Exception:
+                    result["inchi"] = ""
+
+            # Add InChIKey if requested
+            if self.add_inchikey:
+                try:
+                    result["inchikey"] = MolToInchiKey(record.mol)
+                except Exception:
+                    result["inchikey"] = ""
+
+            # Copy other metadata
+            for key, value in record.metadata.items():
+                if key not in result and key != "smiles":
+                    result[key] = value
+
+            return result
+
+    input_path = Path(args.input)
+    if not input_path.exists():
+        print(f"Error: Input file not found: {input_path}", file=sys.stderr)
+        return 1
+
+    # Detect formats
+    in_format = FileFormat(args.in_format) if args.in_format else detect_format(input_path)
+    output_path = Path(args.output)
+    out_format = FileFormat(args.out_format) if args.out_format else detect_format(output_path)
+
+    # Create converter
+    converter = FormatConverter(
+        canonical=args.canonical,
+        add_inchi=args.add_inchi,
+        add_inchikey=args.add_inchikey,
+    )
+
+    # Create reader
+    reader = create_reader(
+        input_path,
+        smiles_column=args.smiles_column,
+        name_column=args.name_column,
+        has_header=not args.no_header,
+    )
+
+    # Create writer
+    writer = create_writer(output_path)
+
+    # Process
+    with reader, writer:
+        result = process_molecules(
+            reader=reader,
+            writer=writer,
+            processor=converter.convert,
+            n_workers=args.ncpu,
+            quiet=args.quiet,
+        )
+
+    if not args.quiet:
+        print(
+            f"Converted {result.successful}/{result.total_processed} molecules "
+            f"({result.failed} failed) in {result.elapsed_time:.1f}s",
+            file=sys.stderr,
+        )
+
+    return 0 if result.failed == 0 else 1