chemruby 0.9.3

data/lib/chem/db/pubchem.rb

@@ -0,0 +1,113 @@
+#
+# chem/db/pubchem.rb - PubChem database class
+#
+#   Copyright (C) 2005 KADOWAKI Tadashi <kado@kuicr.kyoto-u.ac.jp>
+#                      TANAKA   Nobuya  <tanaka@kuicr.kyoto-u.ac.jp>
+#
+#
+
+require 'uri'
+require 'net/http'
+
+module Chem
+
+  module Molecule
+    def search_pubchem
+    end
+  end
+
+  module PubChem
+
+    Host="pubchem.ncbi.nlm.nih.gov"
+    Summary="/summary/summary.cgi"
+
+    class PubChem
+      Searchpath="/search/"
+      Query="PreQSrv.cgi"
+      Boundary="-----boundary-----"
+
+      Data = [
+        Boundary, "Content-Disposition: form-data; name=\"mode\"", "", "simplequery",
+        Boundary, "Content-Disposition: form-data; name=\"check\"", "", "remote",
+        Boundary, "Content-Disposition: form-data; name=\"execution\"", "", "remote",
+        Boundary, "Content-Disposition: form-data; name=\"queue\"", "", "ssquery",
+        Boundary, "Content-Disposition: form-data; name=\"simple_searchdata\"", "", '%s',
+        Boundary, "Content-Disposition: form-data; name=\"simple_cid\"", "", "",
+        Boundary, "Content-Disposition: form-data; name=\"simple_sid\"", "", "",
+        Boundary, "Content-Disposition: form-data; name=\"file\"; filename=\"\"",
+        "Content-Type: application/octet-stream", "", "",
+        Boundary, "Content-Disposition: form-data; name=\"simple_searchtype\"", "", "fs",
+        Boundary, "Content-Disposition: form-data; name=\"maxhits\"", "", '%s',
+        Boundary].join("\x0d\x0a")
+
+      def self.smiles_search(smiles, maxhits=100)
+        cid = []
+        url = ""
+        body = ""
+        Net::HTTP.version_1_2
+        Net::HTTP.start(Host, 80) do |http|
+          body = http.post(Searchpath + Query, Data % [smiles, maxhits],
+                           {'Content-Type' => "multipart/form-data; boundary=#{Boundary}",
+                             'Referer' => "http://pubchem.ncbi.nlm.nih.gov/search/"}).body
+          if m = /url="([^"]+)"/.match(body)
+            body = http.get(Searchpath + m[1]).body
+          end
+          while /setTimeout\('document.location.replace\("([^"]+)"\);', (\d+)\)/ =~ body do
+            sleep($2.to_f/100)
+            response = http.get(URI.parse($1))
+            body = response.body
+            url = response['location']
+          end
+          if /PubChem structure search report:(\s|\S)+No hits/ !~ body
+            # text format
+            url.sub!(/cmd=Select\+from\+History/, 'cmd=Text&dopt=Brief')
+            body = http.get(url).body
+            body.scan(/\d+: CID: (\d+)/).each do |id|
+              cid.push(PubChemEntry.new(id[0].to_i))
+            end
+            #           # html format
+            #           body = http.get(url).body
+            #           while /CID: <a href=\"([^"]+)\">(\d+)<\/a>/ =~ body do
+            #            cid.push($2)
+            #            body = $'
+            #           end
+          end
+        end
+        cid
+      end
+
+    end
+
+    class PubChemEntry
+
+      def initialize cid
+        @cid = cid
+      end
+
+      def get_xml
+        Net::HTTP.version_1_2
+        Net::HTTP.get(Host, Summary + "\?disopt=DisplayXML&cid=%dd" % @cid)
+      end
+
+      def get_sdf
+        Net::HTTP.version_1_2
+        Net::HTTP.get(Host, Summary + "\?disopt=DisplaySDF&cid=%d" % @cid)
+      end
+
+    end
+  end
+
+end
+
+if $0 == __FILE__
+  smiles="CC23(CCC1c4ccc(O)cc4(CCC1C3(CC(O)C2(O))))"
+  puts "===== CID(s) for SMILES, #{smiles} ====="
+  cid = Chem::PubChem.smiles_search(smiles)
+  p cid
+  puts "===== MOL format data ===="
+  cid.each do |c|
+    puts c.get_sdf
+  end
+#  p Chem::PubChem.get_xml(cid[0])
+#  puts Chem::PubChem.get_xml(cid[0]).sdf2mol.data
+end

data/lib/chem/db/rmagick.rb

@@ -0,0 +1,70 @@
+# RMagick adaptor for chem/db/vector.rb
+
+require 'chem/db/vector'
+
+module Chem
+  class RMagickWriter
+
+    include Writer
+
+    # Constructor for RMagick Adaptor
+    # See chem/db/vector.rb for detail parameters
+    def initialize mol, params
+      params[:size]        ||= [350, 350]
+      params[:orig_point]  ||= [10, 10]
+      params[:margin]      ||= [10, 10]
+      @default_pointsize = (params[:pointsize] ? params[:pointsize] : 14)
+      params[:upside_down] = params[:upside_down] ? false : true
+      super
+    end
+
+    # Draws line
+    # This method may be invoked from chem/db/vector.rb
+    def line(from, to, color)
+      @canvas.stroke("rgb(%f, %f, %f)" % color)
+      @canvas.line(from[0], from[1], to[0], to[1])
+    end
+
+    def fill(nodes, color, params = {})
+      @canvas.fill("rgb(%f, %f, %f)" % params[:color]) if params[:color]
+      path = nodes.inject([]){|ret, node| ret << node[0] ; ret << node[1]}
+      @canvas.polygon(* path)
+    end
+
+    def text(str, x, y, params = {})
+      @canvas.pointsize = @default_pointsize
+      metrics = @canvas.get_type_metrics(@img, str)
+      @canvas.stroke('transparent')
+      @canvas.pointsize(params[:pontsize])             if params[:pointsize]
+      @canvas.fill("rgb(%f, %f, %f)" % params[:color]) if params[:color]
+
+      @canvas.text(x - metrics.width / 2.0,
+                   y + metrics.height / 4.0,
+                   str)
+
+      @canvas.pointsize(@default_pointsize)            if params[:pointsize]
+      @canvas.fill('black')                            if params[:color]
+    end
+
+    def self.save(mol, filename, params)
+      writer = self.new(mol, params)
+      writer.draw(filename, params)
+    end
+
+    def draw filename, params
+      @img = Magick::ImageList.new
+      x, y = params[:size]
+      x += params[:margin][0] * 2
+      y += params[:margin][0] * 2
+      @img.new_image(x, y)
+
+      @canvas = Magick::Draw.new
+      draw_body
+      
+      @canvas.draw(@img)
+      @img.write(filename)
+    end
+
+  end
+end
+

data/lib/chem/db/sdf.rb

@@ -0,0 +1,37 @@
+
+
+module Chem
+
+  module MDL
+
+    class SdfParser
+      include Enumerable
+
+      def initialize file
+        require 'chem/db/mdl'
+        @input = open(file)
+      end
+
+      def each
+        @input.rewind
+
+        # for \r\n and \n
+        first_entry = true
+        from = 0
+        @input.each("$$$$") do |entry|
+          from = entry.index("\n") + 1unless first_entry
+          first_entry = false
+          next if entry[from..-1].length < 3
+          yield MdlMolecule.parse_io(StringIO.new(entry[from..-1]))
+        end
+
+      end
+
+      def self.parse file
+        SdfParser.new(file)
+      end
+
+    end
+    
+  end
+end

data/lib/chem/db/smbl.rb

@@ -0,0 +1,88 @@
+#!/usr/local/bin/ruby
+# obsolete class
+require 'rexml/document'
+
+include REXML
+
+
+module Chem
+  module SMBL
+
+    class Specie
+      attr_reader :name
+      def initialize name, compartment, boundaryCondition, initialAmount
+        @name = name
+        @compartment = compartment
+        @boundaryCondition = "false" == boundaryCondition
+        @initialAmount = initialAmount.to_f
+      end
+    end
+
+    class SMBLReaction
+
+      attr_reader :reactants, :products, :name
+      def initialize name, reversible
+        @name = name
+        @reversible = reversible
+        @reactants = []
+        @products = []
+      end
+    end
+
+    class Model
+      attr_reader :species, :reactions
+      def initialize
+        @species = {}
+        @reactions = []
+      end
+    end
+
+    doc = Document.new(file)
+
+    model = Model.new
+
+    doc.elements.each("*/model/listOfSpecies/specie") do |s|
+      model.species[s.attribute("name").to_s] = Specie.new(s.attribute("name").to_s,
+                                                           s.attribute("compartment").to_s,
+                                                           s.attribute("boundaryCondition").to_s,
+                                                           s.attribute("initialAmount").to_s)
+    end
+
+    doc.elements.each("*/model/listOfReactions/reaction") do |r|
+      reaction = Reaction.new(r.attribute("name").to_s,
+                              r.attribute("").to_s == "false")
+      r.elements.each("listOfReactants/specieReference") do |r_sp|
+        reaction.reactants.push([model.species[r_sp.attribute("specie").to_s], r_sp.attribute("stoichiometry")])
+      end
+      r.elements.each("listOfProducts/specieReference") do |r_sp|
+        reaction.products.push([model.species[r_sp.attribute("specie").to_s], r_sp.attribute("stoichiometry")])
+      end
+      model.reactions.push(reaction)
+    end
+
+    def make_SPN(m, out)
+      out.puts "digraph SPN {"
+      tab = 3
+      m.species.keys.each do |k|
+        out.puts "%s \"%s\" [shape=circle];" % [" " * tab, k]
+      end
+      out.puts
+      m.reactions.each do |r|
+        out.puts "%s \"%s\" [shape=box]" % [" " * tab, r.name]
+        r.reactants.each do |r_sp|
+          out.puts "%s \"%s\" -> \"%s\" [label=\"%s\"];" % [" " * tab, r_sp[0].name, r.name, r_sp[1]]
+        end
+        out.puts
+        r.products.each do |r_sp|
+          out.puts "%s \"%s\" -> \"%s\"" % [" " * tab, r.name, r_sp[0].name]
+        end
+      end
+      out.puts "}"
+      out.close
+    end
+
+    make_SPN(model, open("test.dot", "w"))
+
+    system("dot -Tps test.dot >out.eps")
+  end
+end

data/lib/chem/db/smiles.rb

@@ -0,0 +1,2 @@
+
+require 'chem/db/smiles/smiparser'

data/lib/chem/db/smiles/smiles.ry

@@ -0,0 +1,203 @@
+#http://www.daylight.com/dayhtml/doc/theory/theory.smiles.html
+
+class SmilesParser
+rule
+      smiles :
+             | smiles smile EOL
+                 {
+                   return val[1]
+                 }
+       smile : node
+                 {
+                   result = val
+                 }
+             | smile node
+                 {
+                   result.push(val[1])
+                 }
+        node : atom_pos
+             | bond atom_pos
+                 {
+                   val[1].bond = val[0]
+                   result = val[1]
+                 }
+             | branch
+        atom : SYMBOL
+                 {
+                   node = Chem::SmilesAtom.new
+                   node.element = val[0][0]
+                   node.is_aromatic = val[0][1][:is_aromatic]
+                   result = node
+                 }
+             | ATOM_SYMBOL
+                 {
+                   m = /(\d*)([A-Za-z][a-z]?)(@*)(H\d*)?(\d*[+-]+)?/.match(val[0])
+#                   m = /(\d*)([A-Za-z][a-z]?)(@*)(H?\d*)(-?\d*)?/.match(val[0])
+                   node = Chem::SmilesAtom.new
+                   node.mass           = m[1].to_i
+                   node.element        = m[2].capitalize.intern
+                   node.is_aromatic    = (97 <= m[2][0]) #and 122 < $&[0]
+                   node.chiral         = m[3]
+
+                   if m[4] and not m[4] == ""
+                     hydrogen = /H(\d)+/.match(m[4])
+                     node.hydrogen_count = hydrogen ? hydrogen[1].to_i : 1
+                   end
+                   if m[5]
+                     charge = /(\d*)([+-]+)/.match(m[5])
+                     sign   = (charge[2][0..0] == "+") ? 1 : -1
+                     n      = charge[1] == "" ? charge[2].length : charge[1].to_i
+                     node.charge = sign * n
+                   end
+
+                   result              = node
+                 }
+    atom_pos : atom
+             | atom NUMBER # Ring 
+                 {
+                   val[0].smiles_pos = val[1].split("").collect{|c| c.to_i}
+                   result = val[0]
+                 }
+        bond : '-' # single bond
+             | '=' # double bond
+             | '#' # triple bond
+             | ':'
+             | '/'
+             | BSLASH
+             | '.' # zero bond
+      branch : '(' smile ')'
+                 { 
+                   result = val[1]
+                 }
+end
+
+
+#     atom : '[' <mass> symbol <chiral> <hcount> <sign<charge>> ']'
+#     bond :  <empty> | '-' | '=' | '#' | ':'
+#   branch : '(' <chain> ')'
+#          | '(' <chain> <branch> ')'
+#          | '(' <branch> <chain> ')'
+#          | '(' <chain> <branch> <chain> ')'
+#          ;
+
+---- inner
+
+def next_token
+  @q.shift
+end
+
+def construct mol, tree, prev = nil
+  tree.each do |node|
+    if node.instance_of?(Array)
+      construct(mol, node, prev)
+    else
+      mol.nodes.push(node)
+      mol.join(prev, node) if prev
+      #      if node.pos != nil
+      if node.smiles_pos
+        node.smiles_pos.each do |smiles_pos|
+          if @ring[smiles_pos]
+            mol.join(node, @ring[smiles_pos])
+            # re-use ring closure digits
+            # Higher-numbered ring closures are not supported yet.
+            @ring[smiles_pos] = nil
+          else
+            @ring[smiles_pos] = node
+          end
+        end
+      end
+      prev = node
+    end
+  end
+end
+
+def initialize
+  super
+  @ring = []
+end
+
+@@parser = SmilesParser.new
+
+def self.parse_smiles( smiles )
+  @@parser.parse( smiles )
+end
+
+ElementRegex = Regexp.new('\A(' + Chem::Number2Element.inject([]){|ret, el| ret.push(el.to_s)}.sort.reverse.join("|") + ')', Regexp::IGNORECASE)
+
+def parse( line )
+  @q = []
+  
+  line.strip!
+  until line.empty? do
+    case line
+    when /\A\[([^\]]+)\]/
+      # [nH] : aromatic N-H
+      @q.push [:ATOM_SYMBOL, $&] # [m[1], m[2], m[3], m[4], m[5], m[6]]]
+    when ElementRegex
+      prop = {}
+      prop[:is_aromatic] = (97 <= $&[0]) #and 122 < $&[0]
+      @q.push [:SYMBOL, [$&.capitalize.intern , prop]]
+    when /\A\d+/
+      @q.push [:NUMBER, $& ]
+    when /\\/
+      @q.push [:BSLASH, :BSLASH]
+    when /\A./
+      @q.push [$&, $&]
+    else
+      raise RuntimeError, 'must not happen'
+    end
+    line = $'
+  end
+  @q.push [ :EOL, nil ]
+#  p @q
+  mol = Chem::SmilesMol.new
+  construct(mol, do_parse)
+  mol
+end
+
+---- footer
+
+module Chem
+  
+  class SmilesAtom
+    include Atom
+    attr_accessor :bond, :element, :element, :chiral, :hydrogen_count, :charge, :smiles_pos, :is_aromatic
+    def inspect
+      "{%s %s(%s)}" % [@bond, @element, smiles_pos ? smiles_pos.join : ""]
+    end
+  end
+  
+  class SmilesBond
+    include Bond
+  end
+
+  class SmilesMol
+    
+    include Molecule
+    include Enumerable
+
+    attr_reader :nodes, :edges
+
+    def initialize
+      @nodes = []
+      @edges = []
+    end
+    
+    def join from, to
+      return if to.bond == '.'
+      bond = SmilesBond.new
+
+      case to.bond
+      when '='
+        bond.v = 2
+      when '#'
+        bond.v = 3
+      else
+        bond.v = 1
+      end
+      @edges.push([bond, from, to])
+    end
+
+  end
+
+end