lazar 0.0.1

data/README.md

@@ -0,0 +1,44 @@
+lazar
+=====
+
+Ruby libraries for the lazar framework
+
+Dependencies
+------------
+
+  lazar depends on a couple of external programs and libraries. On Debian 7 "Wheezy" systems you can install them with
+
+   `sudo apt-get install build-essential ruby ruby-dev git cmake swig r-base r-base-dev r-cran-rserve openjdk-7-jre libgsl0-dev libxml2-dev zlib1g-dev libcairo2-dev`
+  
+  You will also need at least mongodb version 3.0, but Debian "Wheezy" provides version 2.4. Please follow the instructions at http://docs.mongodb.org/manual/tutorial/install-mongodb-on-debian/:
+
+  ```
+  sudo apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10
+  echo "deb http://repo.mongodb.org/apt/debian wheezy/mongodb-org/3.0 main" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.0.list
+  sudo apt-get update
+  sudo apt-get install -y mongodb-org
+  ```
+
+Installation
+------------
+
+  `gem install lazar`
+
+  Please be patient, the compilation of OpenBabel and Fminer libraries can be very time consuming. If installation fails you can try to install manually:
+
+  ```
+  git clone https://github.com/opentox/lazar.git
+  cd lazar
+  ruby ext/lazar/extconf.rb
+  bundle install
+  ```
+
+  The output should give you more verbose information that can help in debugging (e.g. to identify missing libraries).
+
+Documentation
+-------------
+* [API documentation](http://rdoc.info/gems/lazar)
+
+Copyright
+---------
+Copyright (c) 2009-2015 Christoph Helma, Martin Guetlein, Micha Rautenberg, Andreas Maunz, David Vorgrimmler, Denis Gebele. See LICENSE for details.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/ext/lazar/extconf.rb

@@ -0,0 +1,87 @@
+require 'fileutils'
+require 'rbconfig'
+
+main_dir = File.expand_path(File.join(File.dirname(__FILE__),"..",".."))
+
+# install OpenBabel
+
+
+openbabel_version = "2.3.2"
+
+openbabel_dir = File.join main_dir, "openbabel"
+src_dir = openbabel_dir #File.join openbabel_dir, "openbabel-#{openbabel_version}"
+build_dir = File.join src_dir, "build"
+install_dir = openbabel_dir 
+install_lib_dir = File.join install_dir, "lib"
+lib_dir = File.join openbabel_dir, "lib", "openbabel"
+ruby_src_dir = File.join src_dir, "scripts", "ruby"
+
+begin
+  nr_processors = `grep processor /proc/cpuinfo | wc -l` # speed up compilation, Linux only
+rescue
+  nr_processors = 1
+end
+
+FileUtils.mkdir_p openbabel_dir
+Dir.chdir main_dir do
+  FileUtils.rm_rf src_dir
+  puts "Downloading OpenBabel sources"
+  system "git clone https://github.com/openbabel/openbabel.git"
+end
+
+FileUtils.mkdir_p build_dir
+FileUtils.mkdir_p install_dir
+Dir.chdir build_dir do
+  puts "Configuring OpenBabel"
+  cmake = "cmake #{src_dir} -DCMAKE_INSTALL_PREFIX=#{install_dir} -DBUILD_GUI=OFF -DENABLE_TESTS=OFF -DRUN_SWIG=ON -DRUBY_BINDINGS=ON"
+  # set rpath for local installations
+  # http://www.cmake.org/Wiki/CMake_RPATH_handling
+  # http://vtk.1045678.n5.nabble.com/How-to-force-cmake-not-to-remove-install-rpath-td5721193.html
+  cmake += " -DCMAKE_INSTALL_RPATH:STRING=\"#{install_lib_dir}\"" 
+  system cmake
+end
+
+# local installation in gem directory
+Dir.chdir build_dir do
+  puts "Compiling OpenBabel sources."
+  system "make -j#{nr_processors}"
+  system "make install"
+  ENV["PKG_CONFIG_PATH"] = File.dirname(File.expand_path(Dir["#{install_dir}/**/openbabel*pc"].first))
+end
+
+ob_include= File.expand_path File.join(File.dirname(__FILE__),"../../openbabel/include/openbabel-2.0")
+ob_lib= File.expand_path File.join(File.dirname(__FILE__),"../../openbabel/lib")
+
+# compile ruby bindings
+=begin
+puts "Compiling and installing OpenBabel Ruby bindings."
+Dir.chdir ruby_src_dir do
+  # fix rpath
+  system "sed -i 's|with_ldflags.*$|with_ldflags(\"#\$LDFLAGS -dynamic -Wl,-rpath,#{install_lib_dir}\") do|' #{File.join(ruby_src_dir,'extconf.rb')}"
+  system "#{RbConfig.ruby} extconf.rb --with-openbabel-include=#{ob_include} --with-openbabel-lib=#{ob_lib}"
+  system "make -j#{nr_processors}"
+end
+=end
+
+# install fminer
+fminer_dir = File.join main_dir, "libfminer"
+system "git clone git://github.com/amaunz/fminer2.git #{fminer_dir}"
+
+["libbbrc","liblast"].each do |lib|
+  FileUtils.cd File.join(fminer_dir,lib)
+  system "sed -i 's,^INCLUDE_OB.*,INCLUDE_OB\ =\ #{ob_include},g' Makefile" 
+  system "sed -i 's,^LDFLAGS_OB.*,LDFLAGS_OB\ =\ #{ob_lib},g' Makefile"
+  system "sed -i 's,^INCLUDE_RB.*,INCLUDE_RB\ =\ #{RbConfig::CONFIG['rubyhdrdir']},g' Makefile" 
+  # TODO fix in fminer Makefile
+  system "sed -i 's,-g, -g -I #{RbConfig::CONFIG['rubyhdrdir']} -I #{RbConfig::CONFIG['rubyarchhdrdir']} -I,' Makefile" # fix include path (CH)
+  system "sed -i '74s/$(CC)/$(CC) -Wl,-rpath,#{ob_lib.gsub('/','\/')} -L/' Makefile" # fix library path (CH)
+  system "make ruby"
+end
+
+# install last-utils
+FileUtils.cd main_dir
+system "git clone git://github.com/amaunz/last-utils.git"
+FileUtils.cd File.join(main_dir,"last-utils")
+`sed -i '8s/"openbabel", //' lu.rb`
+
+# install R packagemain_dir

data/java/CdkDescriptorInfo.java

@@ -0,0 +1,22 @@
+import java.util.*;
+import org.openscience.cdk.qsar.descriptors.molecular.*;
+import org.openscience.cdk.qsar.*;
+
+class CdkDescriptorInfo {
+  public static void main(String[] args) {
+
+    DescriptorEngine engine = new DescriptorEngine(DescriptorEngine.MOLECULAR);
+
+    for (Iterator<IDescriptor> it = engine.getDescriptorInstances().iterator(); it.hasNext(); ) {
+      IDescriptor descriptor = it.next();
+      String cdk_class = descriptor.getClass().toString().replaceAll("class ","");
+      System.out.println("- :java_class: \""+cdk_class+"\"");
+      String description = engine.getDictionaryDefinition(cdk_class).replaceAll("^\\s+", "" ).replaceAll("\\s+$", "").replaceAll("\\s+", " ");
+      System.out.println("  :description: \""+description+"\"");
+      System.out.println("  :names:");
+      for (String name : descriptor.getDescriptorNames()) {
+        System.out.println("    - \""+name+"\"");
+      }
+    }
+  }
+}

data/java/CdkDescriptors.java

@@ -0,0 +1,141 @@
+import java.util.*;
+import java.io.*;
+import org.openscience.cdk.DefaultChemObjectBuilder;
+import org.openscience.cdk.interfaces.IMolecule;
+import org.openscience.cdk.io.iterator.IteratingMDLReader;
+import org.openscience.cdk.qsar.*;
+import org.openscience.cdk.qsar.DescriptorValue;
+import org.openscience.cdk.aromaticity.CDKHueckelAromaticityDetector;
+import org.openscience.cdk.tools.manipulator.AtomContainerManipulator;
+import org.openscience.cdk.exception.NoSuchAtomTypeException;
+
+class CdkDescriptors {
+  public static void main(String[] args) {
+
+    if (args==null || args.length<2) {
+	System.err.println("required params: <sd-file> <descriptor1> <descriptor2(optional)> <descriptor3(optional)> ...");
+	System.exit(1);
+    }
+    if (! new File(args[0]).exists()){
+	System.err.println("file not found "+args[0]);
+	System.exit(1);
+    }
+
+    // command line descriptor params can be either "descriptorName" or "descriptorValueName"
+    // terminology:
+    // A descriptor can calculate serveral values, e.g., ALOGP produces ALOGP.ALogP, ALOGP.ALogp2, ALOGP.AMR
+    // "descriptorName" ALOGP
+    // "valueName" AMR
+    // "descriptorValueName" ALOGP.AMR
+    DescriptorEngine engine;
+    Set<String> classNames = new LinkedHashSet<String>(); // descriptors to be computed
+    Set<String> descriptorNames = new LinkedHashSet<String>(); // all values of this descriptor will be printed
+    Set<String> descriptorValueNames = new LinkedHashSet<String>(); // only these values of a descriptor will be printed
+    for (int i =1; i < args.length; i++) {
+      String descriptorName;
+      if (args[i].indexOf(".")!=-1) {
+          descriptorValueNames.add(args[i]);
+	  descriptorName = args[i].substring(0,args[i].indexOf("."));
+      }
+      else {
+	  descriptorNames.add(args[i]);
+          descriptorName = args[i];
+      }
+      classNames.add(getDescriptorClassName(descriptorName));
+    }
+
+    engine = new DescriptorEngine(new ArrayList<String>(classNames));
+    List<IDescriptor> instances =  engine.instantiateDescriptors(new ArrayList<String>(classNames));
+    List<DescriptorSpecification> specs = engine.initializeSpecifications(instances);
+    engine.setDescriptorInstances(instances);
+    engine.setDescriptorSpecifications(specs);
+
+    try {
+      BufferedReader br = new BufferedReader(new FileReader(args[0]));
+      PrintWriter yaml = new PrintWriter(new FileWriter(args[0]+"cdk.yaml"));
+      // parse 3d sdf from file and calculate descriptors
+      IteratingMDLReader reader = new IteratingMDLReader( br, DefaultChemObjectBuilder.getInstance());
+      int c = 0;
+      while (reader.hasNext()) {
+        try {
+          System.out.println("computing "+(args.length-1)+" descriptors for compound "+(++c));
+          IMolecule molecule = (IMolecule)reader.next();
+          molecule = (IMolecule) AtomContainerManipulator.removeHydrogens(molecule);
+          try {
+            AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(molecule);
+          }
+	      catch (NoSuchAtomTypeException e) {
+            e.printStackTrace();
+          }
+          CDKHueckelAromaticityDetector.detectAromaticity(molecule);
+
+          engine.process(molecule);
+          Map<Object,Object> properties = molecule.getProperties();
+          Boolean first = true;
+          for (Map.Entry<Object, Object> entry : properties.entrySet()) {
+            try {
+              if ((entry.getKey() instanceof DescriptorSpecification) && (entry.getValue() instanceof DescriptorValue)) {
+                DescriptorSpecification property = (DescriptorSpecification)entry.getKey();
+                DescriptorValue value = (DescriptorValue)entry.getValue();
+                String[] values = value.getValue().toString().split(",");
+                for (int i = 0; i < values.length; i++) {
+                  String cdk_class = property.getImplementationTitle();
+                  String descriptorName = cdk_class.substring(cdk_class.lastIndexOf(".")+1).replace("Descriptor","");
+                  String descriptorValueName = descriptorName + "." + value.getNames()[i];
+		  if (descriptorNames.contains(descriptorName) || descriptorValueNames.contains(descriptorValueName)) {
+		      if (first) { yaml.print("- "); first = false; }
+		      else { yaml.print("  "); }
+                      yaml.println("Cdk." + descriptorValueName  + ": " + values[i]);
+		  }
+                }
+              }
+            }
+            catch (ClassCastException e) { } // sdf properties are stored as molecules properties (strings), ignore them
+            catch (Exception e) { e.printStackTrace(); } // output nothing to yaml
+          }
+        }
+        catch (Exception e) {
+          yaml.println("- {}");
+          e.printStackTrace();
+          continue;
+        }
+      }
+      yaml.close();
+    }
+    catch (Exception e) { e.printStackTrace(); }
+  }
+    
+
+    /** HACK to find the class for a descriptor
+     * problem: Descriptor is not always at the end of the class (APolDescriptor), but may be in the middle (AutocorrelationDescriptorPolarizability)
+     * this method makes a class-lookup using trial and error */
+    static String getDescriptorClassName(String descriptorName) {
+	String split = splitCamelCase(descriptorName)+" "; // space mark possible positions for 'Descriptor'
+	for(int i = split.length()-1; i>0; i--) {
+	    if (split.charAt(i)==' ') { // iterate over all spaces, starting with the trailing one
+		String test = split.substring(0,i)+"Descriptor"+split.substring(i+1,split.length()); // replace current space with 'Descriptor' ..
+		test = test.replaceAll("\\s",""); // .. and remove other spaces
+		String className = "org.openscience.cdk.qsar.descriptors.molecular." + test;
+		try {
+		    Class.forName(className);
+		    return className;
+		} catch (ClassNotFoundException e) {}
+	    }
+        }
+	System.err.println("Descriptor not found: "+descriptorName);
+	System.exit(1);
+	return null;
+    }
+
+    /** inserts space in between camel words */
+  static String splitCamelCase(String s) {
+   return s.replaceAll(
+      String.format("%s|%s|%s",
+         "(?<=[A-Z])(?=[A-Z][a-z])",
+         "(?<=[^A-Z])(?=[A-Z])",
+         "(?<=[A-Za-z])(?=[^A-Za-z])"
+      ),
+      " "
+   );
+  }
+}

data/java/JoelibDescriptorInfo.java

@@ -0,0 +1,15 @@
+import joelib2.feature.FeatureHelper;
+
+class JoelibDescriptorInfo {
+  public static void main(String[] args) {
+    FeatureHelper helper = FeatureHelper.instance();
+    System.out.println("---"); // document separator for Joelib debug messages
+    for (Object feature : helper.getNativeFeatures() ) {
+      System.out.println("- :java_class: \""+feature.toString()+"\"");
+      // methods for accessing feature descriptions e.g. with 
+      // FeatureFactory.instance().getFeature(feature.toString()).getDescription().getText() or
+      // FeatureFactory.instance().getFeature(feature.toString()).getDescription().getHtml()
+      // are defunct
+    }
+  }
+}

data/java/JoelibDescriptors.java

@@ -0,0 +1,60 @@
+import java.util.*;
+import java.io.*;
+import joelib2.feature.Feature;
+import joelib2.feature.FeatureHelper;
+import joelib2.feature.FeatureFactory;
+import joelib2.feature.FeatureResult;
+import joelib2.io.BasicIOType;
+import joelib2.io.BasicIOTypeHolder;
+import joelib2.io.BasicReader;
+import joelib2.io.MoleculeFileHelper;
+import joelib2.io.MoleculeFileIO;
+import joelib2.io.MoleculeIOException;
+import joelib2.molecule.BasicConformerMolecule;
+
+class JoelibDescriptors {
+  public static void main(String[] args) {
+
+    String[] features = null;
+    features = new String[args.length-1];
+    System.arraycopy(args,1,features,0,args.length-1);
+
+    FeatureFactory factory = FeatureFactory.instance();
+    MoleculeFileIO loader = null;
+    String line = new String();
+    String sdf = new String();
+    try {
+      // parse 3d sdf from file and calculate descriptors
+      InputStream is = new FileInputStream(args[0]);
+      PrintWriter yaml = new PrintWriter(new FileWriter(args[0]+"joelib.yaml"));
+      BasicIOType inType = BasicIOTypeHolder.instance().getIOType("SDF");
+      loader = MoleculeFileHelper.getMolReader(is, inType);
+      BasicConformerMolecule mol = new BasicConformerMolecule(inType, inType);
+      while (true) {
+        try {
+          Boolean success = loader.read(mol);
+          if (!success) { break; } // last molecule
+          for (int i =0; i < features.length; i++) {
+            String name = "joelib2.feature.types." + features[i];
+            Feature feature = factory.getFeature(name);
+            FeatureResult result = feature.calculate(mol);
+            if (i == 0) { yaml.print("- "); }
+            else { yaml.print("  "); }
+            yaml.print( "Joelib."+features[i]+": " );
+            yaml.println( result.toString() );
+          }
+
+        }
+        catch (Exception e) { 
+          System.err.println(e.toString());
+          e.printStackTrace();
+        }
+      }
+      yaml.close();
+    }
+    catch (Exception e) {
+      System.err.println(e.toString());
+      e.printStackTrace();
+    }
+  }
+}

data/java/Rakefile

@@ -0,0 +1,15 @@
+# Java class, classpath
+java_classes = [
+  ["CdkDescriptors", "cdk-1.4.19.jar"],
+  ["CdkDescriptorInfo", "cdk-1.4.19.jar"],
+  ["JoelibDescriptors", "joelib2.jar:."],
+  ["JoelibDescriptorInfo", "joelib2.jar:."],
+]
+  
+task :default => java_classes.collect{|c| "#{c.first}.class"}
+
+java_classes.each do |c|
+  file "#{c.first}.class" => "#{c.first}.java" do
+    puts `javac -classpath #{c.last} #{c.first}.java`
+  end
+end

data/lazar.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "lazar"
+  s.version     = File.read("./VERSION").strip
+  s.authors     = ["Christoph Helma, Martin Guetlein, Andreas Maunz, Micha Rautenberg, David Vorgrimmler, Denis Gebele"]
+  s.email       = ["helma@in-silico.ch"]
+  s.homepage    = "http://github.com/opentox/lazar"
+  s.summary     = %q{Lazar framework}
+  s.description = %q{Libraries for lazy structure-activity relationships and read-across.}
+  s.license     = 'GPL-3'
+
+  s.rubyforge_project = "lazar"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.extensions    = %w[ext/lazar/extconf.rb]
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_runtime_dependency "bundler"
+  s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency 'nokogiri'
+  #s.add_runtime_dependency "openbabel"
+  s.add_runtime_dependency 'rserve-client'
+  s.add_runtime_dependency "mongoid", '~> 5.0beta'  
+
+end