@datagrok/sequence-translator 1.4.4 → 1.4.5

package/src/polytool/pt-enumeration-helm-dialog.ts

@@ -16,7 +16,6 @@ import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-he
 import '@datagrok-libraries/bio/src/types/input';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {InputColumnBase} from '@datagrok-libraries/bio/src/types/input';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
 import {
   PolyToolEnumeratorParams, PolyToolEnumeratorType, PolyToolEnumeratorTypes
@@ -36,8 +35,9 @@ type PolyToolEnumerateInputs = {
   placeholdersBreadth: PolyToolPlaceholdersBreadthInput;
   enumeratorType: DG.ChoiceInput<PolyToolEnumeratorType>
   trivialNameCol: InputColumnBase,
-  toAtomicLevel: DG.InputBase<boolean>;
   keepOriginal: DG.InputBase<boolean>;
+  toAtomicLevel: DG.InputBase<boolean>;
+  toHarmonizedSequence: DG.InputBase<boolean>;
 };
 
 type PolyToolEnumerateHelmSerialized = {
@@ -46,8 +46,9 @@ type PolyToolEnumerateHelmSerialized = {
   placeholdersBreadth: string;
   enumeratorType: PolyToolEnumeratorType;
   trivialNameCol: string;
-  toAtomicLevel: boolean;
   keepOriginal: boolean;
+  toAtomicLevel: boolean;
+  toHarmonizedSequence: boolean;
 };
 
 export async function polyToolEnumerateHelmUI(cell?: DG.Cell): Promise<void> {
@@ -160,10 +161,12 @@ async function getPolyToolEnumerateDialog(
           showRowHeader: false,
           showCellTooltip: false,
         }),
-      toAtomicLevel: ui.input.bool(
-        'To atomic level', {value: false}),
       keepOriginal: ui.input.bool(
         'Keep original', {value: false}),
+      toAtomicLevel: ui.input.bool(
+        'To atomic level', {value: false}),
+      toHarmonizedSequence: ui.input.bool(
+        'To harmonized sequence', {value: false}),
       trivialNameCol: ui.input.column2(
         'Trivial name', {
           table: cell?.dataFrame,
@@ -184,6 +187,7 @@ async function getPolyToolEnumerateDialog(
         }),
     };
 
+    inputs.toHarmonizedSequence.root.style.display = 'none';
     inputs.trivialNameCol.addOptions(trivialNameSampleDiv);
 
     let placeholdersValidity: string | null = null;
@@ -363,8 +367,9 @@ async function getPolyToolEnumerateDialog(
       let helmValue: string;
       let table: DG.DataFrame | undefined = undefined;
       if (cell && cell.rowIndex >= 0 && cell?.column.semType == DG.SEMTYPE.MACROMOLECULE) {
-        const sh = SeqHandler.forColumn(cell.column);
-        helmValue = await sh.getHelm(cell.rowIndex);
+        const sh = _package.seqHelper.getSeqHandler(cell.column);
+        const helmSemValue = await sh.getHelm(cell.rowIndex);
+        helmValue = helmSemValue.value;
         table = cell.dataFrame;
       } else {
         helmValue = PT_HELM_EXAMPLE;
@@ -414,8 +419,8 @@ async function getPolyToolEnumerateDialog(
       .add(inputs.enumeratorType)
       .add(inputs.placeholdersBreadth)
       .add(inputs.trivialNameCol)
-      .add(inputs.toAtomicLevel)
-      .add(inputs.keepOriginal)
+      .add(ui.divH([inputs.keepOriginal.root, inputs.toAtomicLevel.root, inputs.toHarmonizedSequence.root],
+        {style: {width: '100%'}}))
       .add(warningsTextDiv)
       // .addButton('Enumerate', () => {
       //   execDialog()
@@ -433,8 +438,9 @@ async function getPolyToolEnumerateDialog(
           enumeratorType: inputs.enumeratorType.value,
           placeholdersBreadth: inputs.placeholdersBreadth.stringValue,
           trivialNameCol: inputs.trivialNameCol.stringValue,
-          toAtomicLevel: inputs.toAtomicLevel.value,
           keepOriginal: inputs.keepOriginal.value,
+          toAtomicLevel: inputs.toAtomicLevel.value,
+          toHarmonizedSequence: inputs.toHarmonizedSequence.value,
         };
       },
       /* applyInput */ (x: PolyToolEnumerateHelmSerialized): void => {
@@ -443,8 +449,9 @@ async function getPolyToolEnumerateDialog(
         inputs.enumeratorType.value = x.enumeratorType;
         inputs.placeholdersBreadth.stringValue = x.placeholdersBreadth;
         inputs.trivialNameCol.stringValue = x.trivialNameCol;
-        inputs.toAtomicLevel.value = x.toAtomicLevel;
         inputs.keepOriginal.value = x.keepOriginal;
+        inputs.toAtomicLevel.value = x.toAtomicLevel;
+        inputs.toHarmonizedSequence.value = x.toHarmonizedSequence;
       });
     return dialog;
   } catch (err: any) {

package/src/polytool/pt-enumeration-helm.ts

@@ -4,7 +4,8 @@ import * as DG from 'datagrok-api/dg';
 
 import {
   HelmType, HelmMol,
-  JSDraw2ModuleType, OrgType
+  JSDraw2ModuleType, OrgType,
+  IHelmEditorOptions
 } from '@datagrok-libraries/bio/src/helm/types';
 
 
@@ -72,7 +73,7 @@ function getPtEnumeratorBreadth(m: HelmMol, placeholdersBreadth: PolyToolPlaceho
 export function doPolyToolEnumerateHelm(
   helm: string, id: string, params: PolyToolEnumeratorParams
 ): [ /* helm */ string, /* id */ string][] {
-  const molHandler = new JSDraw2.MolHandler<HelmType>();
+  const molHandler = new JSDraw2.MolHandler<HelmType, IHelmEditorOptions>();
   const plugin = new org.helm.webeditor.Plugin(molHandler);
   org.helm.webeditor.IO.parseHelm(plugin, helm, new JSDraw2.Point(0, 0), undefined);
   const m = molHandler.m;

package/src/polytool/pt-unrule-dialog.ts

@@ -4,7 +4,6 @@ import * as DG from 'datagrok-api/dg';
 
 import {Unsubscribable} from 'rxjs';
 
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getUnusedColName} from '@datagrok-libraries/bio/src/monomer-works/utils';
 
@@ -12,6 +11,7 @@ import {defaultErrorHandler} from '../utils/err-info';
 import {doPolyToolUnrule} from './pt-unrule';
 import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
 import {PT_ERROR_DATAFRAME, PT_UI_DIALOG_UNRULE, PT_UI_RULES_USED} from './const';
+import {_package} from '../package';
 
 type PolyToolUnruleSerialized = {
   rules: string[];
@@ -34,7 +34,7 @@ export async function getPolyToolUnruleDialog(srcCol?: DG.Column<string>): Promi
       table: srcColVal.dataFrame, value: srcColVal,
       filter: (col: DG.Column) => {
         if (col.semType !== DG.SEMTYPE.MACROMOLECULE) return false;
-        const sh = SeqHandler.forColumn(col);
+        const sh = _package.seqHelper.getSeqHandler(col);
         return sh.notation === NOTATION.HELM;
       }
     });

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/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

@@ -45,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();
 

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 {
+
+}