@datagrok/bio 2.15.2 → 2.15.5

package/src/package.ts

@@ -4,8 +4,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {Options} from '@datagrok-libraries/utils/src/type-declarations';
-import {DimReductionBaseEditor, PreprocessFunctionReturnType}
-  from '@datagrok-libraries/ml/src/functionEditors/dimensionality-reduction-editor';
+import {DimReductionBaseEditor, PreprocessFunctionReturnType} from '@datagrok-libraries/ml/src/functionEditors/dimensionality-reduction-editor';
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {BitArrayMetrics, KnownMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
@@ -14,50 +13,38 @@ import {SeqHandler, SeqTemps} from '@datagrok-libraries/bio/src/utils/seq-handle
 import {IMonomerLib, IMonomerSet} from '@datagrok-libraries/bio/src/types';
 import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
 import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
-import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
-import {SCORE, calculateScores} from '@datagrok-libraries/bio/src/utils/macromolecule/scoring';
-import {
-  createJsonMonomerLibFromSdf, IMonomerLibHelper
-} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {SCORE} from '@datagrok-libraries/bio/src/utils/macromolecule/scoring';
+import {createJsonMonomerLibFromSdf, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {ActivityCliffsEditor} from '@datagrok-libraries/ml/src/functionEditors/activity-cliffs-function-editor';
 import BitArray from '@datagrok-libraries/utils/src/bit-array';
 import {BYPASS_LARGE_DATA_WARNING} from '@datagrok-libraries/ml/src/functionEditors/consts';
-import {
-  getEmbeddingColsNames, multiColReduceDimensionality
-} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/reduce-dimensionality';
+import {getEmbeddingColsNames, multiColReduceDimensionality} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/reduce-dimensionality';
 import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
-import {
-  ITSNEOptions, IUMAPOptions
-} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/multi-column-dim-reducer';
+import {ITSNEOptions, IUMAPOptions} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/multi-column-dim-reducer';
 import {generateLongSequence, generateLongSequence2} from '@datagrok-libraries/bio/src/utils/generator';
 import {getUserLibSettings, setUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
-import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import {getMacromoleculeColumns} from './utils/ui-utils';
-import {
-  MacromoleculeDifferenceCellRenderer, MacromoleculeSequenceCellRenderer,
-} from './utils/cell-renderer';
+import {MacromoleculeDifferenceCellRenderer, MacromoleculeSequenceCellRenderer,} from './utils/cell-renderer';
+import {MacromoleculeCustomCellRenderer} from './utils/cell-renderer-custom';
 import {VdRegionsViewer} from './viewers/vd-regions-viewer';
 import {SequenceAlignment} from './seq_align';
 import {getEncodedSeqSpaceCol} from './analysis/sequence-space';
-import {
-  createLinesGrid, createPropPanelElement, createTooltipElement,
-} from './analysis/sequence-activity-cliffs';
+import {createLinesGrid, createPropPanelElement, createTooltipElement,} from './analysis/sequence-activity-cliffs';
 import {SequenceSimilarityViewer} from './analysis/sequence-similarity-viewer';
 import {SequenceDiversityViewer} from './analysis/sequence-diversity-viewer';
-import {MONOMERIC_COL_TAGS, SubstructureSearchDialog, invalidateMols} from './substructure-search/substructure-search';
+import {invalidateMols, MONOMERIC_COL_TAGS, SubstructureSearchDialog} from './substructure-search/substructure-search';
 import {convert} from './utils/convert';
 import {getMacromoleculeColumnPropertyPanel} from './widgets/representations';
 import {saveAsFastaUI} from './utils/save-as-fasta';
 import {BioSubstructureFilter} from './widgets/bio-substructure-filter';
 import {WebLogoViewer} from './viewers/web-logo-viewer';
 import {MonomerLibManager} from './utils/monomer-lib/lib-manager';
-import {getMonomerLibraryManagerLink, showManageLibrariesDialog,
-  showManageLibrariesView} from './utils/monomer-lib/library-file-manager/ui';
+import {getMonomerLibraryManagerLink, showManageLibrariesDialog, showManageLibrariesView} from './utils/monomer-lib/library-file-manager/ui';
 import {demoBio01UI} from './demo/bio01-similarity-diversity';
 import {demoBio01aUI} from './demo/bio01a-hierarchical-clustering-and-sequence-space';
 import {demoBio01bUI} from './demo/bio01b-hierarchical-clustering-and-activity-cliffs';
@@ -115,8 +102,17 @@ export class SeqPaletteCustom implements SeqPalette {
 let monomerLib: IMonomerLib | null = null;
 let monomerSets: IMonomerSet | null = null;
 
+let initBioPromise: Promise<void> | null = null;
+
 //tags: init
-export async function initBio() {
+export async function initBio(): Promise<void> {
+  if (initBioPromise === null) {
+    initBioPromise = initBioInt();
+  }
+  await initBioPromise;
+}
+
+async function initBioInt() {
   const logPrefix = 'Bio: _package.initBio()';
   _package.logger.debug(`${logPrefix}, start`);
   let rdKitModule!: RDModule;
@@ -195,7 +191,7 @@ export function getBioLib(): IMonomerLib {
 }
 
 // For sync internal use, on initialized package
-export function getMonomerLib(): IMonomerLib | null {
+export function getMonomerLib(): IMonomerLib {
   return monomerLib!;
 }
 
@@ -326,6 +322,15 @@ export function SeqActivityCliffsEditor(call: DG.FuncCall) {
 
 // -- Cell renderers --
 
+//name: customSequenceCellRenderer
+//tags: cellRenderer
+//meta.cellType: sequence
+//meta.columnTags: quality=Macromolecule, units=custom
+//output: grid_cell_renderer result
+export function customSequenceCellRenderer(): DG.GridCellRenderer {
+  return new MacromoleculeCustomCellRenderer();
+}
+
 //name: fastaSequenceCellRenderer
 //tags: cellRenderer
 //meta.cellType: sequence
@@ -335,6 +340,15 @@ export function fastaSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
   return new MacromoleculeSequenceCellRenderer();
 }
 
+//name: separatorSequenceCellRenderer
+//tags: cellRenderer
+//meta.cellType: sequence
+//meta.columnTags: quality=Macromolecule, units=separator
+//output: grid_cell_renderer result
+export function separatorSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
+  return new MacromoleculeSequenceCellRenderer();
+}
+
 // -- Property panels --
 
 //name:  Bioinformatics | Sequence Renderer
@@ -353,15 +367,6 @@ export function compositionAnalysisWidget(sequence: DG.SemanticValue): DG.Widget
   return getCompositionAnalysisWidget(sequence);
 }
 
-//name: separatorSequenceCellRenderer
-//tags: cellRenderer
-//meta.cellType: sequence
-//meta.columnTags: quality=Macromolecule, units=separator
-//output: grid_cell_renderer result
-export function separatorSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
-  return new MacromoleculeSequenceCellRenderer();
-}
-
 //name: MacromoleculeDifferenceCellRenderer
 //tags: cellRenderer
 //meta.cellType: MacromoleculeDifference
@@ -621,13 +626,17 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, molecules: DG.Co
 //description: Converts sequences to molblocks
 //input: dataframe table [Input data table]
 //input: column seqCol {caption: Sequence; semType: Macromolecule}
-//input: bool nonlinear =false {caption: Non linear; description: Slower mode for cycling/branching HELM structures}
+//input: bool nonlinear =false {caption: Non-linear; description: Slower mode for cycling/branching HELM structures}
+//input: bool highlight =false {caption: Highlight monomers; description: Highlight monomers' substructures of the molecule }
 //output:
-export async function toAtomicLevel(table: DG.DataFrame, seqCol: DG.Column, nonlinear: boolean): Promise<void> {
+export async function toAtomicLevel(
+  table: DG.DataFrame, seqCol: DG.Column, nonlinear: boolean, highlight: boolean = false
+): Promise<void> {
   const pi = DG.TaskBarProgressIndicator.create('Converting to atomic level ...');
   try {
+    await initBioPromise;
     const monomerLib = (await getMonomerLibHelper()).getMonomerLib();
-    await sequenceToMolfile(table, seqCol, nonlinear, monomerLib);
+    await sequenceToMolfile(table, seqCol, nonlinear, highlight, monomerLib, _package.rdKitModule);
   } finally {
     pi.close();
   }
@@ -751,6 +760,31 @@ export function convertDialog() {
   convert(col);
 }
 
+//top-menu: Bio | Convert | TestConvert
+//name: convertSeqNotation
+//description: RDKit-based conversion for SMILES, SMARTS, InChi, Molfile V2000 and Molfile V3000
+//input: string sequence {semType: Macromolecule}
+//input: string targetNotation
+//input: string separator
+//output: string result
+export async function convertSeqNotation(sequence: string, targetNotation: NOTATION, separator?: string): Promise<string | undefined | null> {
+  try {
+    const col = DG.Column.fromStrings('sequence', [sequence]);
+    const df = DG.DataFrame.fromColumns([col]);
+    const semType = await grok.functions.call('Bio:detectMacromolecule', {col: col});
+    if (semType)
+      col.semType = semType;
+    const converterSh = SeqHandler.forColumn(col);
+    const newColumn = converterSh.convert(targetNotation, separator);
+    return newColumn.get(0);
+  } catch (err: any) {
+    const [errMsg, errStack] = errInfo(err);
+    _package.logger.error(errMsg, undefined, errStack);
+    throw err;
+  }
+}
+
+
 //name: monomerCellRenderer
 //tags: cellRenderer
 //meta.cellType: Monomer
@@ -1098,6 +1132,76 @@ export async function sdfToJsonLib(table: DG.DataFrame) {
 
 // -- Utils --
 
+//name: seq2atomic
+//friendlyName: seq2atomic
+//description: Converts a `Macromolecule` sequence to its atomic level `Molecule` representation
+//input: string seq { semType: Macromolecule }
+//input: bool nonlinear
+//output: string molfile { semType: Molecule }
+//meta.role: converter
+export async function seq2atomic(seq: string, nonlinear: boolean): Promise<string | undefined> {
+  if (!(seq.trim())) return '';
+  try {
+    const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, `helm`, [seq]);
+    const df = DG.DataFrame.fromColumns([seqCol]);
+    const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+    if (semType) seqCol.semType = semType;
+
+    const monomerLib = (await getMonomerLibHelper()).getMonomerLib();
+    const res = (await sequenceToMolfile(df, seqCol, nonlinear, false, monomerLib, _package.rdKitModule))?.molCol?.get(0);
+    return res ?? undefined;
+  } catch (err: any) {
+    const [errMsg, errStack] = errInfo(err);
+    _package.logger.error(errMsg, undefined, errStack);
+    throw err;
+  }
+}
+
+// //description: Gets similarity to a reference sequence
+// //input: string seq { semType: Macromolecule }
+// //input: string ref { semType: Macromolecule }
+// //output: double result
+// export async function seqSimilarity(seq: string, ref: string): Promise<number> {
+//   // if (!(seq.trim())) return null;
+//   try {
+//     const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, `seq`, [seq]);
+//     const df = DG.DataFrame.fromColumns([seqCol]);
+//     const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+//     if (semType) seqCol.semType = semType;
+//
+//     const resCol = await calculateScoresWithEmptyValues(df, seqCol, ref, SCORE.SIMILARITY);
+//     return resCol.get(0)!;
+//   } catch (err: any) {
+//     const [errMsg, errStack] = errInfo(err);
+//     _package.logger.error(errMsg, undefined, errStack);
+//     throw err;
+//   }
+// }
+
+//name: seqIdentity
+//friendlyName: seqIdentity
+//description: Gets identity to a reference sequence
+//input: string seq { semType: Macromolecule }
+//input: string ref { semType: Macromolecule }
+//output: double result
+export async function seqIdentity(seq: string, ref: string): Promise<number | null> {
+  if (!(seq.trim())) return null;
+  try {
+    const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, `seq`, [seq]);
+    const df = DG.DataFrame.fromColumns([seqCol]);
+    const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+    if (!semType) throw new Error('Macromolecule required');
+
+    const resCol = await calculateScoresWithEmptyValues(df, seqCol, ref, SCORE.IDENTITY);
+    return resCol.get(0);
+  } catch (err: any) {
+    const [errMsg, errStack] = errInfo(err);
+    _package.logger.error(errMsg, undefined, errStack);
+    throw err;
+  }
+}
+
+
 //name: detectMacromoleculeProbe
 //input: file file
 //input: string colName = ''
@@ -1121,7 +1225,7 @@ export async function getSeqHelper(): Promise<ISeqHelper> {
 export function getMolFromHelm(
   df: DG.DataFrame, helmCol: DG.Column<string>, chiralityEngine: boolean
 ): Promise<DG.Column<string>> {
-  return getMolColumnFromHelm(df, helmCol, chiralityEngine);
+  return getMolColumnFromHelm(df, helmCol, chiralityEngine, getMonomerLib());
 }
 
 // -- Custom notation providers --
@@ -1130,6 +1234,7 @@ export function getMolFromHelm(
 //input: column col
 //input: string separator
 export function applyNotationProviderForCyclized(col: DG.Column<string>, separator: string) {
+  col.meta.units = NOTATION.CUSTOM;
   col.temp[SeqTemps.notationProvider] = new CyclizedNotationProvider(separator);
 }
 
@@ -1137,5 +1242,13 @@ export function applyNotationProviderForCyclized(col: DG.Column<string>, separat
 //input: column col
 //input: string separator
 export function applyNotationProviderForDimerized(col: DG.Column<string>, separator: string) {
+  col.meta.units = NOTATION.CUSTOM;
   col.temp[SeqTemps.notationProvider] = new DimerizedNotationProvider(separator);
 }
+
+//name: test1
+//output: object result
+export function test1(): any {
+  _package.logger.debug('Bio:test1() function');
+  return {value: 'value1'};
+}

package/src/tests/WebLogo-positions-test.ts

@@ -4,7 +4,6 @@ import * as DG from 'datagrok-api/dg';
 import {category, expect, expectArray, test, testEvent} from '@datagrok-libraries/utils/src/test';
 import {ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
-import {GAP_SYMBOL} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 
 import {
   countForMonomerAtPosition,
@@ -12,6 +11,7 @@ import {
   PositionMonomerInfo as PMI,
   WebLogoViewer,
 } from '../viewers/web-logo-viewer';
+import {GAP_SYMBOL} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
 const g: string = GAP_SYMBOL;
 

package/src/tests/bio-tests.ts

@@ -10,7 +10,7 @@ import {Nucleotides, NucleotidesPalettes} from '@datagrok-libraries/bio/src/nucl
 import {AminoacidsPalettes} from '@datagrok-libraries/bio/src/aminoacids';
 import {UnknownSeqPalette} from '@datagrok-libraries/bio/src/unknown';
 import {getStatsForCol} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
-import {GAP_SYMBOL} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+import {GAP_SYMBOL} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
 /** GAP_SYMBOL */
 const g: string = GAP_SYMBOL;

package/src/tests/detectors-tests.ts

@@ -147,16 +147,16 @@ YN[Re]VYNR[Ac]WYV
     },
     'sepSameLength': {
       csv: `seq
-Ac(1)-A-A-A-A-A-A-A-A-A-A-A-A-A-C(1)-G-NH2
-Ac(1)-A-A-A-A-A-A-A-A-A-A-A-A-A-C(1)-G-NH2
-Ac(1)-A-A-A-A-A-A-A-A-A-A-A-A-A-C(1)-G-NH2`,
+Aca-A-A-A-A-A-A-A-A-A-A-A-A-A-C-G-NH2
+Aca-A-A-A-A-A-A-A-A-A-A-A-A-A-C-G-NH2
+Aca-A-A-A-A-A-A-A-A-A-A-A-A-A-C-G-NH2`,
       pos: {'seq': new PosCol(NOTATION.SEPARATOR, ALIGNMENT.SEQ_MSA, ALPHABET.UN, 5, true, '-')}
     },
     'sepMsaSameLength': {
       csv: `seq
-Ac(1)-A-A-A-A-A-A-A-A-A-A-A-A-A-C(1)-G-NH2
-Ac(1)-A-A(2)-A-A-A-C(2)-A-A-A-A-C(1)-G-NH2
-Ac(1)-A-A-A-A-A-A-A-A-A-A-A-A-A-C(1)-G-NH2`,
+Aca-A-A-A-A-A-A-A-A-A-A-A-A-A-Aca-G-NH2
+Aca-A-Aca-A-A-A-meI-A-A-A-A-A-Aca-G-NH2
+Aca-A-A-A-A-A-A-A-A-A-A-A-A-A-Aca-G-NH2`,
       pos: {'seq': new PosCol(NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.UN, 5, true, '-')}
     },
     'helmSameLength': {
@@ -237,9 +237,9 @@ m1-mon2-m3-mon4-mon5-Num--MON8-N9-m1-mon2-m3-mon4-mon5-Num--MON8-N9
 
 mon1-M-mon3-mon4-mon5---MON8-N9-mon1-M-mon3-mon4-mon5---MON8-N9`;
     [csvTests.sepComplex]: string = `seq
-Ac(1)-F-K(AEEA-AEEA-R-Ac)-L-mF-V-Y-mNle-D-W-N-mF-C(1)-G-NH2
-Ac(1)-F-K(AEEA-ARRA-W-Ac)-L-mF-V-Y-mNle-D-W-N-mF-C(1)-G-NH2
-Ac(1)-F-K(AEEA-AEEA-Ac)-L-mF-V-Y-mNle-D-W-N-mF-C(1)-G-NH2`;
+Aca-F-K(AEEA-AEEA-R-Ac)-L-mF-V-Y-mNle-D-W-N-mF-Aca-G-NH2
+Aca-F-K(AEEA-ARRA-W-Ac)-L-mF-V-Y-mNle-D-W-N-mF-Aca-G-NH2
+Aca-F-K(AEEA-AEEA-Ac)-L-mF-V-Y-mNle-D-W-N-mF-Aca-G-NH2`;
     [csvTests.fastaMsaDna1]: string = `seq
 AC-GT-CTAC-GT-CT
 CAC-T-GTCAC-T-GT
@@ -406,7 +406,7 @@ MWRSWY-CKHPMWRSWY-CKHP`;
 
   test('SepComplex', async () => {
     await _testPos(readCsv(csvTests.sepComplex), 'seq',
-      NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.UN, 18, true);
+      NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.UN, 17, true);
   });
 
   test('samplesFastaCsv', async () => {

package/src/tests/monomer-libraries-tests.ts

@@ -27,7 +27,7 @@ category('monomerLibraries', () => {
   test('default', async () => {
     // Clear settings to test default
     await setUserLibSettings({exclude: [], explicit: [], duplicateMonomerPreferences: {}});
-    await monomerLibHelper.loadLibraries(true); // test defaultLib
+    await monomerLibHelper.loadMonomerLib(true); // test defaultLib
 
     // Currently default monomer lib set is of all files at LIB_PATH (at least HELMCoreLibrary.json)
     const currentMonomerLib = monomerLibHelper.getMonomerLib();

package/src/tests/seq-handler-splitted-tests.ts

@@ -4,8 +4,9 @@ import * as DG from 'datagrok-api/dg';
 import wu from 'wu';
 
 import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
-import {GapOriginals, SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {GapOriginals} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
 enum Tests {
   fasta = 'fasta',
@@ -135,7 +136,10 @@ PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.T.dK.Thr_PO3H2}$$$$`
       expect(sh.separator === testData.tgt.separator, true);
 
       const resSplitted: string[][] = wu.count(0).take(sh.length)
-        .map((rowIdx) => wu(sh.getSplitted(rowIdx).originals).toArray()).toArray();
+        .map((rowIdx) => {
+          const seqSS = sh.getSplitted(rowIdx);
+          return wu.count(0).take(seqSS.length).map((posIdx) => seqSS.getOriginal(posIdx)).toArray();
+        }).toArray();
       expectArray(resSplitted, testData.tgt.splitted);
     });
   }

package/src/tests/splitters-test.ts

@@ -144,13 +144,13 @@ PEPTIDE1{hHis.Aca.Cys_SEt}$$$,5.72388
 });
 
 export async function _testFastaSplitter(src: string, tgt: string[]) {
-  const res: ISeqSplitted = splitterAsFasta(src);
-  console.debug(`Bio: tests: splitters: src=${JSON.stringify(src)}, res=${JSON.stringify(res)} .`);
-  expectArray(wu(res.originals).toArray(), tgt);
+  const resSS: ISeqSplitted = splitterAsFasta(src);
+  console.debug(`Bio: tests: splitters: src=${JSON.stringify(src)}, res=${JSON.stringify(resSS)} .`);
+  expectArray(wu.count(0).take(resSS.length).map((p) => resSS.getOriginal(p)).toArray(), tgt);
 }
 
 export async function _testHelmSplitter(src: string, tgt: string[]) {
-  const res: ISeqSplitted = splitterAsHelm(src);
-  console.debug(`Bio: tests: splitters: src=${JSON.stringify(src)}, res=${JSON.stringify(res)} .`);
-  expectArray(wu(res.originals).toArray(), tgt);
+  const resSS: ISeqSplitted = splitterAsHelm(src);
+  console.debug(`Bio: tests: splitters: src=${JSON.stringify(src)}, res=${JSON.stringify(resSS)} .`);
+  expectArray(wu.count(0).take(resSS.length).map((p) => resSS.getOriginal(p)).toArray(), tgt);
 }

package/src/tests/to-atomic-level-tests.ts

@@ -6,6 +6,7 @@ import * as DG from 'datagrok-api/dg';
 import wu from 'wu';
 
 import {before, after, category, test, expectArray, expect} from '@datagrok-libraries/utils/src/test';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
 import {ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
@@ -15,10 +16,9 @@ import {
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 
-import {toAtomicLevel} from '../package';
 import {_package} from '../package-test';
-import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 
 const appPath = 'System:AppData/Bio';
 const fileSource = new DG.FileSource(appPath);
@@ -60,13 +60,20 @@ category('toAtomicLevel', async () => {
   /** Backup actual user's monomer libraries settings */
   let userLibSettings: UserLibSettings;
 
+  let monomerLib: IMonomerLib;
+  let rdKitModule: RDModule;
+
   before(async () => {
+    rdKitModule = await getRdKitModule();
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
     // Clear settings to test default
     await setUserLibSettingsForTests();
+    await monomerLibHelper.awaitLoaded();
     await monomerLibHelper.loadMonomerLib(true);
 
+    monomerLib = monomerLibHelper.getMonomerLib();
+
     for (const [testName, testData] of Object.entries(TestsData)) {
       const inputPath = testData.inPath;
 
@@ -83,7 +90,8 @@ category('toAtomicLevel', async () => {
 
   async function getTestResult(source: DG.DataFrame, target: DG.DataFrame): Promise<void> {
     const inputCol = source.getCol(inputColName);
-    await toAtomicLevel(source, inputCol, false);
+    // await toAtomicLevel(source, inputCol, false);
+    await grok.functions.call('Bio:toAtomicLevel', {table: source, seqCol: inputCol, nonlinear: false});
     const obtainedCol = source.getCol(outputColName);
     const expectedCol = target.getCol(outputColName);
     const obtainedArray: string[] = wu(obtainedCol.values()).map((mol) => polishMolfile(mol)).toArray();
@@ -212,19 +220,18 @@ PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.Thr_PO3H2.Aca.Tyr
     const resCol = (await _testToAtomicLevel(srcDf, 'seq', monomerLibHelper))!;
     expect(polishMolfile(resCol.get(0)), polishMolfile(tgtMol));
   });
+
+  async function _testToAtomicLevel(
+    df: DG.DataFrame, seqColName: string = 'seq', monomerLibHelper: IMonomerLibHelper
+  ): Promise<DG.Column | null> {
+    const seqCol: DG.Column<string> = df.getCol(seqColName);
+    const res = await _toAtomicLevel(df, seqCol, monomerLib, rdKitModule);
+    if (res.warnings.length > 0)
+      _package.logger.warning(`_toAtomicLevel() warnings ${res.warnings.join('\n')}`);
+    return res.molCol;
+  }
 });
 
-async function _testToAtomicLevel(
-  df: DG.DataFrame, seqColName: string = 'seq', monomerLibHelper: IMonomerLibHelper
-): Promise<DG.Column | null> {
-  const rdKitModule = await getRdKitModule();
-  const seqCol: DG.Column<string> = df.getCol(seqColName);
-  const monomerLib: IMonomerLib = monomerLibHelper.getMonomerLib();
-  const res = await _toAtomicLevel(df, seqCol, monomerLib);
-  if (res.warnings.length > 0)
-    _package.logger.warning(`_toAtomicLevel() warnings ${res.warnings.join('\n')}`);
-  return res.col;
-}
 
 function polishMolfile(mol: string): string {
   return mol.replaceAll('\r\n', '\n')

package/src/tests/to-atomic-level-ui-tests.ts

@@ -4,28 +4,38 @@ import * as grok from 'datagrok-api/grok';
 import {after, before, category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
 import {sequenceToMolfile} from '../utils/sequence-to-mol';
-import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
-import {ConverterFunc} from './types';
-import {_package} from '../package';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+
+type TestDataTargetType = { atomCount: number, bondCount: number };
+type TestDataType = {
+  src: { seq: string, units: NOTATION },
+  tgt: TestDataTargetType,
+};
 
 category('toAtomicLevel-ui', () => {
 
   let monomerLibHelper: IMonomerLibHelper;
   let userLibSettings: UserLibSettings;
-  let helmHelper: IHelmHelper;
+  let monomerLib: IMonomerLib;
+  let rdKitModule: RDModule;
 
   before(async () => {
-    helmHelper = await getHelmHelper(); // init Helm package
+    rdKitModule = await getRdKitModule();
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
 
     // Test 'helm' requires default monomer library loaded
     await setUserLibSettingsForTests();
+    await monomerLibHelper.awaitLoaded();
     await monomerLibHelper.loadMonomerLib(true); // load default libraries
+
+    monomerLib = monomerLibHelper.getMonomerLib();
   });
 
   after(async () => {
@@ -33,42 +43,72 @@ category('toAtomicLevel-ui', () => {
     await setUserLibSettings(userLibSettings);
     await monomerLibHelper.loadMonomerLib(true); // load user settings libraries
   });
-  const fastaCsv = `seq
-MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW
-MIEVFLFGIVLGLIPITLAGLFVTAYLQYRRGDQLDL
-MMELVLKTIIGPIVVGVVLRIVDKWLNKDK
-`;
-  const helmCsv = `seq
-PEPTIDE1{meI.hHis.Aca.N.T.dK.Thr_PO3H2.Aca.D-Tyr_Et.Aze.dV.E.N.dV.Phe_4Me}$$$$
-PEPTIDE1{meI.hHis.Aca.N.T.dK.Thr_PO3H2.Aca.meM.D-Chg.dV.E.N.D-Orn.D-aThr.Phe_4Me}$$$$
-PEPTIDE1{meI.Aca.N.T.dK.Thr_PO3H2.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.D-Cit.N.D-Orn.D-aThr.Phe_4Me}$$$$
-`;
 
-  test('toAtomicLevel-fasta-linear', async () => {
-    const df = DG.DataFrame.fromCsv(fastaCsv);
-    await grok.data.detectSemanticTypes(df);
-    const seqCol = df.getCol('seq');
-    await _testToAtomicLevelFunc(df, seqCol, false);
-  });
+  const tests: { [testName: string]: TestDataType } = {
+    'fasta': {
+      src: {seq: 'MDYKETLLMPK', units: NOTATION.FASTA,},
+      tgt: {atomCount: 94, bondCount: 95,},
+    },
+    'fasta-with-gap': {
+      src: {seq: 'MD-YKETLLMPK', units: NOTATION.FASTA,},
+      tgt: {atomCount: 94, bondCount: 95,},
+    },
+    'helm': {
+      src: {seq: 'PEPTIDE1{meI.hHis.Aca.N.T.dK.Thr_PO3H2}$$$$', units: NOTATION.HELM,},
+      tgt: {atomCount: 68, bondCount: 68,},
+    },
+    'helm-with-gap': {
+      src: {seq: 'PEPTIDE1{meI.hHis.*.Aca.N.T.dK.Thr_PO3H2}$$$$', units: NOTATION.HELM,},
+      tgt: {atomCount: 68, bondCount: 68,},
+    },
+  };
 
-  test('toAtomicLevel-fasta-nonlinear', async () => {
-    const df = DG.DataFrame.fromCsv(fastaCsv);
-    await grok.data.detectSemanticTypes(df);
-    const seqCol = df.getCol('seq');
-    await _testToAtomicLevelFunc(df, seqCol, true);
-  });
+//   const fastaCsv = `seq
+// MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW
+// MIEVFLFGIVLGLIPITLAGLFVTAYLQYRRGDQLDL
+// MMELVLKTIIGPIVVGVVLRIVDKWLNKDK
+// `;
+//   const helmCsv = `seq
+// PEPTIDE1{meI.hHis.Aca.N.T.dK.Thr_PO3H2.Aca.D-Tyr_Et.Aze.dV.E.N.dV.Phe_4Me}$$$$
+// PEPTIDE1{meI.hHis.Aca.N.T.dK.Thr_PO3H2.Aca.meM.D-Chg.dV.E.N.D-Orn.D-aThr.Phe_4Me}$$$$
+// PEPTIDE1{meI.Aca.N.T.dK.Thr_PO3H2.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.D-Cit.N.D-Orn.D-aThr.Phe_4Me}$$$$
+// `;
 
-  test('toAtomicLevel-helm', async () => {
-    const df = DG.DataFrame.fromCsv(helmCsv);
+  const getSeqCol = async (testData: TestDataType): Promise<DG.Column<string>> => {
+    const seq = testData.src.seq;
+    const df = DG.DataFrame.fromColumns([DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'seq', [seq])]);
     await grok.data.detectSemanticTypes(df);
-    const seqCol = df.getCol('seq');
-    await _testToAtomicLevelFunc(df, seqCol, true);
-  });
+    return df.getCol('seq');
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}-linear`, async () => {
+      const seqCol = await getSeqCol(testData);
+      await _testToAtomicLevelFunc(seqCol, false, testData.tgt);
+    });
+  }
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}-nonlinear`, async () => {
+      const seqCol = await getSeqCol(testData);
+      await _testToAtomicLevelFunc(seqCol, true, testData.tgt);
+    }, {skipReason: 'To publish HelmHelper.removeGaps dependency'});
+  }
 
   async function _testToAtomicLevelFunc(
-    table: DG.DataFrame, seqCol: DG.Column<string>, nonlinear: boolean
+    seqCol: DG.Column<string>, nonlinear: boolean, tgt: TestDataTargetType,
   ): Promise<void> {
-    const molCol = await sequenceToMolfile(table, seqCol, nonlinear, monomerLibHelper.getMonomerLib());
-    expect(molCol!.semType, DG.SEMTYPE.MOLECULE);
+    const res = (await sequenceToMolfile(seqCol.dataFrame, seqCol, nonlinear, false, monomerLib, rdKitModule))!;
+    expect(res.molCol!.semType, DG.SEMTYPE.MOLECULE);
+    const resMolStr = res.molCol!.get(0)!;
+    const resRdMol = rdKitModule.get_mol(resMolStr);
+    expect(resRdMol != null, true, 'No molecule generated');
+    try {
+      const resAtomCount = resRdMol.get_num_atoms();
+      const resBondCount = resRdMol.get_num_bonds();
+      expect(resAtomCount, tgt.atomCount);
+      expect(resBondCount, tgt.bondCount);
+    } finally {
+      resRdMol.delete();
+    }
   }
 });