rdkit-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9182da229ab652e734801366a87d7a75527888aab1d5fc4df16730cd9468dd88
+  data.tar.gz: 4835a455fb34e0270ff568eda78bdb560932cdb96a47b3f7e0c5cf717127f695
+SHA512:
+  metadata.gz: 4602becf8e88cdc946b7c92926dbaec2c6dad8579f42016697b89667c8242138675ef407140556b6b1097531e1b13632c1fb408b4a21783d73770ea8752f8a3e
+  data.tar.gz: 7486a4a515a40a99fe7c466deb04be027070d0cc41c16979de00300662ad607f2396df1619eb13cf7c7d493832a9b8d17d90b7fe2febbd67468ebf9c6913c0e6

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 (2024-08-08)
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,30 @@
+BSD 3-Clause License
+
+Copyright (c) 2006-2015, Rational Discovery LLC, Greg Landrum, and Julie Penzotti and others
+Copyright (c) 2024 Andrew Kane
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,177 @@
+# RDKit.rb
+
+Cheminformatics for Ruby, powered by [RDKit](https://github.com/rdkit/rdkit)
+
+[![Build Status](https://github.com/ankane/rdkit-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/ankane/rdkit-ruby/actions)
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem "rdkit-rb"
+```
+
+## Getting Started
+
+Create a molecule
+
+```ruby
+mol = RDKit::Molecule.from_smiles("c1ccccc1O")
+```
+
+Get the number of atoms
+
+```ruby
+mol.num_atoms
+```
+
+Get substructure matches
+
+```ruby
+mol.match(RDKit::Molecule.from_smarts("ccO"))
+```
+
+Get fragments
+
+```ruby
+mol.fragments
+```
+
+Generate an SVG
+
+```ruby
+mol.to_svg
+```
+
+## Fingerprints
+
+A number of [fingerprints](https://www.rdkit.org/docs/RDKit_Book.html#additional-information-about-the-fingerprints) are supported.
+
+RDKit
+
+```ruby
+mol.rdkit_fingerprint
+```
+
+Morgan
+
+```ruby
+mol.morgan_fingerprint
+```
+
+Pattern
+
+```ruby
+mol.pattern_fingerprint
+```
+
+Atom pair
+
+```ruby
+mol.atom_pair_fingerprint
+```
+
+Topological torsion
+
+```ruby
+mol.topological_torsion_fingerprint
+```
+
+MACCS
+
+```ruby
+mol.maccs_fingerprint
+```
+
+You can use a library like [pgvector-ruby](https://github.com/pgvector/pgvector-ruby) to find similar molecules. See an [example](https://github.com/pgvector/pgvector-ruby/blob/master/examples/morgan_fingerprints.rb).
+
+## Updates
+
+Add or remove hydrogen atoms
+
+```ruby
+mol.add_hs!
+mol.remove_hs!
+```
+
+Standardize
+
+```ruby
+mol.cleanup!
+mol.normalize!
+mol.neutralize!
+mol.reionize!
+mol.canonical_tautomer!
+mol.charge_parent!
+mol.fragment_parent!
+```
+
+## Conversion
+
+SMILES
+
+```ruby
+mol.to_smiles
+```
+
+SMARTS
+
+```ruby
+mol.to_smarts
+```
+
+CXSMILES
+
+```ruby
+mol.to_cxsmiles
+```
+
+CXSMARTS
+
+```ruby
+mol.to_cxsmarts
+```
+
+JSON
+
+```ruby
+mol.to_json
+```
+
+## Reactions
+
+Create a reaction
+
+```ruby
+rxn = RDKit::Reaction.from_smarts("[CH3:1][OH:2]>>[CH2:1]=[OH0:2]")
+```
+
+Generate an SVG
+
+```ruby
+rxn.to_svg
+```
+
+## History
+
+View the [changelog](https://github.com/ankane/rdkit-ruby/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/rdkit-ruby/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/rdkit-ruby/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone https://github.com/ankane/rdkit-ruby.git
+cd rdkit-ruby
+bundle install
+bundle exec rake vendor:all
+bundle exec rake test
+```

data/lib/rdkit/ffi.rb

@@ -0,0 +1,91 @@
+module RDKit
+  module FFI
+    extend Fiddle::Importer
+
+    libs = Array(RDKit.ffi_lib).dup
+    begin
+      dlload Fiddle.dlopen(libs.shift)
+    rescue Fiddle::DLError => e
+      retry if libs.any?
+      raise e
+    end
+
+    # https://github.com/rdkit/rdkit/blob/master/Code/MinimalLib/cffiwrapper.h
+
+    # I/O
+    extern "char *get_mol(const char *input, size_t *mol_sz, const char *details_json)"
+    extern "char *get_qmol(const char *input, size_t *mol_sz, const char *details_json)"
+    extern "char *get_molblock(const char *pkl, size_t pkl_sz, const char *details_json)"
+    extern "char *get_v3kmolblock(const char *pkl, size_t pkl_sz, const char *details_json)"
+    extern "char *get_smiles(const char *pkl, size_t pkl_sz, const char *details_json)"
+    extern "char *get_smarts(const char *pkl, size_t pkl_sz, const char *details_json)"
+    extern "char *get_cxsmiles(const char *pkl, size_t pkl_sz, const char *details_json)"
+    extern "char *get_cxsmarts(const char *pkl, size_t pkl_sz, const char *details_json)"
+    extern "char *get_json(const char *pkl, size_t pkl_sz, const char *details_json)"
+    extern "char *get_rxn(const char *input, size_t *mol_sz, const char *details_json)"
+    extern "char **get_mol_frags(const char *pkl, size_t pkl_sz, size_t **frags_pkl_sz_array, size_t *num_frags, const char *details_json, char **mappings_json)"
+
+    # substructure
+    extern "char *get_substruct_match(const char *mol_pkl, size_t mol_pkl_sz, const char *query_pkl, size_t query_pkl_sz, const char *options_json)"
+    extern "char *get_substruct_matches(const char *mol_pkl, size_t mol_pkl_sz, const char *query_pkl, size_t query_pkl_sz, const char *options_json)"
+
+    # drawing
+    extern "char *get_svg(const char *pkl, size_t pkl_sz, const char *details_json)"
+    extern "char *get_rxn_svg(const char *pkl, size_t pkl_sz, const char *details_json)"
+
+    # calculators
+    extern "char *get_descriptors(const char *pkl, size_t pkl_sz)"
+    extern "char *get_morgan_fp(const char *pkl, size_t pkl_sz, const char *details_json)"
+    extern "char *get_morgan_fp_as_bytes(const char *pkl, size_t pkl_sz, size_t *nbytes, const char *details_json)"
+    extern "char *get_rdkit_fp(const char *pkl, size_t pkl_sz, const char *details_json)"
+    extern "char *get_rdkit_fp_as_bytes(const char *pkl, size_t pkl_sz, size_t *nbytes, const char *details_json)"
+    extern "char *get_pattern_fp(const char *pkl, size_t pkl_sz, const char *details_json)"
+    extern "char *get_pattern_fp_as_bytes(const char *pkl, size_t pkl_sz, size_t *nbytes, const char *details_json)"
+    extern "char *get_topological_torsion_fp(const char *pkl, size_t pkl_sz, const char *details_json)"
+    extern "char *get_topological_torsion_fp_as_bytes(const char *pkl, size_t pkl_sz, size_t *nbytes, const char *details_json)"
+    extern "char *get_atom_pair_fp(const char *pkl, size_t pkl_sz, const char *details_json)"
+    extern "char *get_atom_pair_fp_as_bytes(const char *pkl, size_t pkl_sz, size_t *nbytes, const char *details_json)"
+    extern "char *get_maccs_fp(const char *pkl, size_t pkl_sz)"
+    extern "char *get_maccs_fp_as_bytes(const char *pkl, size_t pkl_sz, size_t *nbytes)"
+
+    # modification
+    extern "short add_hs(char **pkl, size_t *pkl_sz)"
+    extern "short remove_all_hs(char **pkl, size_t *pkl_sz)"
+
+    # standardization
+    extern "short cleanup(char **pkl, size_t *pkl_sz, const char *details_json)"
+    extern "short normalize(char **pkl, size_t *pkl_sz, const char *details_json)"
+    extern "short neutralize(char **pkl, size_t *pkl_sz, const char *details_json)"
+    extern "short reionize(char **pkl, size_t *pkl_sz, const char *details_json)"
+    extern "short canonical_tautomer(char **pkl, size_t *pkl_sz, const char *details_json)"
+    extern "short charge_parent(char **pkl, size_t *pkl_sz, const char *details_json)"
+    extern "short fragment_parent(char **pkl, size_t *pkl_sz, const char *details_json)"
+
+    # coordinates
+    extern "void prefer_coordgen(short val)"
+    extern "short has_coords(char *mol_pkl, size_t mol_pkl_sz)"
+    extern "short set_2d_coords(char **pkl, size_t *pkl_sz)"
+    extern "short set_3d_coords(char **pkl, size_t *pkl_sz, const char *params_json)"
+    extern "short set_2d_coords_aligned(char **pkl, size_t *pkl_sz, const char *template_pkl, size_t template_sz, const char *details_json, char **match_json)"
+
+    # housekeeping
+    # treat as void *ptr since calls free() internally
+    FREE = extern "void free_ptr(char *ptr)"
+
+    # other
+    extern "char *version()"
+    extern "void enable_logging()"
+    extern "void disable_logging()"
+
+    # chirality
+    extern "short use_legacy_stereo_perception(short value)"
+    extern "short allow_non_tetrahedral_chirality(short value)"
+
+    # logging
+    extern "void *set_log_tee(const char *log_name)"
+    extern "void *set_log_capture(const char *log_name)"
+    extern "short destroy_log_handle(void **log_handle)"
+    extern "char *get_log_buffer(void *log_handle)"
+    extern "short clear_log_buffer(void *log_handle)"
+  end
+end

data/lib/rdkit/molecule.rb

@@ -0,0 +1,340 @@
+module RDKit
+  class Molecule
+    private_class_method :new
+
+    def self.from_smiles(input, **options)
+      mol = allocate
+      mol.send(:load_smiles, input, **options)
+      mol
+    end
+
+    def self.from_smarts(input)
+      mol = allocate
+      mol.send(:load_smarts, input)
+      mol
+    end
+
+    def num_atoms(only_explicit: true)
+      if only_explicit
+        json_data["molecules"].sum { |v| v["atoms"].count }
+      else
+        descriptors["NumAtoms"].to_i
+      end
+    end
+
+    def num_heavy_atoms
+      descriptors["NumHeavyAtoms"].to_i
+    end
+
+    def match?(pattern, use_chirality: true)
+      !match(pattern, use_chirality: use_chirality, max_matches: 1).nil?
+    end
+
+    def match(pattern, use_chirality: true, max_matches: nil)
+      check_pattern(pattern)
+
+      details = {
+        useChirality: use_chirality
+      }
+      details[:maxMatches] = max_matches.to_i if max_matches
+      json = check_string(FFI.get_substruct_matches(@ptr, @sz, pattern.instance_variable_get(:@ptr), pattern.instance_variable_get(:@sz), to_details(details)))
+
+      matches = JSON.parse(json)
+      if matches.any?
+        matches.map { |v| v["atoms"] }
+      end
+    end
+
+    def fragments(sanitize: true)
+      sz_arr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+      num_frags = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SIZE_T)
+      details = {
+        sanitizeFrags: sanitize
+      }
+      arr = FFI.get_mol_frags(@ptr, @sz, sz_arr.ref, num_frags.ref, to_details(details), nil)
+      check_ptr(arr)
+
+      num_frags.to_i.times.map do |i|
+        ptr = (arr + i * Fiddle::SIZEOF_VOIDP).ptr
+        sz = (sz_arr + i * Fiddle::SIZEOF_SIZE_T).ptr
+
+        mol = self.class.allocate
+        mol.send(:load_ptr, ptr, sz)
+        mol
+      end
+    ensure
+      free_ptr(sz_arr)
+      free_ptr(arr)
+    end
+
+    def rdkit_fingerprint(min_path: 1, max_path: 7, length: 2048, bits_per_hash: 2, use_hs: true, branched_paths: true, use_bond_order: true)
+      length = length.to_i
+      check_length(length)
+
+      details = {
+        minPath: min_path.to_i,
+        maxPath: max_path.to_i,
+        nBits: length,
+        nBitsPerHash: bits_per_hash.to_i,
+        useHs: use_hs,
+        branchedPaths: branched_paths,
+        useBondOrder: use_bond_order
+      }
+      check_string(FFI.get_rdkit_fp(@ptr, @sz, to_details(details)))
+    end
+
+    def morgan_fingerprint(radius: 3, length: 2048, use_chirality: false, use_bond_types: true)
+      radius = radius.to_i
+      if radius < 1
+        raise ArgumentError, "radius must be greater than 0"
+      end
+
+      length = length.to_i
+      check_length(length)
+
+      details = {
+        radius: radius,
+        nBits: length,
+        useChirality: use_chirality,
+        useBondTypes: use_bond_types
+      }
+      check_string(FFI.get_morgan_fp(@ptr, @sz, to_details(details)))
+    end
+
+    def pattern_fingerprint(length: 2048, tautomeric: false)
+      length = length.to_i
+      check_length(length)
+
+      details = {
+        nBits: length,
+        tautomericFingerprint: tautomeric
+      }
+      check_string(FFI.get_pattern_fp(@ptr, @sz, to_details(details)))
+    end
+
+    def topological_torsion_fingerprint(length: 2048)
+      length = length.to_i
+      check_length(length)
+
+      details = {
+        nBits: length
+      }
+      check_string(FFI.get_topological_torsion_fp(@ptr, @sz, to_details(details)))
+    end
+
+    def atom_pair_fingerprint(length: 2048, min_length: 1, max_length: 30)
+      length = length.to_i
+      check_length(length)
+
+      details = {
+        nBits: length,
+        minLength: min_length.to_i,
+        maxLength: max_length.to_i
+      }
+      check_string(FFI.get_atom_pair_fp(@ptr, @sz, to_details(details)))
+    end
+
+    def maccs_fingerprint
+      # remove bit 0 for correct length
+      # https://github.com/rdkit/rdkit/issues/1726
+      check_string(FFI.get_maccs_fp(@ptr, @sz))[1..]
+    end
+
+    def add_hs
+      dup.add_hs!
+    end
+
+    def add_hs!
+      check_status(FFI.add_hs(@ptr.ref, @sz.ref))
+      self
+    end
+
+    def remove_hs
+      dup.remove_hs!
+    end
+
+    def remove_hs!
+      check_status(FFI.remove_all_hs(@ptr.ref, @sz.ref))
+      self
+    end
+
+    def cleanup
+      dup.cleanup!
+    end
+
+    def cleanup!
+      check_status(FFI.cleanup(@ptr.ref, @sz.ref, to_details({})))
+      self
+    end
+
+    def normalize
+      dup.normalize!
+    end
+
+    def normalize!
+      check_status(FFI.normalize(@ptr.ref, @sz.ref, to_details({})))
+      self
+    end
+
+    def neutralize
+      dup.neutralize!
+    end
+
+    def neutralize!
+      check_status(FFI.neutralize(@ptr.ref, @sz.ref, to_details({})))
+      self
+    end
+
+    def reionize
+      dup.reionize!
+    end
+
+    def reionize!
+      check_status(FFI.reionize(@ptr.ref, @sz.ref, to_details({})))
+      self
+    end
+
+    def canonical_tautomer
+      dup.canonical_tautomer!
+    end
+
+    def canonical_tautomer!
+      check_status(FFI.canonical_tautomer(@ptr.ref, @sz.ref, to_details({})))
+      self
+    end
+
+    def charge_parent
+      dup.charge_parent!
+    end
+
+    def charge_parent!
+      check_status(FFI.charge_parent(@ptr.ref, @sz.ref, to_details({})))
+      self
+    end
+
+    def fragment_parent
+      dup.fragment_parent!
+    end
+
+    def fragment_parent!
+      check_status(FFI.fragment_parent(@ptr.ref, @sz.ref, to_details({})))
+      self
+    end
+
+    def to_smiles
+      check_string(FFI.get_smiles(@ptr, @sz, to_details({})))
+    end
+
+    def to_smarts
+      check_string(FFI.get_smarts(@ptr, @sz, to_details({})))
+    end
+
+    def to_cxsmiles
+      check_string(FFI.get_cxsmiles(@ptr, @sz, to_details({})))
+    end
+
+    def to_cxsmarts
+      check_string(FFI.get_cxsmarts(@ptr, @sz, to_details({})))
+    end
+
+    def to_json
+      check_string(FFI.get_json(@ptr, @sz, to_details({})))
+    end
+
+    def to_svg(width: 250, height: 200)
+      details = {
+        width: width,
+        height: height
+      }
+      check_string(FFI.get_svg(@ptr, @sz, to_details(details)))
+    end
+
+    def to_s
+      "#<#{self.class.name} #{to_smiles}>"
+    end
+    alias_method :inspect, :to_s
+
+    private
+
+    def initialize_copy(other)
+      super
+      load_smiles(other.to_smiles, sanitize: false, kekulize: false, remove_hs: false)
+    end
+
+    def load_smiles(input, sanitize: true, kekulize: true, remove_hs: true)
+      sz = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SIZE_T)
+      details = {
+        sanitize: sanitize,
+        kekulize: kekulize,
+        removeHs: remove_hs
+      }
+      ptr = FFI.get_mol(input.to_str, sz.ref, to_details(details))
+      load_ptr(ptr, sz)
+    end
+
+    def load_smarts(input)
+      sz = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SIZE_T)
+      ptr = FFI.get_qmol(input.to_str, sz.ref, to_details({}))
+      load_ptr(ptr, sz)
+    end
+
+    def load_ptr(ptr, sz)
+      if ptr.null?
+        raise ArgumentError, "invalid input"
+      end
+
+      @ptr = ptr
+      @ptr.free = FFI::FREE
+      @sz = sz
+    end
+
+    def to_details(options)
+      JSON.generate(options)
+    end
+
+    def json_data
+      JSON.parse(to_json)
+    end
+
+    def descriptors
+      JSON.parse(check_string(FFI.get_descriptors(@ptr, @sz)))
+    end
+
+    def check_pattern(pattern)
+      unless pattern.is_a?(self.class)
+        raise ArgumentError, "expected #{self.class.name}"
+      end
+    end
+
+    def check_length(length)
+      if length < 1
+        raise ArgumentError, "length must be greater than 0"
+      end
+    end
+
+    def check_ptr(ptr)
+      if ptr.nil? || ptr.null?
+        raise Error, "bad pointer"
+      end
+    end
+
+    def free_ptr(ptr)
+      FFI.free_ptr(ptr) if ptr
+    end
+
+    def check_string(ptr)
+      check_ptr(ptr)
+      begin
+        ptr.to_s
+      ensure
+        free_ptr(ptr)
+      end
+    end
+
+    def check_status(status)
+      if status != 1
+        raise Error, "bad status: #{status}"
+      end
+    end
+  end
+end

data/lib/rdkit/reaction.rb

@@ -0,0 +1,66 @@
+module RDKit
+  class Reaction
+    private_class_method :new
+
+    def self.from_smarts(input)
+      rxn = allocate
+      rxn.send(:load_rxn, input)
+      rxn
+    end
+
+    def to_svg(width: 250, height: 200)
+      details = {
+        width: width,
+        height: height
+      }
+      check_string(FFI.get_rxn_svg(@ptr, @sz, to_details(details)))
+    end
+
+    def to_s
+      "#<#{self.class.name} #{@input}>"
+    end
+    alias_method :inspect, :to_s
+
+    private
+
+    def load_rxn(input)
+      sz = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SIZE_T)
+      @input = input.to_str
+      ptr = FFI.get_rxn(@input, sz.ref, to_details({}))
+      load_ptr(ptr, sz)
+    end
+
+    def load_ptr(ptr, sz)
+      if ptr.null?
+        raise ArgumentError, "invalid input"
+      end
+
+      @ptr = ptr
+      @ptr.free = FFI::FREE
+      @sz = sz
+    end
+
+    def to_details(options)
+      JSON.generate(options)
+    end
+
+    def check_ptr(ptr)
+      if ptr.nil? || ptr.null?
+        raise Error, "bad pointer"
+      end
+    end
+
+    def free_ptr(ptr)
+      FFI.free_ptr(ptr) if ptr
+    end
+
+    def check_string(ptr)
+      check_ptr(ptr)
+      begin
+        ptr.to_s
+      ensure
+        free_ptr(ptr)
+      end
+    end
+  end
+end