@datagrok/sequence-translator 1.4.3 → 1.4.5

package/src/polytool/pt-unrule.ts

@@ -30,7 +30,7 @@ export function doPolyToolUnrule(helms: string[], rules: Rules): string[] {
       resHrzSeqList[i] = '';
     else {
       const chain = Chain.fromHelm(helms[i]);
-      resHrzSeqList[i] = chain.getNotation(rules);
+      resHrzSeqList[i] = chain.getNotation();
     }
   }
   return resHrzSeqList;

package/src/polytool/types.ts

@@ -2,6 +2,8 @@ import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
+import {PolymerType} from '@datagrok-libraries/bio/src/helm/types';
+
 export enum PolyToolEnumeratorTypes {
   Single = 'single',
   Matrix = 'matrix',
@@ -21,3 +23,19 @@ export type PolyToolEnumeratorParams = {
   keepOriginal?: boolean;
   trivialName?: boolean;
 }
+
+export class MonomerNotFoundError extends Error {
+  public type = 'MonomerNotFoundError';
+
+  constructor(polymerType: PolymerType, symbol: string, options?: ErrorOptions) {
+    super(`Monomer '${symbol}' of polymer type '${polymerType}' not found`, options);
+  }
+}
+
+export class InvalidReactionError extends Error {
+  public type = 'InvalidReactionError';
+
+  constructor(reaction: string, options?: ErrorOptions) {
+    super(`Invalid reaction '${reaction}'.`);
+  }
+}

package/src/tests/polytool-chain-from-notation-tests.ts

@@ -0,0 +1,45 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
+import {Chain} from '../polytool/pt-conversion';
+import {getRules} from '../polytool/pt-rules';
+
+category('PolyTool: Chain: fromNotation', () => {
+  const tests = {
+    'cyclized': {
+      src: {seq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)-meI'},
+      tgt: {
+        monomerCount: [11], linkageCount: 1,
+        helm: 'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$',
+      },
+    },
+    'reaction1': {
+      src: {seq: 'R-F-azG(3)-T-G-H-F-Y-P-aG(3)-meI'},
+      tgt: {
+        monomerCount: [9, 1], linkageCount: 2,
+        helm: 'PEPTIDE1{R.F.[GGaz].T.G.H.F.Y.P}|PEPTIDE2{[meI]}$PEPTIDE1,PEPTIDE1,3:R3-9:R2|PEPTIDE1,PEPTIDE2,3:R4-1:R1$$$',
+      }
+    },
+    'reaction2': {
+      src: {seq: 'R-F-aG(3)-T-G-H-F-Y-P-azG(3)-meI'},
+      tgt: {
+        // TODO: Target test data requires clarification
+        monomerCount: [2, 8], linkageCount: 0,
+        helm: 'PEPTIDE1{R.F}|PEPTIDE2{T.G.H.F.Y.P.[GGaz].[meI]}$PEPTIDE1,PEPTIDE2,2:R2-7:R3|PEPTIDE2,PEPTIDE2,1:R1-7:R4,$$$',
+      }
+    }
+
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}`, async () => {
+      const rules = await getRules(['rules_example.json']);
+      const resChain = Chain.fromNotation(testData.src.seq, rules);
+      expectArray(resChain.monomers.map((mL) => mL.length), testData.tgt.monomerCount);
+      expect(resChain.linkages.length, testData.tgt.linkageCount);
+      expect(resChain.getHelm(), testData.tgt.helm);
+    }, testName == 'reaction2' ? {skipReason: 'reverse reaction'} : undefined);
+  }
+});

package/src/tests/polytool-chain-parse-notation-tests.ts

@@ -0,0 +1,59 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
+import {Chain} from '../polytool/pt-conversion';
+import {getRules} from '../polytool/pt-rules';
+import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+
+category('PolyTool: Chain: parseNotation', () => {
+  let helmHelper: IHelmHelper;
+
+  before(async () => {
+    helmHelper = await getHelmHelper(); // initialize JSDraw2 and org
+  });
+
+  const tests = {
+    'cyclized': {
+      src: {seq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)-meI'},
+      tgt: {
+        //monomerCount: [11], linkageCount: 1,
+        helm: 'PEPTIDE1{R.F.[C(1)].T.G.H.F.Y.P.[C(1)].[meI]}$$$$V2.0',
+      },
+    },
+    'dimerized1': {
+      src: {seq: '(#2)Succ-{A(CHOL)-F-C(2)-T-G-H-Y-P-C(2)-NH2}'},
+      tgt: {
+        // TODO: Target test data requires clarification
+        //monomerCount: [2, 8], linkageCount: 0,
+        helm: 'PEPTIDE1{[(#2)Succ]}|PEPTIDE2{[A(CHOL)].F.[C(2)].T.G.H.Y.P.[C(2)].[NH2]}$PEPTIDE1,PEPTIDE2,1:R1-1:R1$$$V2.0',
+      },
+    },
+    'dimerized2': {
+      src: {seq: '($2)Succ-{R-F-C(1)-T-G-H-F-P-C(1)-NH2}($2){A(CHOL)-F-C(1)-T-G-H-F-P-C(1)-NH2}'},
+      tgt: {
+        // TODO: Target test data requires clarification
+        //monomerCount: [2, 8], linkageCount: 0,
+        helm: 'PEPTIDE1{[($2)Succ]}|PEPTIDE2{R.F.[C(1)].T.G.H.F.P.[C(1)].[NH2]}|PEPTIDE3{[($2)A(CHOL)].F.[C(1)].T.G.H.F.P.[C(1)].[NH2]}$PEPTIDE1,PEPTIDE2,1:R1-1:R1$$$V2.0',
+      },
+    },
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}`, async () => {
+      const rules = await getRules(['rules_example.json']);
+      const resChain = await Chain.parseNotation(testData.src.seq);
+      //expectArray(resChain.monomers.map((mL) => mL.length), testData.tgt.monomerCount);
+      //expect(resChain.linkages.length, testData.tgt.linkageCount);
+      // expect(resChain.getNotationHelm(), testData.tgt.helm);
+      // expect(resChain.getNotation(), testData.src.seq);
+
+      const resMol = resChain.mol!;
+      const hwe = helmHelper.createHelmWebEditor();
+      hwe.editor.setMol(resMol!);
+      const resHelm = hwe.editor.getHelm();
+      expect(resHelm, testData.tgt.helm);
+    }, testName == 'reaction2' ? {skipReason: 'reverse reaction'} : undefined);
+  }
+});

package/src/tests/polytool-detectors-custom-notation-test.ts

@@ -0,0 +1,43 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {category, test, expect, before} from '@datagrok-libraries/utils/src/test';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {ALIGNMENT, ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {_testNeg, _testPos, DetectorTestData, DfReaderFunc, PosCol} from './utils/detect-macromolecule-utils';
+
+category('PolyTool: detectors', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
+  const tests: DetectorTestData = {
+    'cyclized1': {
+      csv: `n,seq
+1,R-F-C(1)-T-G-H-F-Y-G-H-F-Y-G-H-F-Y-P-C(1)-meI
+2,C(1)-T-G-H-F-Y-P-C(1)-meI
+3,R-F-C(1)-T-G-H-F-Y-P-C(1)
+4,C(1)-T-G-H-F-H-P-C(1)
+5,R-F-D(2)-T-G-H-F-Y-P-NH2(2)
+6,R-F-aG(3)-T-G-H-F-Y-P-azG(3)-meI`,
+      pos: {'seq': new PosCol(NOTATION.CUSTOM, ALIGNMENT.SEQ, ALPHABET.UN, 13, true, '-')}
+    },
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}`, async () => {
+      const reader: DfReaderFunc = async (): Promise<DG.DataFrame> => {
+        return DG.DataFrame.fromCsv(testData.csv);
+      };
+      for (const negColName of testData.neg ?? [])
+        await _testNeg(reader, negColName);
+      for (const [posColName, posCol] of Object.entries(testData.pos ?? {})) {
+        await _testPos(reader, posColName, seqHelper, posCol.units, posCol.aligned,
+          posCol.alphabet, posCol.alphabetSize, posCol.alphabetIsMultichar, posCol.separator);
+      }
+    });
+  }
+});

package/src/tests/toAtomicLevel-tests.ts

@@ -15,6 +15,8 @@ import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 
 import {_package} from '../package-test';
+import {getNewMonomer} from '../polytool/pt-conversion';
+import {getRules, RuleReaction} from '../polytool/pt-rules';
 
 category('toAtomicLevel', () => {
   let userLibSettings: UserLibSettings;
@@ -43,7 +45,7 @@ category('toAtomicLevel', () => {
     expect(ggazM != null, true, `Monomer 'GGaz' not found.`);
 
     const overrideMonomerLibData: MonomerLibData = {[PolymerTypes.PEPTIDE]: {'GGaz': ggazM}};
-    const overriddenMonomerLib = systemMonomerLib.override(overrideMonomerLibData);
+    const overriddenMonomerLib = systemMonomerLib.override(overrideMonomerLibData, 'test');
 
     const seqHelper = await getSeqHelper();
 
@@ -69,4 +71,27 @@ category('toAtomicLevel', () => {
       mol.delete();
     }
   });
+
+  test('getNewMonomer', async () => {
+    const rdKitModule = await getRdKitModule();
+    const systemMonomerLib = monomerLibHelper.getMonomerLib();
+
+    const rules = await getRules(['rules_example.json']);
+    const reactionRule = rules.reactionRules.find((r) => r.name == 'GGaz')!;
+
+    const [newSymbol, newMonomer] = getNewMonomer(rdKitModule, systemMonomerLib, reactionRule);
+    expect(newSymbol, reactionRule.name);
+
+    const mol = rdKitModule.get_mol(newMonomer.molfile);
+    try {
+      const molInchi = mol.get_inchi();
+      const molInchiKey = rdKitModule.get_inchikey_for_inchi(molInchi);
+      expect(mol.get_num_bonds(), 18);
+      expect(mol.get_num_atoms(), 18);
+      // TODO: Check inchi key for the new monomer molfile
+      // expect(molInchiKey, 'V2H10N2O3S-UHFFFAOYSA-N');
+    } finally {
+      mol.delete();
+    }
+  });
 });

package/src/tests/utils/detect-macromolecule-utils.ts

@@ -0,0 +1,64 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
+import {ALIGNMENT, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {delay, expect} from '@datagrok-libraries/utils/src/test';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+
+export type DetectorTestData = { [testName: string]: { csv: string, neg?: string[], pos?: { [colName: string]: PosCol } } };
+
+export type DfReaderFunc = () => Promise<DG.DataFrame>;
+
+export class PosCol {
+  constructor(
+    public readonly units: NOTATION,
+    public readonly aligned: ALIGNMENT | null,
+    public readonly alphabet: string | null,
+    public readonly alphabetSize: number,
+    public readonly alphabetIsMultichar?: boolean,
+    public readonly separator?: string,
+  ) { };
+}
+
+export async function _testNeg(readDf: DfReaderFunc, colName: string) {
+  const df: DG.DataFrame = await readDf();
+  const col: DG.Column = df.getCol(colName)!;
+  const semType: string = await grok.functions
+    .call('Bio:detectMacromolecule', {col: col}) as unknown as string;
+  if (semType)
+    col.semType = semType;
+
+  if (col.semType === DG.SEMTYPE.MACROMOLECULE) {
+    const msg = `Negative test detected semType='${col.semType}', units='${col.meta.units}'.`;
+    throw new Error(msg);
+  }
+}
+
+export async function _testPos(
+  readDf: DfReaderFunc, colName: string, seqHelper: ISeqHelper,
+  units: string, aligned: string | null, alphabet: string | null, alphabetSize: number, alphabetIsMultichar?: boolean,
+  separator: string | null = null,
+) {
+  const df: DG.DataFrame = await readDf();
+  const col: DG.Column = df.col(colName)!;
+  const semType: string = await grok.functions
+    .call('Bio:detectMacromolecule', {col: col}) as unknown as string;
+  if (semType)
+    col.semType = semType;
+
+  expect(col.semType, DG.SEMTYPE.MACROMOLECULE);
+  expect(col.meta.units, units);
+  expect(col.getTag(bioTAGS.aligned), aligned);
+  expect(col.getTag(bioTAGS.alphabet), alphabet);
+  if (separator)
+    expect(col.getTag(bioTAGS.separator), separator);
+
+  const sh = seqHelper.getSeqHandler(col);
+  expect(sh.getAlphabetSize(), alphabetSize);
+  expect(sh.getAlphabetIsMultichar(), alphabetIsMultichar);
+  if (!sh.isHelm()) {
+    expect(sh.aligned, aligned);
+    expect(sh.alphabet, alphabet);
+  }
+}
+

package/src/tests/{utils.ts → utils/index.ts}

@@ -2,8 +2,8 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {DEFAULT_FORMATS} from '../apps/common/model/const';
-import {ITranslationHelper} from '../types';
+import {DEFAULT_FORMATS} from '../../apps/common/model/const';
+import {ITranslationHelper} from '../../types';
 
 export class OligoToolkitTestPackage extends DG.Package {
   async getTranslationHelper(): Promise<ITranslationHelper> {

package/src/utils/context-menu.ts

@@ -2,9 +2,6 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-
 import {defaultErrorHandler} from './err-info';
 import {polyToolEnumerateHelmUI} from '../polytool/pt-enumeration-helm-dialog';
 import {polyToolEnumerateChemUI} from '../polytool/pt-dialog';

package/src/utils/cyclized.ts

@@ -0,0 +1,90 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import wu from 'wu';
+
+/* eslint-disable max-len */
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {INotationProvider, ISeqSplitted, SeqSplittedBase, SplitterFunc} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+import {getSplitterWithSeparator} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {GAP_SYMBOL, GapOriginals, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {CellRendererBackBase} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
+import {MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
+import {monomerToShort, StringListSeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+
+import {Chain} from '../polytool/pt-conversion';
+
+import {_package} from '../package';
+
+/* eslint-enable max-len */
+
+export class CyclizedNotationProvider implements INotationProvider {
+  private readonly separatorSplitter: SplitterFunc;
+  public readonly splitter: SplitterFunc;
+
+  constructor(
+    public readonly separator: string,
+    protected readonly seqHelper: ISeqHelper
+  ) {
+    this.separatorSplitter = getSplitterWithSeparator(this.separator);
+    this.splitter = this._splitter.bind(this);
+  }
+
+  private _splitter(seq: string): ISeqSplitted {
+    const baseSS: ISeqSplitted = this.separatorSplitter(seq);
+    return new CyclizedSeqSplitted(
+      wu.count(0).take(baseSS.length).map((p) => baseSS.getOriginal(p)).toArray(),
+      GapOriginals[NOTATION.SEPARATOR]);
+  }
+
+  public async getHelm(seq: string, options?: any): Promise<DG.SemanticValue<string>> {
+    const seqChain = await Chain.parseNotation(seq);
+    const seqPseudoHelm = seqChain.getNotationHelm();
+
+    const resPseudoHelmSV = DG.SemanticValue.fromValueType(seqPseudoHelm,
+      DG.SEMTYPE.MACROMOLECULE, NOTATION.HELM);
+    resPseudoHelmSV.tags['pt-role'] = 'template';
+    return resPseudoHelmSV;
+  }
+
+  public createCellRendererBack(gridCol: DG.GridColumn | null, tableCol: DG.Column<string>): CellRendererBackBase<string> {
+    let maxLengthOfMonomer: number = 4; // (_package.bioProperties ? _package.bioProperties.maxMonomerLength : 4) ?? 50;
+    const back = new MonomerPlacer(gridCol, tableCol, _package.logger, maxLengthOfMonomer,
+      () => {
+        const sh = this.seqHelper.getSeqHandler(tableCol);
+        return {
+          seqHandler: sh,
+          monomerCharWidth: 7,
+          separatorWidth: 11,
+          monomerToShort: monomerToShort,
+        };
+      });
+    back.init().then(() => {});
+    return back;
+  }
+}
+
+/** Gets canonical monomers for original ones with cyclization marks */
+export class CyclizedSeqSplitted extends StringListSeqSplitted {
+  private readonly seqCList: (string | null)[];
+
+  override getCanonical(posIdx: number): string {
+    if (this.isGap(posIdx)) return GAP_SYMBOL;
+
+    let cmRes: string | null = this.seqCList[posIdx];
+    if (cmRes === null) {
+      const om = this.getOriginal(posIdx);
+      cmRes = om;
+      if (om[om.length - 1] === ')')
+        cmRes = this.seqCList[posIdx] = om.replace(/\(\d+\)$/, '');
+    }
+    return cmRes;
+  }
+
+  constructor(seqOList: SeqSplittedBase, gapOriginalMonomer: string) {
+    super(seqOList, gapOriginalMonomer);
+    this.seqCList = new Array<string | null>(this.length).fill(null);
+  }
+}

package/src/utils/dimerized.ts

@@ -0,0 +1,10 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {CyclizedNotationProvider} from './cyclized';
+
+
+export class DimerizedNotationProvider extends CyclizedNotationProvider {
+
+}