rdkit-cli 0.1.0__py3-none-any.whl

rdkit_cli/commands/fragment.py

@@ -0,0 +1,284 @@
+"""Fragment 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 fragment command and subcommands."""
+    parser = subparsers.add_parser(
+        "fragment",
+        help="Fragment molecules",
+        description="Fragment molecules using BRICS, RECAP, or functional group analysis.",
+        formatter_class=RdkitHelpFormatter,
+    )
+
+    frag_subparsers = parser.add_subparsers(
+        title="Subcommands",
+        dest="subcommand",
+        metavar="<subcommand>",
+    )
+
+    # fragment brics
+    brics_parser = frag_subparsers.add_parser(
+        "brics",
+        help="Fragment using BRICS algorithm",
+        formatter_class=RdkitHelpFormatter,
+    )
+    add_common_io_options(brics_parser)
+    add_common_processing_options(brics_parser)
+    brics_parser.add_argument(
+        "--min-size",
+        type=int,
+        default=1,
+        metavar="N",
+        help="Minimum fragment heavy atom count (default: 1)",
+    )
+    brics_parser.set_defaults(func=run_brics)
+
+    # fragment recap
+    recap_parser = frag_subparsers.add_parser(
+        "recap",
+        help="Fragment using RECAP algorithm",
+        formatter_class=RdkitHelpFormatter,
+    )
+    add_common_io_options(recap_parser)
+    add_common_processing_options(recap_parser)
+    recap_parser.add_argument(
+        "--min-size",
+        type=int,
+        default=1,
+        metavar="N",
+        help="Minimum fragment heavy atom count (default: 1)",
+    )
+    recap_parser.set_defaults(func=run_recap)
+
+    # fragment functional-groups
+    fg_parser = frag_subparsers.add_parser(
+        "functional-groups",
+        help="Extract functional group counts",
+        formatter_class=RdkitHelpFormatter,
+    )
+    add_common_io_options(fg_parser)
+    add_common_processing_options(fg_parser)
+    fg_parser.set_defaults(func=run_functional_groups)
+
+    # fragment analyze
+    analyze_parser = frag_subparsers.add_parser(
+        "analyze",
+        help="Analyze fragment frequency distribution",
+        formatter_class=RdkitHelpFormatter,
+    )
+    analyze_parser.add_argument(
+        "-i", "--input",
+        required=True,
+        metavar="FILE",
+        help="Input file with fragment_smiles column",
+    )
+    analyze_parser.add_argument(
+        "-o", "--output",
+        metavar="FILE",
+        help="Output file (optional, prints to stdout if not specified)",
+    )
+    analyze_parser.add_argument(
+        "--fragment-column",
+        default="fragment_smiles",
+        help="Name of fragment column (default: fragment_smiles)",
+    )
+    analyze_parser.add_argument(
+        "--top",
+        type=int,
+        default=20,
+        help="Number of top fragments to show (default: 20)",
+    )
+    analyze_parser.add_argument(
+        "--no-header",
+        action="store_true",
+        help="Input file has no header row",
+    )
+    analyze_parser.set_defaults(func=run_analyze)
+
+    # Set default for main parser
+    parser.set_defaults(func=lambda args: parser.print_help() or 1)
+
+
+def run_brics(args) -> int:
+    """Run BRICS fragmentation."""
+    from rdkit_cli.core.fragment import BRICSFragmenter
+    from rdkit_cli.io import create_reader, create_writer
+
+    fragmenter = BRICSFragmenter(
+        min_fragment_size=args.min_size,
+    )
+
+    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)
+
+    total_input = 0
+    total_fragments = 0
+
+    with reader, writer:
+        for record in reader:
+            total_input += 1
+            results = fragmenter.fragment(record)
+            for result in results:
+                writer.write_row(result)
+                total_fragments += 1
+
+    if not args.quiet:
+        print(
+            f"Generated {total_fragments} BRICS fragments from {total_input} molecules",
+            file=sys.stderr,
+        )
+
+    return 0
+
+
+def run_recap(args) -> int:
+    """Run RECAP fragmentation."""
+    from rdkit_cli.core.fragment import RECAPFragmenter
+    from rdkit_cli.io import create_reader, create_writer
+
+    fragmenter = RECAPFragmenter(
+        min_fragment_size=args.min_size,
+    )
+
+    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)
+
+    total_input = 0
+    total_fragments = 0
+
+    with reader, writer:
+        for record in reader:
+            total_input += 1
+            results = fragmenter.fragment(record)
+            for result in results:
+                writer.write_row(result)
+                total_fragments += 1
+
+    if not args.quiet:
+        print(
+            f"Generated {total_fragments} RECAP fragments from {total_input} molecules",
+            file=sys.stderr,
+        )
+
+    return 0
+
+
+def run_functional_groups(args) -> int:
+    """Run functional group extraction."""
+    from rdkit_cli.core.fragment import FunctionalGroupExtractor
+    from rdkit_cli.io import create_reader, create_writer
+
+    extractor = FunctionalGroupExtractor()
+
+    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)
+
+    # Note: Running single-threaded because RDKit FragmentCatalog
+    # objects can't be pickled for multiprocessing
+    total = 0
+    successful = 0
+
+    with reader, writer:
+        for record in reader:
+            total += 1
+            result = extractor.extract(record)
+            if result is not None:
+                writer.write_row(result)
+                successful += 1
+
+    if not args.quiet:
+        print(
+            f"Extracted functional groups for {successful}/{total} molecules "
+            f"({total - successful} failed)",
+            file=sys.stderr,
+        )
+
+    return 0
+
+
+def run_analyze(args) -> int:
+    """Run fragment frequency analysis."""
+    import pandas as pd
+    from rdkit_cli.core.fragment import analyze_fragments
+
+    input_path = Path(args.input)
+    if not input_path.exists():
+        print(f"Error: Input file not found: {input_path}", file=sys.stderr)
+        return 1
+
+    # Read fragment data
+    header = 0 if not args.no_header else None
+    df = pd.read_csv(input_path, header=header)
+
+    if args.no_header:
+        fragment_col = df.columns[0]
+    else:
+        fragment_col = args.fragment_column
+
+    if fragment_col not in df.columns:
+        print(f"Error: Fragment column '{fragment_col}' not found", file=sys.stderr)
+        return 1
+
+    fragments = df[fragment_col].dropna().tolist()
+    results = analyze_fragments(fragments, top_n=args.top)
+
+    # Output
+    output_lines = ["fragment,count,percentage"]
+    for fragment, count, pct in results:
+        fragment_escaped = fragment.replace('"', '""')
+        output_lines.append(f'"{fragment_escaped}",{count},{pct}')
+
+    output_text = "\n".join(output_lines)
+
+    if args.output:
+        output_path = Path(args.output)
+        with open(output_path, "w") as f:
+            f.write(output_text + "\n")
+        print(f"Wrote fragment analysis to {output_path}", file=sys.stderr)
+    else:
+        print(output_text)
+
+    print(f"\nTotal fragments: {len(fragments)}, Unique: {len(set(fragments))}", file=sys.stderr)
+
+    return 0

rdkit_cli/commands/mcs.py

@@ -0,0 +1,162 @@
+"""MCS (Maximum Common Substructure) command implementation."""
+
+import sys
+from pathlib import Path
+
+from rdkit_cli.cli import RdkitHelpFormatter, add_common_processing_options
+
+
+def register_parser(subparsers):
+    """Register the mcs command."""
+    parser = subparsers.add_parser(
+        "mcs",
+        help="Find Maximum Common Substructure",
+        description="Find the Maximum Common Substructure (MCS) of molecules.",
+        formatter_class=RdkitHelpFormatter,
+    )
+
+    parser.add_argument(
+        "-i", "--input",
+        required=True,
+        metavar="FILE",
+        help="Input file with molecules",
+    )
+    parser.add_argument(
+        "-o", "--output",
+        metavar="FILE",
+        help="Output file (optional, prints to stdout if not specified)",
+    )
+    add_common_processing_options(parser)
+
+    # MCS options
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=60,
+        metavar="SEC",
+        help="Maximum time in seconds (default: 60)",
+    )
+    parser.add_argument(
+        "--threshold",
+        type=float,
+        default=1.0,
+        metavar="T",
+        help="Fraction of molecules that must contain MCS (default: 1.0)",
+    )
+    parser.add_argument(
+        "--maximize",
+        choices=["atoms", "bonds"],
+        default="atoms",
+        help="What to maximize (default: atoms)",
+    )
+    parser.add_argument(
+        "--no-ring-matches-ring",
+        action="store_true",
+        help="Allow ring atoms to match non-ring atoms",
+    )
+    parser.add_argument(
+        "--no-complete-rings",
+        action="store_true",
+        help="Allow partial ring matches",
+    )
+    parser.add_argument(
+        "--match-valences",
+        action="store_true",
+        help="Match atom valences",
+    )
+    parser.add_argument(
+        "--match-chirality",
+        action="store_true",
+        help="Match chirality",
+    )
+    parser.add_argument(
+        "--atom-compare",
+        choices=["any", "elements", "isotopes"],
+        default="elements",
+        help="Atom comparison method (default: elements)",
+    )
+    parser.add_argument(
+        "--bond-compare",
+        choices=["any", "order", "orderexact"],
+        default="order",
+        help="Bond comparison method (default: order)",
+    )
+
+    parser.set_defaults(func=run_mcs)
+
+
+def run_mcs(args) -> int:
+    """Run MCS finding."""
+    from rdkit_cli.core.mcs import find_mcs
+    from rdkit_cli.io import create_reader
+
+    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,
+    )
+
+    if not args.quiet:
+        print("Reading molecules...", file=sys.stderr)
+
+    # Read all molecules
+    records = list(reader)
+    mols = [r.mol for r in records if r.mol is not None]
+
+    if len(mols) < 2:
+        print("Error: Need at least 2 valid molecules for MCS", file=sys.stderr)
+        return 1
+
+    if not args.quiet:
+        print(f"Finding MCS for {len(mols)} molecules...", file=sys.stderr)
+
+    # Find MCS
+    result = find_mcs(
+        mols,
+        timeout=args.timeout,
+        threshold=args.threshold,
+        maximize=args.maximize,
+        ring_matches_ring_only=not args.no_ring_matches_ring,
+        complete_rings_only=not args.no_complete_rings,
+        match_valences=args.match_valences,
+        match_chiral_tag=args.match_chirality,
+        atom_compare=args.atom_compare,
+        bond_compare=args.bond_compare,
+    )
+
+    if result is None:
+        print("Error: MCS computation failed", file=sys.stderr)
+        return 1
+
+    if result.get("error"):
+        print(f"Error: {result['error']}", file=sys.stderr)
+        return 1
+
+    # Output results
+    if args.output:
+        from rdkit_cli.io import create_writer
+        output_path = Path(args.output)
+        writer = create_writer(output_path)
+        with writer:
+            writer.write_row(result)
+        if not args.quiet:
+            print(f"Wrote MCS result to {output_path}", file=sys.stderr)
+    else:
+        print("\nMCS Results")
+        print("=" * 50)
+
+        if result.get("canceled"):
+            print(f"WARNING: Search timed out after {args.timeout}s")
+
+        print(f"SMARTS: {result.get('smarts', 'N/A')}")
+        print(f"Atoms:  {result.get('num_atoms', 0)}")
+        print(f"Bonds:  {result.get('num_bonds', 0)}")
+        print("=" * 50)
+
+    return 0

rdkit_cli/commands/reactions.py

@@ -0,0 +1,191 @@
+"""Reactions 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 reactions command and subcommands."""
+    parser = subparsers.add_parser(
+        "reactions",
+        help="Apply chemical reactions and transformations",
+        description="Apply SMIRKS transformations and enumerate reaction products.",
+        formatter_class=RdkitHelpFormatter,
+    )
+
+    rxn_subparsers = parser.add_subparsers(
+        title="Subcommands",
+        dest="subcommand",
+        metavar="<subcommand>",
+    )
+
+    # reactions transform
+    transform_parser = rxn_subparsers.add_parser(
+        "transform",
+        help="Apply SMIRKS transformation",
+        formatter_class=RdkitHelpFormatter,
+    )
+    add_common_io_options(transform_parser)
+    add_common_processing_options(transform_parser)
+    transform_parser.add_argument(
+        "-s", "--smirks",
+        required=True,
+        metavar="SMIRKS",
+        help="SMIRKS transformation pattern",
+    )
+    transform_parser.add_argument(
+        "--max-products",
+        type=int,
+        default=100,
+        help="Maximum products per molecule (default: 100)",
+    )
+    transform_parser.set_defaults(func=run_transform)
+
+    # reactions enumerate
+    enum_parser = rxn_subparsers.add_parser(
+        "enumerate",
+        help="Enumerate reaction products",
+        formatter_class=RdkitHelpFormatter,
+    )
+    add_common_io_options(enum_parser)
+    add_common_processing_options(enum_parser)
+    enum_parser.add_argument(
+        "-t", "--template",
+        required=True,
+        metavar="SMARTS",
+        help="Reaction SMARTS template",
+    )
+    enum_parser.add_argument(
+        "--reactant2",
+        metavar="FILE",
+        help="Second reactant file (if reaction has 2 reactants)",
+    )
+    enum_parser.add_argument(
+        "--max-products",
+        type=int,
+        default=1000,
+        help="Maximum total products (default: 1000)",
+    )
+    enum_parser.set_defaults(func=run_enumerate)
+
+    # Set default for main parser
+    parser.set_defaults(func=lambda args: parser.print_help() or 1)
+
+
+def run_transform(args) -> int:
+    """Run SMIRKS transformation."""
+    # Lazy imports
+    from rdkit_cli.core.reactions import ReactionTransformer
+    from rdkit_cli.io import create_reader, create_writer
+    from rdkit_cli.parallel.batch import process_molecules
+
+    try:
+        transformer = ReactionTransformer(
+            smirks=args.smirks,
+            max_products=args.max_products,
+        )
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    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)
+
+    with reader, writer:
+        result = process_molecules(
+            reader=reader,
+            writer=writer,
+            processor=transformer.transform,
+            n_workers=args.ncpu,
+            quiet=args.quiet,
+        )
+
+    if not args.quiet:
+        print(
+            f"Transformed {result.successful}/{result.total_processed} molecules "
+            f"({result.total_processed - result.successful - result.failed} no reaction, "
+            f"{result.failed} failed) in {result.elapsed_time:.1f}s",
+            file=sys.stderr,
+        )
+
+    return 0
+
+
+def run_enumerate(args) -> int:
+    """Run reaction enumeration."""
+    # Lazy imports
+    from rdkit_cli.core.reactions import ReactionEnumerator
+    from rdkit_cli.io import create_reader, create_writer
+
+    try:
+        enumerator = ReactionEnumerator(
+            reaction_smarts=args.template,
+            max_products=args.max_products,
+        )
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    # Read reactants
+    input_path = Path(args.input)
+    if not input_path.exists():
+        print(f"Error: Input file not found: {input_path}", file=sys.stderr)
+        return 1
+
+    if not args.quiet:
+        print("Reading reactants...", file=sys.stderr)
+
+    reader1 = create_reader(
+        input_path,
+        smiles_column=args.smiles_column,
+        has_header=not args.no_header,
+    )
+    mols1 = [r.mol for r in reader1 if r.mol is not None]
+
+    reactant_lists = [mols1]
+
+    # Read second reactant file if provided
+    if args.reactant2:
+        reactant2_path = Path(args.reactant2)
+        if not reactant2_path.exists():
+            print(f"Error: Reactant2 file not found: {reactant2_path}", file=sys.stderr)
+            return 1
+
+        reader2 = create_reader(reactant2_path, smiles_column=args.smiles_column)
+        mols2 = [r.mol for r in reader2 if r.mol is not None]
+        reactant_lists.append(mols2)
+
+    if not args.quiet:
+        print(f"Enumerating products from {len(mols1)} reactant(s)...", file=sys.stderr)
+
+    try:
+        products = enumerator.enumerate(reactant_lists)
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    # Write output
+    output_path = Path(args.output)
+    writer = create_writer(output_path)
+
+    with writer:
+        writer.write_batch(products)
+
+    if not args.quiet:
+        print(f"Generated {len(products)} products. Wrote to {output_path}", file=sys.stderr)
+
+    return 0