@datagrok/bio 2.11.42 → 2.12.1

package/src/tests/detectors-tests.ts

@@ -6,7 +6,7 @@ import {category, test, expect} from '@datagrok-libraries/utils/src/test';
 
 import {importFasta} from '../package';
 import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
 /*
 // snippet to list df columns of semType='Macromolecule' (false positive)
@@ -433,12 +433,12 @@ export async function _testPosList(list: string[], units: NOTATION,
   if (separator)
     expect(col.getTag(bioTAGS.separator), separator);
 
-  const uh = UnitsHandler.getOrCreate(col);
-  expect(uh.getAlphabetSize(), alphabetSize);
-  expect(uh.getAlphabetIsMultichar(), alphabetIsMultichar);
-  if (!uh.isHelm()) {
-    expect(uh.aligned, aligned);
-    expect(uh.alphabet, alphabet);
+  const sh = SeqHandler.forColumn(col);
+  expect(sh.getAlphabetSize(), alphabetSize);
+  expect(sh.getAlphabetIsMultichar(), alphabetIsMultichar);
+  if (!sh.isHelm()) {
+    expect(sh.aligned, aligned);
+    expect(sh.alphabet, alphabet);
   }
 }
 
@@ -461,12 +461,12 @@ export async function _testPos(
   if (separator)
     expect(col.getTag(bioTAGS.separator), separator);
 
-  const uh = UnitsHandler.getOrCreate(col);
-  expect(uh.getAlphabetSize(), alphabetSize);
-  expect(uh.getAlphabetIsMultichar(), alphabetIsMultichar);
-  if (!uh.isHelm()) {
-    expect(uh.aligned, aligned);
-    expect(uh.alphabet, alphabet);
+  const sh = SeqHandler.forColumn(col);
+  expect(sh.getAlphabetSize(), alphabetSize);
+  expect(sh.getAlphabetIsMultichar(), alphabetIsMultichar);
+  if (!sh.isHelm()) {
+    expect(sh.aligned, aligned);
+    expect(sh.alphabet, alphabet);
   }
 }
 

package/src/tests/fasta-export-tests.ts

@@ -4,7 +4,8 @@ import * as grok from 'datagrok-api/grok';
 
 import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
 import {saveAsFastaDo, wrapSequence} from '../utils/save-as-fasta';
-import {splitterAsFasta} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {NOTATION, splitterAsFasta} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
 type SaveAsFastaTestArgs = { srcCsv: string, idCols: string [], seqCol: string, lineWidth: number, tgtFasta: string };
 
@@ -87,10 +88,13 @@ MRGGL
   });
 
   function _testWrapSequence(testKey: string, lineWidth: number = 10) {
-    const splitter = splitterAsFasta;
-
     const srcSeq: string = wrapData[testKey].src;
-    const wrapRes: string[] = wrapSequence(srcSeq, splitter, lineWidth);
+    const col = DG.Column.fromStrings('src', [srcSeq]);
+    col.semType = DG.SEMTYPE.MACROMOLECULE;
+    col.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
+    const sh = SeqHandler.forColumn(col);
+    const srcSS = sh.getSplitted(0);
+    const wrapRes: string[] = wrapSequence(srcSS, lineWidth);
     const wrapTgt: string[] = wrapData[testKey].tgt;
 
     expectArray(wrapRes, wrapTgt);
@@ -100,6 +104,8 @@ MRGGL
     const df: DG.DataFrame = DG.DataFrame.fromCsv(args.srcCsv);
 
     const seqCol: DG.Column = df.getCol(args.seqCol);
+    seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    seqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
     const idCols: DG.Column[] = args.idCols.map((colName) => df.getCol(colName));
 
     const fastaRes: string = saveAsFastaDo(idCols, seqCol, args.lineWidth);

package/src/tests/mm-distance-tests.ts

@@ -3,7 +3,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {category, expect, test} from '@datagrok-libraries/utils/src/test';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {MmDistanceFunctionsNames, mmDistanceFunctions}
   from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 
@@ -42,20 +42,20 @@ ATCGAATCGA
 ATCGAATCGA`;
 
   test('protein-distance-function', async () => {
-    const uh = await _initMacromoleculeColumn(protTable);
-    const distFunc = uh.getDistanceFunctionName();
+    const sh = await _initMacromoleculeColumn(protTable);
+    const distFunc = sh.getDistanceFunctionName();
     expect(distFunc, MmDistanceFunctionsNames.LEVENSHTEIN);
   });
 
   test('DNA-distance-function', async () => {
-    const uh = await _initMacromoleculeColumn(DNATable);
-    const distFunc = uh.getDistanceFunctionName();
+    const sh = await _initMacromoleculeColumn(DNATable);
+    const distFunc = sh.getDistanceFunctionName();
     expect(distFunc, MmDistanceFunctionsNames.LEVENSHTEIN);
   });
 
   test('MSA-distance-function', async () => {
-    const uh = await _initMacromoleculeColumn(MSATable);
-    const distFunc = uh.getDistanceFunctionName();
+    const sh = await _initMacromoleculeColumn(MSATable);
+    const distFunc = sh.getDistanceFunctionName();
     expect(distFunc, MmDistanceFunctionsNames.HAMMING);
   });
 
@@ -125,7 +125,7 @@ ATCGAATCGA`;
   });
 });
 
-async function _initMacromoleculeColumn(csv: string): Promise<UnitsHandler> {
+async function _initMacromoleculeColumn(csv: string): Promise<SeqHandler> {
   const srcDf: DG.DataFrame = DG.DataFrame.fromCsv(csv);
   const seqCol = srcDf.col('seq')!;
   const semType: string = await grok.functions
@@ -133,8 +133,8 @@ async function _initMacromoleculeColumn(csv: string): Promise<UnitsHandler> {
   if (semType)
     seqCol.semType = semType;
   await grok.data.detectSemanticTypes(srcDf);
-  const uh = UnitsHandler.getOrCreate(seqCol);
-  return uh;
+  const sh = SeqHandler.forColumn(seqCol);
+  return sh;
 }
 
 function _testDistance(seq1: string, seq2: string, df: (a: string, b: string) => number, expected: number) {

package/src/tests/msa-tests.ts

@@ -103,13 +103,11 @@ MWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHP
 
 async function _testMsaIsCorrect(srcCsv: string, tgtCsv: string): Promise<void> {
   const srcDf: DG.DataFrame = DG.DataFrame.fromCsv(srcCsv);
+  await grok.data.detectSemanticTypes(srcDf);
   const tgtDf: DG.DataFrame = DG.DataFrame.fromCsv(tgtCsv);
 
   const srcCol: DG.Column = srcDf.getCol('seq')!;
-  const semType: string = await grok.functions
-    .call('Bio:detectMacromolecule', {col: srcCol}) as unknown as string;
-  if (semType)
-    srcCol.semType = semType;
+  expect(srcCol.semType, DG.SEMTYPE.MACROMOLECULE);
 
   const tgtCol: DG.Column = tgtDf.getCol('seq')!;
   const resCol: DG.Column = await runKalign(srcCol, true);
@@ -121,23 +119,18 @@ async function _testMSAOnColumn(
   srcNotation: NOTATION, tgtNotation: NOTATION, alphabet?: ALPHABET, pepseaMethod?: string,
 ): Promise<void> {
   const srcDf: DG.DataFrame = DG.DataFrame.fromCsv(srcCsv);
+  await grok.data.detectSemanticTypes(srcDf);
   const tgtDf: DG.DataFrame = DG.DataFrame.fromCsv(tgtCsv);
 
-  const srcSeqCol = srcDf.getCol('seq')!;
   const tgtCol = tgtDf.getCol('seq')!;
   const srcCol: DG.Column = srcDf.getCol('seq')!;
-  const semType: string = await grok.functions
-    .call('Bio:detectMacromolecule', {col: srcCol}) as unknown as string;
-  if (semType)
-    srcCol.semType = semType;
-
-  await grok.data.detectSemanticTypes(srcDf);
-  expect(srcSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
-  expect(srcSeqCol.getTag(DG.TAGS.UNITS), srcNotation);
+  expect(srcCol.semType, DG.SEMTYPE.MACROMOLECULE);
+  expect(srcCol.getTag(DG.TAGS.UNITS), srcNotation);
   if (alphabet)
-    expect(srcSeqCol.getTag(bioTAGS.alphabet), alphabet);
+    expect(srcCol.getTag(bioTAGS.alphabet), alphabet);
 
-  const msaSeqCol = await multipleSequenceAlignmentUI({col: srcSeqCol, pepsea: {method: pepseaMethod}});
+  const msaSeqCol = await multipleSequenceAlignmentUI({col: srcCol, pepsea: {method: pepseaMethod}});
+  expect(msaSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
   expect(msaSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
   expect(msaSeqCol.getTag(DG.TAGS.UNITS), tgtNotation);
   expect(msaSeqCol.getTag(bioTAGS.aligned), ALIGNMENT.SEQ_MSA);

package/src/tests/renderers-monomer-placer.ts

@@ -6,7 +6,7 @@ import wu from 'wu';
 import {category, test} from '@datagrok-libraries/utils/src/test';
 import {MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
 import {monomerToShort} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
 import {_package} from '../package-test';
 
@@ -93,9 +93,9 @@ id3,QHIRE--LT
       const charWidth: number = 7;
       const sepWidth: number = 12;
       const colTemp: MonomerPlacer = new MonomerPlacer(null, seqCol, () => {
-        const uh = UnitsHandler.getOrCreate(seqCol);
+        const sh = SeqHandler.forColumn(seqCol);
         return {
-          unitsHandler: uh,
+          seqHandler: sh,
           monomerCharWidth: charWidth,
           separatorWidth: sepWidth,
           monomerToShort: monomerToShort,

package/src/tests/renderers-test.ts

@@ -1,11 +1,9 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-import $ from 'cash-dom';
-
-import {category, expect, test, awaitCheck, delay} from '@datagrok-libraries/utils/src/test';
+import {category, expect, test, delay} from '@datagrok-libraries/utils/src/test';
 import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
 import {importFasta} from '../package';
 import {convertDo} from '../utils/convert';
@@ -148,8 +146,8 @@ category('renderers', () => {
     expect(msaSeqCol.getTag(bioTAGS.alphabet), ALPHABET.PT);
     expect(msaSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
 
-    // check newColumn with UnitsHandler constructor
-    const _uh: UnitsHandler = UnitsHandler.getOrCreate(msaSeqCol);
+    // check newColumn with SeqHandler constructor
+    const _sh: SeqHandler = SeqHandler.forColumn(msaSeqCol);
   }
 
   async function _testAfterConvert() {
@@ -172,8 +170,8 @@ category('renderers', () => {
     const resCellRenderer = tgtCol.getTag(DG.TAGS.CELL_RENDERER);
     expect(resCellRenderer, 'sequence');
 
-    // check tgtCol with UnitsHandler constructor
-    const _uh: UnitsHandler = UnitsHandler.getOrCreate(tgtCol);
+    // check tgtCol with SeqHandler constructor
+    const _sh: SeqHandler = SeqHandler.forColumn(tgtCol);
   }
 
   async function _selectRendererBySemType() {

package/src/tests/splitters-test.ts

@@ -2,22 +2,23 @@ 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';
+
 import {
-  after, before, category, test, expect, expectArray, delay, awaitCheck
+  after, before, category, test, expect, expectArray
 } from '@datagrok-libraries/utils/src/test';
-import {
-  TAGS as bioTAGS,
-  splitterAsFasta,
-  splitterAsHelm,
-  NOTATION
-} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {TAGS as bioTAGS, splitterAsFasta} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 import {splitToMonomersUI} from '../utils/split-to-monomers';
 import {awaitGrid} from './utils';
 import * as C from '../utils/constants';
-
 import {getHelmMonomers} from '../package';
 
+import {splitterAsHelm} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
+import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+
+import {_package} from '../package-test';
+
 category('splitters', async () => {
   before(async () => {
   });
@@ -132,7 +133,7 @@ PEPTIDE1{hHis.Aca.Cys_SEt}$$$,5.72388
   });
 
   // test('helmAsFasta', async () => {
-  //   // The columns can't be empty for UnitsHandler
+  //   // The columns can't be empty for SeqHandler
   //   /* eslint-disable max-len */
   //   const srcSeq = '[meI][Pip][dK][Thr_PO3H2][L-hArg(Et,Et)][D-Tyr_Et][Tyr_ab-dehydroMe][dV]EN[D-Orn][D-aThr][Phe_4Me]';
   //   const tgtSeqA = ['meI', 'Pip', 'dK', 'Thr_PO3H2', 'L-hArg(Et,Et)', 'D-Tyr_Et', 'Tyr_ab-dehydroMe', 'dV', 'E', 'N', 'D-Orn', 'D-aThr', 'Phe_4Me'];
@@ -143,13 +144,13 @@ PEPTIDE1{hHis.Aca.Cys_SEt}$$$,5.72388
 });
 
 export async function _testFastaSplitter(src: string, tgt: string[]) {
-  const res: string[] = splitterAsFasta(src);
+  const res: ISeqSplitted = splitterAsFasta(src);
   console.debug(`Bio: tests: splitters: src=${JSON.stringify(src)}, res=${JSON.stringify(res)} .`);
-  expectArray(res, tgt);
+  expectArray(wu(res.originals).toArray(), tgt);
 }
 
 export async function _testHelmSplitter(src: string, tgt: string[]) {
-  const res: string[] = splitterAsHelm(src);
+  const res: ISeqSplitted = splitterAsHelm(src);
   console.debug(`Bio: tests: splitters: src=${JSON.stringify(src)}, res=${JSON.stringify(res)} .`);
-  expectArray(res, tgt);
+  expectArray(wu(res.originals).toArray(), tgt);
 }

package/src/tests/substructure-filters-tests.ts

@@ -2,6 +2,10 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+import $ from 'cash-dom';
+import wu from 'wu';
+
+
 import {after, before, category, test, expect, delay, testEvent, awaitCheck} from '@datagrok-libraries/utils/src/test';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
@@ -19,7 +23,7 @@ import {HelmBioFilter} from '../widgets/bio-substructure-filter-helm';
 import {_package} from '../package-test';
 
 
-category('substructureFilters', async () => {
+category('bio-substructure-filters', async () => {
   let monomerLibHelper: IMonomerLibHelper;
   /** Backup actual user's monomer libraries settings */
   let userLibSettings: UserLibSettings;
@@ -305,6 +309,144 @@ category('substructureFilters', async () => {
     await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
     await awaitGrid(view.grid);
   });
+
+  // two seq columns
+
+  const twoColumnsCsv: string = `id,seq1,seq2,trueSeq1,trueSeq2
+0,CGGCTACGGC,ATTGCATTCG,0,1,
+1,CGGCTGCCGC,ATAGCATTCG,1,1,
+2,CGGCTGCGCC,AATGCATACG,1,0,
+3,CGGCTGCATT,TTTGCATTCG,1,1,
+4,CGGCTGCATT,AAAGCATACG,1,0,
+`;
+
+  test('two-columns-fasta', async () => {
+    const df = DG.DataFrame.fromCsv(twoColumnsCsv);
+    await grok.data.detectSemanticTypes(df);
+    const view = grok.shell.addTableView(df);
+
+    const fSeq1ColName: string = 'seq1';
+    const fSeq1SubStr: string = 'CGGCTG';
+    const fSeq1Trues: number[] = df.getCol('trueSeq1').toList();
+
+    const fSeq2ColName: string = 'seq2';
+    const fSeq2SubStr: string = 'GCATT';
+    const fSeq2Trues: number[] = df.getCol('trueSeq2').toList();
+
+    //const seq2Filter = new BioSubstructureFilter();
+    const filterList: any[] = [
+      {type: 'Bio:bioSubstructureFilter', columnName: fSeq1ColName},
+      {type: 'Bio:bioSubstructureFilter', columnName: fSeq2ColName},
+    ];
+    const fg = (await df.plot.fromType(DG.VIEWER.FILTERS,
+      {filters: filterList})) as DG.FilterGroup;
+    view.dockManager.dock(fg, DG.DOCK_TYPE.LEFT);
+    await delay(100);
+    await awaitGrid(view.grid);
+
+    const seq1Filter = fg.filters[0] as BioSubstructureFilter;
+    const seq2Filter = fg.filters[1] as BioSubstructureFilter;
+    expect(seq1Filter.column!.name, fSeq1ColName);
+    expect(seq2Filter.column!.name, fSeq2ColName);
+
+    const seq1Bf = seq1Filter.bioFilter as FastaBioFilter;
+    const seq2Bf = seq2Filter.bioFilter as FastaBioFilter;
+
+    await testEvent(df.onRowsFiltered, () => {}, () => {
+      seq1Bf.props = new BioFilterProps(fSeq1SubStr);
+    }, 1000);
+    await testEvent(df.onRowsFiltered, () => {}, () => {
+      seq2Bf.props = new BioFilterProps('');
+    }, 1000, 'testEvent onRowsFiltered on seq1');
+    expect(df.filter.trueCount, fSeq1Trues.filter((v) => v === 1).length);
+    expect(df.filter.toBinaryString(), fSeq1Trues.map((v) => v.toString()).join(''));
+
+    await testEvent(df.onRowsFiltered, () => {}, () => {
+      seq1Bf.props = new BioFilterProps('');
+    }, 1000);
+    await testEvent(df.onRowsFiltered, () => {}, () => {
+      seq2Bf.props = new BioFilterProps(fSeq2SubStr);
+    }, 1000, 'testEvent onRowsFiltered on seq2');
+    expect(df.filter.trueCount, fSeq2Trues.filter((v) => v === 1).length);
+    expect(df.filter.toBinaryString(), fSeq2Trues.map((v) => v.toString()).join(''));
+
+    await testEvent(df.onRowsFiltered, () => {}, () => {
+      seq1Bf.props = new BioFilterProps('');
+    }, 1000);
+    await testEvent(df.onRowsFiltered, () => {}, () => {
+      seq2Bf.props = new BioFilterProps('');
+    }, 1000, 'testEvent onRowsFiltered on neither');
+    expect(df.filter.trueCount, df.rowCount);
+
+    await testEvent(df.onRowsFiltered, () => {}, () => {
+      seq1Bf.props = new BioFilterProps(fSeq1SubStr);
+    }, 5000);
+    await testEvent(df.onRowsFiltered, () => {}, () => {
+      seq2Bf.props = new BioFilterProps(fSeq2SubStr);
+    }, 5000, 'testEvent onRowsFiltered on both');
+    const bothTrues: number[] = wu.count(0).take(df.rowCount)
+      .map((rowI) => fSeq1Trues[rowI] * fSeq2Trues[rowI]).toArray();
+    expect(df.filter.trueCount, bothTrues.filter((v) => v === 1).length);
+    expect(df.filter.toBinaryString(), bothTrues.map((v) => v.toString()).join(''));
+
+    await Promise.all([seq1Filter.awaitRendered(), seq2Filter.awaitRendered(), awaitGrid(view.grid)]);
+  });
+
+  // -- reset --
+
+  test('reset-fasta', async () => {
+    const df = await readDataframe('tests/filter_FASTA.csv');
+    await grok.data.detectSemanticTypes(df);
+    const view = grok.shell.addTableView(df);
+
+    const fSeqColName: string = 'fasta';
+    const fSubStr: string = 'MD';
+    const fTrueCount: number = 3;
+
+    const filterList = [{type: 'Bio:bioSubstructureFilter', columnName: fSeqColName}];
+    const fg = (await df.plot.fromType(DG.VIEWER.FILTERS,
+      {filters: filterList})) as DG.FilterGroup;
+    view.dockManager.dock(fg, DG.DOCK_TYPE.LEFT);
+    await delay(100);
+    await awaitGrid(view.grid);
+
+    const seqFilter = fg.filters[0] as BioSubstructureFilter;
+    const seqBf = seqFilter.bioFilter as FastaBioFilter;
+    await testEvent(df.onRowsFiltered, () => {}, () => {
+      seqBf.props = new BioFilterProps(fSubStr);
+    }, 1000, 'testEvent onRowsFiltered');
+    expect(df.filter.trueCount, fTrueCount);
+    expect(seqBf.props.substructure, fSubStr);
+    expect(seqBf.substructureInput.value, fSubStr);
+
+    const fgResetIconEl: HTMLElement = $(fg.root).find('i[name="icon-arrow-rotate-left"]')[0] as HTMLElement;
+    fgResetIconEl.click();
+    await delay(100);
+    await awaitGrid(view.grid);
+    expect(seqBf.props.substructure, '');
+    expect(seqBf.substructureInput.value, '');
+  });
+
+  test('reopen', async () => {
+    const df = await _package.files.readCsv('tests/filter_FASTA.csv');
+    const view = grok.shell.addTableView(df);
+
+    const filterList = [{type: 'Bio:bioSubstructureFilter', columnName: 'fasta'}];
+
+    const fg1 = (await df.plot.fromType(DG.VIEWER.FILTERS,
+      {filters: filterList})) as DG.FilterGroup;
+    const fg1Dn = view.dockManager.dock(fg1, DG.DOCK_TYPE.LEFT);
+    await delay(100);
+    await awaitGrid(view.grid);
+    fg1.close();
+    await awaitGrid(view.grid);
+
+    const fg2 = (await df.plot.fromType(DG.VIEWER.FILTERS,
+      {filters: filterList})) as DG.FilterGroup;
+    const fg2Dn = view.dockManager.dock(fg2, DG.DOCK_TYPE.LEFT);
+    await delay(100);
+    await awaitGrid(view.grid);
+  });
 });
 
 async function createFilter(colName: string, df: DG.DataFrame): Promise<BioSubstructureFilter> {

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

@@ -14,7 +14,7 @@ import {
   getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
 import {toAtomicLevel} from '../package';
 import {_package} from '../package-test';
@@ -198,7 +198,7 @@ PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.Thr_PO3H2.Aca.Tyr
     seqCol.semType = DG.SEMTYPE.MACROMOLECULE;
     seqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
     seqCol.setTag(bioTAGS.alphabet, ALPHABET.PT);
-    const uh = UnitsHandler.getOrCreate(seqCol);
+    const sh = SeqHandler.forColumn(seqCol);
     const resCol = (await _testToAtomicLevel(srcDf, 'seq', monomerLibHelper))!;
     expect(polishMolfile(resCol.get(0)), polishMolfile(tgtMol));
   });

package/src/tests/units-handler-get-region.ts

@@ -2,10 +2,10 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
 import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {ALPHABET, NOTATION, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
-category('UnitsHandler: getRegion', () => {
+category('SeqHandler: getRegion', () => {
   const data: {
     [testName: string]: {
       srcCsv: string,
@@ -76,8 +76,8 @@ PEPTIDE1{[Cys_SEt].T.*.*}$$$$`,
       const semType: string | null = await grok.functions.call('Bio:detectMacromolecule', {col: srcSeqCol});
       if (semType) srcSeqCol.semType = semType;
 
-      const srcUh = UnitsHandler.getOrCreate(srcSeqCol);
-      const resSeqCol = srcUh.getRegion(testData.startIdx, testData.endIdx, 'regSeq');
+      const srcSh = SeqHandler.forColumn(srcSeqCol);
+      const resSeqCol = srcSh.getRegion(testData.startIdx, testData.endIdx, 'regSeq');
 
       const tgtDf = DG.DataFrame.fromCsv(testData.tgtCsv);
       const tgtSeqCol = tgtDf.getCol('seq');

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

@@ -1,10 +1,11 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
+import wu from 'wu';
+
 import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
-import {GapSymbols, UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {GapOriginals, SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 
 enum Tests {
   fasta = 'fasta',
@@ -14,10 +15,10 @@ enum Tests {
   helm = 'helm',
 }
 
-category('UnitsHandler', () => {
-  const fG = GapSymbols[NOTATION.FASTA];
-  const hG = GapSymbols[NOTATION.HELM];
-  const sG = GapSymbols[NOTATION.SEPARATOR];
+category('SeqHandler', () => {
+  const fG = GapOriginals[NOTATION.FASTA];
+  const hG = GapOriginals[NOTATION.HELM];
+  const sG = GapOriginals[NOTATION.SEPARATOR];
   const data: {
     [testName: string]: {
       src: { csv: string },
@@ -34,9 +35,9 @@ TTCAACTTCAAC`
       tgt: {
         notation: NOTATION.FASTA,
         splitted: [
-          'ACGTCACGTC',
-          'CAGTGTCAGTGT',
-          'TTCAACTTCAAC',
+          ['A', 'C', 'G', 'T', 'C', 'A', 'C', 'G', 'T', 'C'],
+          ['C', 'A', 'G', 'T', 'G', 'T', 'C', 'A', 'G', 'T', 'G', 'T'],
+          ['T', 'T', 'C', 'A', 'A', 'C', 'T', 'T', 'C', 'A', 'A', 'C'],
         ]
       }
     },
@@ -51,9 +52,9 @@ ACCGTACTACCGTACT`,
         notation: NOTATION.FASTA,
         splitted: [
           //@formatter:off
-          'AC-GT-CTAC-GT-CT',
-          'CAC-T-GTCAC-T-GT',
-          'ACCGTACTACCGTACT',
+          ['A', 'C', '-', 'G', 'T', '-', 'C', 'T', 'A', 'C', '-', 'G', 'T', '-', 'C', 'T'],
+          ['C', 'A', 'C', '-', 'T', '-', 'G', 'T', 'C', 'A', 'C', '-', 'T', '-', 'G', 'T'],
+          ['A', 'C', 'C', 'G', 'T', 'A', 'C', 'T', 'A', 'C', 'C', 'G', 'T', 'A', 'C', 'T'],
           //@formatter:on
         ]
       }
@@ -129,12 +130,13 @@ PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.T.dK.Thr_PO3H2}$$$$`
       if (semType) col.semType = semType;
       expect(col.semType, DG.SEMTYPE.MACROMOLECULE);
 
-      const uh = UnitsHandler.getOrCreate(col);
-      expect(uh.notation, testData.tgt.notation);
-      expect(uh.separator === testData.tgt.separator, true);
+      const sh = SeqHandler.forColumn(col);
+      expect(sh.notation, testData.tgt.notation);
+      expect(sh.separator === testData.tgt.separator, true);
 
-      const resSplitted: ISeqSplitted[] = uh.splitted;
+      const resSplitted: string[][] = wu.count(0).take(sh.length)
+        .map((rowIdx) => wu(sh.getSplitted(rowIdx).originals).toArray()).toArray();
       expectArray(resSplitted, testData.tgt.splitted);
-    }, testName == Tests.separatorMsa ? {skipReason: '#2468 CSV row starting with the quote character'} : undefined);
+    });
   }
 });