@datagrok/bio 2.11.42 → 2.12.0

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/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);
+    });
   }
 });

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

@@ -3,8 +3,8 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {category, test, expect} from '@datagrok-libraries/utils/src/test';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
-import {ALPHABET, NOTATION, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 const seqDna = `seq
 ACGTCACGTC
@@ -27,67 +27,67 @@ PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.D-Chg.dV.Phe_ab-dehyd
 PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.D-Chg.dV.Thr_PO3H2.N.D-Orn.D-aThr.Phe_4Me}$$$$
 PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.D-Chg.dV.Thr_PO3H2.N.D-Orn.D-aThr.Phe_4Me}$$$$`;
 
-category('UnitsHandler', () => {
+category('SeqHandler', () => {
   test('Seq-Fasta', async () => {
-    const [_df, uh] = await loadCsvWithDetection(seqDna);
-    expect(uh.notation, NOTATION.FASTA);
-    expect(uh.isMsa(), false);
+    const [_df, sh] = await loadCsvWithDetection(seqDna);
+    expect(sh.notation, NOTATION.FASTA);
+    expect(sh.isMsa(), false);
   });
 
   test('Seq-Fasta-MSA', async () => {
-    const [_df, uh] = await loadCsvWithDetection(seqDnaMsa);
-    expect(uh.notation, NOTATION.FASTA);
-    expect(uh.isMsa(), true);
+    const [_df, sh] = await loadCsvWithDetection(seqDnaMsa);
+    expect(sh.notation, NOTATION.FASTA);
+    expect(sh.isMsa(), true);
   });
 
   test('Seq-Fasta-units', async () => {
-    const [_df, uh] = await loadCsvWithDetection(seqDna);
-    expect(uh.notation, NOTATION.FASTA);
-    expect(uh.isMsa(), false);
+    const [_df, sh] = await loadCsvWithDetection(seqDna);
+    expect(sh.notation, NOTATION.FASTA);
+    expect(sh.isMsa(), false);
   });
 
   test('Seq-Fasta-MSA-units', async () => {
-    const [_df, uh] = await loadCsvWithDetection(seqDnaMsa);
-    expect(uh.notation, NOTATION.FASTA);
-    expect(uh.isMsa(), true);
+    const [_df, sh] = await loadCsvWithDetection(seqDnaMsa);
+    expect(sh.notation, NOTATION.FASTA);
+    expect(sh.isMsa(), true);
   });
 
   test('Seq-Helm', async () => {
-    const [_df, uh] = await loadCsvWithDetection(seqHelm);
-    expect(uh.notation, NOTATION.HELM);
-    expect(uh.isHelm(), true);
+    const [_df, sh] = await loadCsvWithDetection(seqHelm);
+    expect(sh.notation, NOTATION.HELM);
+    expect(sh.isHelm(), true);
   });
 
   test('Seq-UN', async () => {
-    const [_df, uh] = await loadCsvWithDetection(seqUn);
-    expect(uh.notation, NOTATION.SEPARATOR);
-    expect(uh.separator, '-');
-    expect(uh.alphabet, ALPHABET.UN);
+    const [_df, sh] = await loadCsvWithDetection(seqUn);
+    expect(sh.notation, NOTATION.SEPARATOR);
+    expect(sh.separator, '-');
+    expect(sh.alphabet, ALPHABET.UN);
   });
 
   test('Seq-UN-auto', async () => {
-    const [_df, uh] = await loadCsvWithDetection(seqUn);
-    expect(uh.notation, NOTATION.SEPARATOR);
-    expect(uh.separator, '-');
-    expect(uh.alphabet, ALPHABET.UN);
+    const [_df, sh] = await loadCsvWithDetection(seqUn);
+    expect(sh.notation, NOTATION.SEPARATOR);
+    expect(sh.separator, '-');
+    expect(sh.alphabet, ALPHABET.UN);
   });
 
-  async function loadCsvWithDetection(csv: string): Promise<[df: DG.DataFrame, uh: UnitsHandler]> {
+  async function loadCsvWithDetection(csv: string): Promise<[df: DG.DataFrame, sh: SeqHandler]> {
     const df = DG.DataFrame.fromCsv(csv);
     await grok.data.detectSemanticTypes(df);
-    const uh = UnitsHandler.getOrCreate(df.getCol('seq'));
-    return [df, uh];
+    const sh = SeqHandler.forColumn(df.getCol('seq'));
+    return [df, sh];
   }
 
   // async function loadCsvWithTag(csv: string, tag: string, value: string):
-  //   Promise<[df: DG.DataFrame, uh: UnitsHandler]> {
+  //   Promise<[df: DG.DataFrame, uh: SeqHandler]> {
   //   const df = DG.DataFrame.fromCsv(csv);
   //   const col = df.getCol('seq');
   //   col.setTag(tag, value);
   //   col.semType = DG.SEMTYPE.MACROMOLECULE;
   //   if (value === NOTATION.SEPARATOR)
   //     col.setTag(TAGS.separator, '-');
-  //   const uh = UnitsHandler.getOrCreate(df.getCol('seq'));
-  //   return [df, uh];
+  //   const sh = SeqHandler.forColumn(df.getCol('seq'));
+  //   return [df, sh];
   // }
 });