sdf-parser 4.0.1 → 5.0.1

package/README.md

@@ -17,7 +17,7 @@ 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 { parse } = require('sdf-parser');
 
 var fs = require('fs');
 var sdf = fs.readFileSync('./test.sdf', 'utf-8');
@@ -44,16 +44,16 @@ var result = parse(sdf, {
   exclude: ['Number of H-Donors'],
   include: ['Number of H-Donors', 'CLogP', 'Code'],
   modifiers: {
-    CLogP: function(field) {
+    CLogP: function (field) {
       return {
         low: field * 1 - 0.2,
-        high: field * 1 + 0.2
+        high: field * 1 + 0.2,
       };
-    }
+    },
   },
-  filter: function(entry) {
+  filter: (entry) => {
     return entry.CLogP && entry.CLogP.low > 4;
-  }
+  },
 });
 ```
 
@@ -98,7 +98,7 @@ fs.createReadStream('test.sdf')
 
 [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-js/sdf-parser/master.svg?style=flat-square
-[travis-url]: https://travis-ci.org/cheminfo-js/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,234 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ensureString = require('ensure-string');
+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;
+}
+
+/**
+ *  Parse a SDF file
+ * @param {string|ArrayBuffer|Uint8Array} sdf SDF file to parse
+ * @param {any} [options={}]
+ * @param {array<string>} [options.include] List of fields to include
+ * @param {array<string>} [options.exclude] List of fields to exclude
+ * @param {boolean} [options.dynamicTyping] Dynamically type the data
+ * @param {object} [options.modifiers] Object containing callbacks to apply on some specific fields
+ * @param {boolean} [options.mixedEOL=false] Set to true if you know there is a mixture between \r\n and \n
+ */
+function parse(sdf, options = {}) {
+  const {
+    include,
+    exclude,
+    filter,
+    modifiers = {},
+    forEach = {},
+    dynamicTyping = true,
+  } = options;
+
+  sdf = ensureString.ensureString(sdf);
+  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

@@ -1,14 +1,22 @@
 {
   "name": "sdf-parser",
-  "version": "4.0.1",
+  "version": "5.0.1",
   "description": "SDF parser",
-  "main": "./src/index.js",
+  "main": "lib/index.js",
+  "module": "src/index.js",
   "files": [
+    "lib",
     "src"
   ],
+  "sideEffects": false,
   "scripts": {
-    "eslint": "eslint src __tests__",
+    "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"
@@ -18,35 +26,38 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/cheminfo-js/sdf-parser.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-js/sdf-parser/issues"
+    "url": "https://github.com/cheminfo/sdf-parser/issues"
   },
-  "homepage": "https://github.com/cheminfo-js/sdf-parser",
+  "homepage": "https://github.com/cheminfo/sdf-parser",
   "devDependencies": {
-    "babel-eslint": "^10.0.1",
+    "@babel/plugin-transform-modules-commonjs": "^7.16.8",
+    "babel-eslint": "^10.1.0",
     "callback-stream": "^1.1.0",
-    "eslint": "^5.16.0",
-    "eslint-config-cheminfo": "^1.20.1",
-    "eslint-plugin-import": "^2.17.3",
-    "eslint-plugin-jest": "^22.6.4",
-    "jest": "^24.8.0",
-    "openchemlib": "^7.1.0"
+    "cheminfo-build": "^1.1.11",
+    "eslint": "^8.10.0",
+    "eslint-config-cheminfo": "^7.3.0",
+    "jest": "^27.5.1",
+    "openchemlib": "^7.4.3",
+    "prettier": "^2.5.1"
   },
   "dependencies": {
-    "pumpify": "^2.0.0",
-    "split2": "^3.1.1",
-    "through2": "^3.0.1",
+    "ensure-string": "^1.1.0",
+    "pumpify": "^2.0.1",
+    "split2": "^4.1.0",
+    "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);
+  });
+});

package/src/__tests__/stream.test.js

@@ -0,0 +1,98 @@
+import fs from 'fs';
+
+import callbackStream from 'callback-stream';
+import OCL from 'openchemlib/minimal';
+
+import { entries, molecules } from '..';
+
+const cbStream = callbackStream.bind(null, { objectMode: true });
+
+describe('stream', () => {
+  it('entries', () =>
+    new Promise((resolve) => {
+      fs.createReadStream(`${__dirname}/test.sdf`)
+        .pipe(entries())
+        .pipe(
+          cbStream((err, data) => {
+            expect(err).toBeNull();
+            expect(data).toHaveLength(128);
+            expect(data[0]).toContain('-ISIS-  04231216572D');
+            const mol = OCL.Molecule.fromMolfile(data[5]);
+            expect(mol.toMolfile()).toContain(
+              '17 18  0  0  0  0  0  0  0  0999 V2000',
+            );
+            resolve();
+          }),
+        );
+    }));
+
+  it('molecules', () =>
+    new Promise((resolve) => {
+      fs.createReadStream(`${__dirname}/test.sdf`)
+        .pipe(molecules())
+        .pipe(
+          cbStream((err, data) => {
+            expect(err).toBeNull();
+            expect(data).toHaveLength(128);
+            expect(data[0]).toMatchObject({
+              Code: '0100380824',
+              CLogP: 2.7,
+            });
+            expect(data[0].molfile).toContain('-ISIS-  04231216572D');
+            resolve();
+          }),
+        );
+    }));
+
+  it('molecules - full result', () =>
+    new Promise((resolve) => {
+      fs.createReadStream(`${__dirname}/test.sdf`)
+        .pipe(molecules({ fullResult: true }))
+        .pipe(
+          cbStream((err, data) => {
+            expect(err).toBeNull();
+            expect(data).toHaveLength(128);
+            expect(data[0]).toMatchObject({
+              labels: [
+                'Code',
+                'Number of H-Donors',
+                'Number of H-Acceptors',
+                'Number of Rotatable bonds',
+                'CLogP',
+              ],
+            });
+            expect(data[0].molecules).toHaveLength(1);
+            resolve();
+          }),
+        );
+    }));
+
+  it('molecules with filter', () =>
+    new Promise((resolve) => {
+      fs.createReadStream(`${__dirname}/test.sdf`)
+        .pipe(
+          molecules({
+            filter: (entry) => entry.Code === '0100380869',
+          }),
+        )
+        .pipe(
+          cbStream((err, data) => {
+            expect(err).toBeNull();
+            expect(data).toHaveLength(1);
+            resolve();
+          }),
+        );
+    }));
+
+  it('async iteration', async () => {
+    const stream = fs
+      .createReadStream(`${__dirname}/test.sdf`)
+      .pipe(molecules());
+    let count = 0;
+    for await (const molecule of stream) {
+      count++;
+      expect(molecule.molfile.toString()).toContain('0999 V2000');
+    }
+    expect(count).toBe(128);
+  });
+});