sdf-parser 5.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 cheminfo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,104 @@
+# sdf-parser
+
+[![NPM version][npm-image]][npm-url]
+[![build status][travis-image]][travis-url]
+[![npm download][download-image]][download-url]
+
+Allow to parse a SDF file and convert it to an array of objects.
+
+## Use of the package
+
+```bash
+npm install sdf-parser
+```
+
+In node script:
+
+```js
+// allows to parse a file test.sdf that would be present in the same directory
+
+var { parse } = require('sdf-parser');
+
+var fs = require('fs');
+var sdf = fs.readFileSync('./test.sdf', 'utf-8');
+
+var result = parse(sdf);
+console.log(result);
+```
+
+## require('sdf-parser') (sdf, options)
+
+options:
+
+- exclude : array of string containing the fields to discard
+- include : array of string containing the fields to keep
+- modifiers : object of functions that need to be converted during the parsing
+- filter : function that allows to filter the result
+- mixedEOL : if set to true will try to deal with mixed End Of Line separator
+- dynamicTyping : convert fields containing only number to numbers (default: true)
+
+## Advanced example with filtering and modifiers
+
+```js
+var result = parse(sdf, {
+  exclude: ['Number of H-Donors'],
+  include: ['Number of H-Donors', 'CLogP', 'Code'],
+  modifiers: {
+    CLogP: function (field) {
+      return {
+        low: field * 1 - 0.2,
+        high: field * 1 + 0.2,
+      };
+    },
+  },
+  filter: (entry) => {
+    return entry.CLogP && entry.CLogP.low > 4;
+  },
+});
+```
+
+## Streams
+
+This API is only available on Node.js.
+
+### molecules(options)
+
+Transform an input text stream to a stream of molecule objects.
+
+#### options
+
+- `fullResult`: true to emit the full result of `parse` instead of just the molecules.
+- All other options from the `parse` function.
+
+```js
+const { stream } = require('sdf-parser');
+fs.createReadStream('test.sdf')
+  .pipe(stream.molecules())
+  .on('data', (molecule) => {
+    console.log(molecule.molfile);
+  });
+```
+
+### entries()
+
+Transform an input text stream to a stream of sdf entries.
+
+```js
+const { stream } = require('sdf-parser');
+fs.createReadStream('test.sdf')
+  .pipe(stream.entries())
+  .on('data', (entry) => {
+    // sdf entry as a string
+  });
+```
+
+## License
+
+[MIT](./LICENSE)
+
+[npm-image]: https://img.shields.io/npm/v/sdf-parser.svg?style=flat-square
+[npm-url]: https://www.npmjs.com/package/sdf-parser
+[travis-image]: https://img.shields.io/travis/cheminfo/sdf-parser/master.svg?style=flat-square
+[travis-url]: https://travis-ci.org/cheminfo/sdf-parser
+[download-image]: https://img.shields.io/npm/dm/sdf-parser.svg?style=flat-square
+[download-url]: https://www.npmjs.com/package/sdf-parser

package/lib/index.js

@@ -0,0 +1,221 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var pipeline = require('pumpify');
+var split2 = require('split2');
+var through2 = require('through2');
+var filter = require('through2-filter');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var pipeline__default = /*#__PURE__*/_interopDefaultLegacy(pipeline);
+var split2__default = /*#__PURE__*/_interopDefaultLegacy(split2);
+var through2__default = /*#__PURE__*/_interopDefaultLegacy(through2);
+var filter__default = /*#__PURE__*/_interopDefaultLegacy(filter);
+
+function getEntriesBoundaries(string, substring, eol) {
+  const res = [];
+  let previous = 0;
+  let next = 0;
+  while (next !== -1) {
+    next = string.indexOf(substring, previous);
+    if (next !== -1) {
+      res.push([previous, next]);
+      previous = next =
+        string.indexOf(eol, next + substring.length) + eol.length;
+    } else {
+      res.push([previous, string.length]);
+    }
+  }
+  return res;
+}
+
+function parse(sdf, options = {}) {
+  const {
+    include,
+    exclude,
+    filter,
+    modifiers = {},
+    forEach = {},
+    dynamicTyping = true,
+  } = options;
+
+  if (typeof sdf !== 'string') {
+    throw new TypeError('Parameter "sdf" must be a string');
+  }
+
+  let eol = '\n';
+  if (options.mixedEOL) {
+    sdf = sdf.replace(/\r\n/g, '\n');
+    sdf = sdf.replace(/\r/g, '\n');
+  } else {
+    // we will find the delimiter in order to be much faster and not use regular expression
+    let header = sdf.substr(0, 1000);
+    if (header.indexOf('\r\n') > -1) {
+      eol = '\r\n';
+    } else if (header.indexOf('\r') > -1) {
+      eol = '\r';
+    }
+  }
+
+  let entriesBoundaries = getEntriesBoundaries(sdf, `${eol}$$$$`, eol);
+  let molecules = [];
+  let labels = {};
+
+  let start = Date.now();
+
+  for (let i = 0; i < entriesBoundaries.length; i++) {
+    let sdfPart = sdf.substring(...entriesBoundaries[i]);
+    let parts = sdfPart.split(`${eol}>`);
+    if (parts.length > 0 && parts[0].length > 5) {
+      let molecule = {};
+      let currentLabels = [];
+      molecule.molfile = parts[0] + eol;
+      for (let j = 1; j < parts.length; j++) {
+        let lines = parts[j].split(eol);
+        let from = lines[0].indexOf('<');
+        let to = lines[0].indexOf('>');
+        let label = lines[0].substring(from + 1, to);
+        currentLabels.push(label);
+        if (!labels[label]) {
+          labels[label] = {
+            counter: 0,
+            isNumeric: dynamicTyping,
+            keep: false,
+          };
+          if (
+            (!exclude || exclude.indexOf(label) === -1) &&
+            (!include || include.indexOf(label) > -1)
+          ) {
+            labels[label].keep = true;
+            if (modifiers[label]) {
+              labels[label].modifier = modifiers[label];
+            }
+            if (forEach[label]) {
+              labels[label].forEach = forEach[label];
+            }
+          }
+        }
+        if (labels[label].keep) {
+          for (let k = 1; k < lines.length - 1; k++) {
+            if (molecule[label]) {
+              molecule[label] += eol + lines[k];
+            } else {
+              molecule[label] = lines[k];
+            }
+          }
+          if (labels[label].modifier) {
+            let modifiedValue = labels[label].modifier(molecule[label]);
+            if (modifiedValue === undefined || modifiedValue === null) {
+              delete molecule[label];
+            } else {
+              molecule[label] = modifiedValue;
+            }
+          }
+          if (labels[label].isNumeric) {
+            if (
+              !isFinite(molecule[label]) ||
+              molecule[label].match(/^0[0-9]/)
+            ) {
+              labels[label].isNumeric = false;
+            }
+          }
+        }
+      }
+      if (!filter || filter(molecule)) {
+        molecules.push(molecule);
+        // only now we can increase the counter
+        for (let j = 0; j < currentLabels.length; j++) {
+          labels[currentLabels[j]].counter++;
+        }
+      }
+    }
+  }
+
+  // all numeric fields should be converted to numbers
+  for (let label in labels) {
+    let currentLabel = labels[label];
+    if (currentLabel.isNumeric) {
+      currentLabel.minValue = Infinity;
+      currentLabel.maxValue = -Infinity;
+      for (let j = 0; j < molecules.length; j++) {
+        if (molecules[j][label]) {
+          let value = parseFloat(molecules[j][label]);
+          molecules[j][label] = value;
+          if (value > currentLabel.maxValue) {
+            currentLabel.maxValue = value;
+          }
+          if (value < currentLabel.minValue) {
+            currentLabel.minValue = value;
+          }
+        }
+      }
+    }
+  }
+
+  // we check that a label is in all the records
+  for (let key in labels) {
+    if (labels[key].counter === molecules.length) {
+      labels[key].always = true;
+    } else {
+      labels[key].always = false;
+    }
+  }
+
+  let statistics = [];
+  for (let key in labels) {
+    let statistic = labels[key];
+    statistic.label = key;
+    statistics.push(statistic);
+  }
+
+  return {
+    time: Date.now() - start,
+    molecules: molecules,
+    labels: Object.keys(labels),
+    statistics: statistics,
+  };
+}
+
+const filterStream = filter__default["default"].bind(null, { objectMode: true });
+function filterCb(chunk) {
+  return chunk.length > 1 && chunk.trim().length > 1;
+}
+
+function entries() {
+  return pipeline__default["default"].obj(
+    split2__default["default"](/\r?\n\${4}.*\r?\n/),
+    filterStream(filterCb),
+    through2__default["default"]({ objectMode: true }, function process(value, encoding, callback) {
+      const eol = value.includes('\r\n') ? '\r\n' : '\n';
+      this.push(`${value + eol}$$$$${eol}`);
+      callback();
+    }),
+  );
+}
+
+function molecules(options) {
+  return pipeline__default["default"].obj(
+    entries(),
+    through2__default["default"]({ objectMode: true }, function process(value, encoding, callback) {
+      try {
+        const parsed = parse(value, options);
+        if (parsed.molecules.length === 1) {
+          if (options && options.fullResult) {
+            this.push(parsed);
+          } else {
+            this.push(parsed.molecules[0]);
+          }
+        }
+        callback();
+      } catch (e) {
+        callback(e);
+      }
+    }),
+  );
+}
+
+exports.entries = entries;
+exports.molecules = molecules;
+exports.parse = parse;

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "sdf-parser",
+  "version": "5.0.0",
+  "description": "SDF parser",
+  "main": "lib/index.js",
+  "module": "src/index.js",
+  "files": [
+    "lib",
+    "src"
+  ],
+  "scripts": {
+    "build": "npm run compile && cheminfo-build --root SDFParser",
+    "compile": "rollup -c",
+    "eslint": "eslint src",
+    "eslint-fix": "npm run eslint -- --fix",
+    "prepack": "npm run compile",
+    "prettier": "prettier --check src",
+    "prettier-write": "prettier --write src",
+    "test": "npm run test-coverage && npm run eslint",
+    "test-coverage": "jest --coverage",
+    "test-only": "jest"
+  },
+  "browser": {
+    "./src/stream.js": "./src/stream.browser.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cheminfo/sdf-parser.git"
+  },
+  "keywords": [
+    "sdf",
+    "parser",
+    "molfile",
+    "v2000",
+    "v3000",
+    "mdl"
+  ],
+  "author": "Luc Patiny",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/cheminfo/sdf-parser/issues"
+  },
+  "homepage": "https://github.com/cheminfo/sdf-parser",
+  "devDependencies": {
+    "@babel/plugin-transform-modules-commonjs": "^7.15.4",
+    "babel-eslint": "^10.1.0",
+    "callback-stream": "^1.1.0",
+    "cheminfo-build": "^1.1.11",
+    "eslint": "^7.32.0",
+    "eslint-config-cheminfo": "^6.0.1",
+    "jest": "^27.2.5",
+    "openchemlib": "^7.4.3",
+    "prettier": "^2.4.1"
+  },
+  "dependencies": {
+    "pumpify": "^2.0.1",
+    "split2": "^3.2.2",
+    "through2": "^4.0.2",
+    "through2-filter": "^3.0.0"
+  }
+}

package/src/__tests__/checkOptions.test.js

@@ -0,0 +1,57 @@
+import fs from 'fs';
+
+import { parse } from '..';
+
+let sdf = fs.readFileSync(`${__dirname}/test.sdf`, 'utf-8');
+
+describe('SDF Parser options', () => {
+  let result = parse(sdf, {
+    exclude: ['Number of H-Donors'],
+    include: ['Number of H-Donors', 'CLogP', 'Code'],
+    modifiers: {
+      CLogP: (field) => {
+        return {
+          low: field * 1 - 0.2,
+          high: field * 1 + 0.2,
+        };
+      },
+    },
+    filter: (entry) => {
+      return entry.CLogP && entry.CLogP.low > 4;
+    },
+  });
+
+  it('Check statistics', () => {
+    expect(result.statistics[0].counter).toBe(43);
+    expect(result.statistics[0].isNumeric).toBe(false);
+    expect(result.statistics[0].label).toBe('Code');
+    expect(result.statistics[0].always).toBe(true);
+    expect(result.statistics[4].counter).toBe(43);
+    expect(result.statistics[4].isNumeric).toBe(false);
+    expect(result.statistics[4].label).toBe('CLogP');
+    expect(result.statistics[4].always).toBe(true);
+  });
+
+  it('Check molecules', () => {
+    expect(result.molecules).toHaveLength(43);
+    let molecule = result.molecules[0];
+
+    expect(Object.keys(molecule)).toHaveLength(3);
+    expect(molecule.Code).toBe('0100380851');
+    expect(molecule.CLogP.low).toBeCloseTo(4.8, 0.0001);
+    expect(molecule.CLogP.high).toBeCloseTo(5.2, 0.0001);
+    expect(molecule.molfile.split('\n')).toHaveLength(56);
+  });
+
+  it('should throw with non-string argument', () => {
+    expect(() => {
+      parse();
+    }).toThrow(TypeError);
+    expect(() => {
+      parse(42);
+    }).toThrow(TypeError);
+    expect(() => {
+      parse({});
+    }).toThrow(TypeError);
+  });
+});

package/src/__tests__/checkUndefined.test.js

@@ -0,0 +1,24 @@
+import fs from 'fs';
+
+import { parse } from '..';
+
+let sdf = fs.readFileSync(`${__dirname}/test.sdf`, 'utf-8');
+
+describe('SDF Parser options and undefined', () => {
+  let result = parse(sdf, {
+    exclude: ['Number of H-Donors'],
+    include: ['Number of H-Donors', 'CLogP', 'Code'],
+    modifiers: {
+      CLogP: () => {
+        return undefined;
+      },
+    },
+    filter: (entry) => {
+      return entry.CLogP && entry.CLogP.low > 4;
+    },
+  });
+
+  it('Check molecules', () => {
+    expect(result.molecules).toHaveLength(0);
+  });
+});

package/src/__tests__/getEntriesBoundaries.test.js

@@ -0,0 +1,26 @@
+import fs from 'fs';
+
+import { getEntriesBoundaries } from '../getEntriesBoundaries';
+
+let sdf0 = fs.readFileSync(`${__dirname}/test.sdf`, 'utf-8');
+let sdf1 = fs.readFileSync(`${__dirname}/test1.sdf`, 'utf-8');
+let sdf2 = fs.readFileSync(`${__dirname}/test2.sdf`, 'utf-8');
+
+[sdf0, sdf1, sdf2].forEach((sdf) => {
+  let eol = '\n';
+  let header = sdf.substr(0, 1000);
+  if (header.indexOf('\r\n') > -1) {
+    eol = '\r\n';
+  } else if (header.indexOf('\r') > -1) {
+    eol = '\r';
+  }
+
+  test('Split should match regex behavior', () => {
+    let sdfParts = sdf.split(new RegExp(`${eol}\\$\\$\\$\\$.*${eol}`));
+    expect(sdfParts).toStrictEqual(
+      getEntriesBoundaries(sdf, `${eol}$$$$`, eol).map((v) =>
+        sdf.substring(...v),
+      ),
+    );
+  });
+});

package/src/__tests__/index.test.js

@@ -0,0 +1,76 @@
+import fs from 'fs';
+
+import { parse } from '..';
+
+let sdf = fs.readFileSync(`${__dirname}/test.sdf`, 'utf-8');
+let sdf1 = fs.readFileSync(`${__dirname}/test1.sdf`, 'utf-8');
+
+describe('SDF Parser', () => {
+  let result = parse(sdf);
+
+  it('Check statistics', () => {
+    expect(result.statistics[0].counter).toBe(128);
+    expect(result.statistics[0].isNumeric).toBe(false);
+    expect(result.statistics[0].label).toBe('Code');
+    expect(result.statistics[1].counter).toBe(128);
+    expect(result.statistics[1].minValue).toBe(0);
+    expect(result.statistics[1].maxValue).toBe(5);
+    expect(result.statistics[1].isNumeric).toBe(true);
+    expect(result.statistics[1].label).toBe('Number of H-Donors');
+    expect(result.statistics[0].always).toBe(true);
+    expect(result.statistics[4].always).toBe(false);
+  });
+
+  it('Check molecules', () => {
+    let molecule = result.molecules[0];
+    expect(molecule.Code).toContain('0100380824');
+    expect(molecule.CLogP).toBe(2.7);
+    expect(molecule.molfile.split('\n')).toHaveLength(37);
+  });
+
+  it('should throw with non-string argument', () => {
+    expect(() => {
+      parse();
+    }).toThrow(TypeError);
+    expect(() => {
+      parse(42);
+    }).toThrow(TypeError);
+    expect(() => {
+      parse({});
+    }).toThrow(TypeError);
+  });
+});
+
+describe('SDF Parser no dynamicTyping', () => {
+  let result = parse(sdf, {
+    dynamicTyping: false,
+  });
+
+  it('Check statistics', () => {
+    expect(result.statistics[0].counter).toBe(128);
+    expect(result.statistics[0].isNumeric).toBe(false);
+    expect(result.statistics[0].label).toBe('Code');
+    expect(result.statistics[1].counter).toBe(128);
+    expect(result.statistics[1].minValue).toBeUndefined();
+    expect(result.statistics[1].maxValue).toBeUndefined();
+    expect(result.statistics[1].isNumeric).toBe(false);
+    expect(result.statistics[1].label).toBe('Number of H-Donors');
+    expect(result.statistics[0].always).toBe(true);
+    expect(result.statistics[4].always).toBe(false);
+  });
+
+  it('Check molecules', () => {
+    let molecule = result.molecules[0];
+    expect(typeof molecule.Code).toBe('string');
+    expect(typeof molecule.CLogP).toBe('string');
+    expect(molecule.CLogP).toBe('2.700000000000000e+000');
+    expect(molecule.molfile.split('\n')).toHaveLength(37);
+  });
+});
+
+describe('SDF Parser one molecule', () => {
+  let result = parse(sdf1);
+  it('Check statistics', () => {
+    expect(result.molecules).toHaveLength(1);
+  });
+});

package/src/__tests__/notWellFormatted.test.js

@@ -0,0 +1,14 @@
+import fs from 'fs';
+
+import { parse } from '..';
+
+describe('SDF Parser of non well formatted file', () => {
+  let sdf = fs.readFileSync(`${__dirname}/test2.sdf`, 'utf-8');
+  sdf = sdf.replace(/\r/g, '');
+  let result = parse(sdf, { mixedEOL: true });
+
+  it('Check molecules', () => {
+    let molecules = result.molecules;
+    expect(molecules).toHaveLength(7);
+  });
+});