@datagrok/bio 1.7.22 → 1.7.25

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@datagrok/bio",
-  "beta": false,
   "friendlyName": "Bio",
-  "version": "1.7.22",
+  "author": {
+    "name": "Leonid Stolbov",
+    "email": "lstolbov@datagrok.ai"
+  },
+  "version": "1.7.25",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",
@@ -11,9 +14,9 @@
   },
   "dependencies": {
     "@biowasm/aioli": ">=2.4.0",
-    "@datagrok-libraries/bio": "^3.0.0",
-    "@datagrok-libraries/ml": "^3.0.0",
-    "@datagrok-libraries/utils": "^1.4.0",
+    "@datagrok-libraries/bio": "^3.0.4",
+    "@datagrok-libraries/ml": "^3.0.3",
+    "@datagrok-libraries/utils": "^1.5.4",
     "cash-dom": "latest",
     "datagrok-api": "^1.5.0",
     "dayjs": "^1.11.4",
@@ -33,7 +36,11 @@
     "puppeteer": "^13.7.0",
     "ts-jest": "^27.0.0",
     "webpack": "latest",
-    "webpack-cli": "^4.10.0"
+    "webpack-cli": "^4.10.0",
+    "@types/js-yaml": "^4.0.5",
+    "js-yaml": "^4.1.0",
+    "@types/node-fetch": "^2.6.2",
+    "node-fetch": "^2.6.7"
   },
   "scripts": {
     "link-api": "npm link datagrok-api",

package/{setup → setup.sh}

@@ -1,6 +1,6 @@
 #!/bin/bash
 
-./setup-unlink-clean
+./setup-unlink-clean.sh
 
 GREEN='\e[0;32m'
 NO_COLOR='\e[0m'

package/src/__jest__/remote.test.ts

@@ -5,7 +5,7 @@
 import * as utils from './test-node';
 import puppeteer from 'puppeteer';
 
-const P_START_TIMEOUT: number = 500000;
+const P_START_TIMEOUT: number = 3600000;
 let browser: puppeteer.Browser;
 let page: puppeteer.Page;
 
@@ -51,10 +51,10 @@ it('TEST', async () => {
         let failReport = '';
         for (let i = 0; i < df.rowCount; i++) {
           if (cStatus.get(i)) {
-            passReport += `Test result : ${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
+            passReport += `Test result : Success : ${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
           } else {
             failed = true;
-            failReport += `Test result : ${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
+            failReport += `Test result : Failed : ${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
           }
         }
         resolve({failReport, passReport, failed});
@@ -65,4 +65,4 @@ it('TEST', async () => {
   console.log(r.passReport);
   // @ts-ignore
   expect(r.failed).checkOutput(false, r.failReport);
-}, 500000);
+}, 3600000);

package/src/__jest__/test-node.ts

@@ -68,6 +68,7 @@ export async function getBrowserPage(puppeteer: any): Promise<{ browser: any, pa
   });
 
   const page = await browser.newPage();
+  await page.setDefaultNavigationTimeout(0);
   await page.goto(`${url}/oauth/`);
   await page.setCookie({name: 'auth', value: token});
   await page.evaluate((token: any) => {
@@ -75,8 +76,8 @@ export async function getBrowserPage(puppeteer: any): Promise<{ browser: any, pa
   }, token);
   await page.goto(url);
   try {
-    await page.waitForSelector('.grok-preloader');
-    await page.waitForFunction(() => document.querySelector('.grok-preloader') == null, {timeout: 500000});
+    await page.waitForSelector('.grok-preloader', { timeout: 1800000 });
+    await page.waitForFunction(() => document.querySelector('.grok-preloader') == null, {timeout: 3600000});
   } catch (error) {
     throw error;
   }

package/src/package-test.ts

@@ -11,6 +11,7 @@ import './tests/activity-cliffs-tests';
 import './tests/splitters-test';
 import './tests/renderers-test';
 import './tests/convert-test';
+import './tests/fasta-handler-test';
 import './tests/WebLogo-positions-test';
 
 export const _package = new DG.Package();
@@ -21,7 +22,6 @@ export {tests};
 //input: string category {optional: true}
 //input: string test {optional: true}
 //output: dataframe result
-//top-menu: Tools | Dev | JS API Tests
 export async function test(category: string, test: string): Promise<DG.DataFrame> {
   const data = await runTests({category, test});
   return DG.DataFrame.fromObjects(data)!;

package/src/package.ts

@@ -5,7 +5,7 @@ import * as DG from 'datagrok-api/dg';
 
 export const _package = new DG.Package();
 
-import {AlignedSequenceDifferenceCellRenderer, AminoAcidsCellRenderer} from './utils/cell-renderer';
+import {MacromoleculeDifferenceCellRenderer, MonomerCellRenderer} from './utils/cell-renderer';
 import {WebLogo, SeqColStats} from '@datagrok-libraries/bio/src/viewers/web-logo';
 import {VdRegionsViewer} from './viewers/vd-regions-viewer';
 import {runKalign, testMSAEnoughMemory} from './utils/multiple-sequence-alignment';
@@ -20,37 +20,27 @@ import {createJsonMonomerLibFromSdf, encodeMonomers, getMolfilesFromSeq, HELM_CO
 import {getMacroMol} from './utils/atomic-works';
 import {MacromoleculeSequenceCellRenderer} from './utils/cell-renderer';
 import {convert} from './utils/convert';
-import {lru} from './utils/cell-renderer';
 import {representationsWidget} from './widgets/representations';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
+import {removeEmptyStringRows} from '@datagrok-libraries/utils/src/dataframe-utils'
 
 
-//tags: init
-export async function initBio(): Promise<void> {
-  // apparently HELMWebEditor requires dojo to be initialized first
-  const funcList: DG.Func[] = DG.Func.find({package: 'Helm', name: 'initHelm'});
-  console.debug(`Bio: initBio() funcList.length = ${funcList.length}`);
-  if (funcList.length === 1)
-    await grok.functions.call('Helm:initHelp');
-
-  return new Promise((resolve, reject) => {
-    // @ts-ignore
-    dojo.ready(function() { resolve(null); });
-  });
-}
-
-//name: Lru
-//output: object lruCache
-export function Lru() {
-  return lru;
+//name: fastaSequenceCellRenderer
+//tags: cellRenderer
+//meta.cellType: Sequence
+//meta.columnTags: units=fasta
+//output: grid_cell_renderer result
+export function fastaSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
+  return new MacromoleculeSequenceCellRenderer();
 }
 
-//name: macromoleculeSequenceCellRenderer
+//name: separatorSequenceCellRenderer
 //tags: cellRenderer
-//meta.cellType: Macromolecule
+//meta.cellType: Sequence
+//meta.columnTags: units=separator
 //output: grid_cell_renderer result
-export function macromoleculeSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
+export function separatorSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
   return new MacromoleculeSequenceCellRenderer();
 }
 
@@ -161,16 +151,22 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
   if (!encodedCol)
     return;
   const embedColsNames = getEmbeddingColsNames(table);
+  const withoutEmptyValues = DG.DataFrame.fromColumns([macroMolecule]).clone();
+  const emptyValsIdxs = removeEmptyStringRows(withoutEmptyValues, encodedCol);
+
   const chemSpaceParams = {
-    seqCol: encodedCol,
+    seqCol: withoutEmptyValues.col(macroMolecule.name)!,
     methodName: methodName,
     similarityMetric: similarityMetric,
     embedAxesNames: embedColsNames
   };
   const sequenceSpaceRes = await sequenceSpace(chemSpaceParams);
   const embeddings = sequenceSpaceRes.coordinates;
-  for (const col of embeddings)
-    table.columns.add(col);
+  for (const col of embeddings) {
+      const listValues = col.toList();
+      emptyValsIdxs.forEach((ind: number) => listValues.splice(ind, 0, null));
+      table.columns.add(DG.Column.fromFloat32Array(col.name, listValues));
+  }   
   if (plotEmbeddings) {
     for (const v of grok.shell.views) {
       if (v.name === table.name)
@@ -241,6 +237,14 @@ export async function multipleSequenceAlignmentAny(table: DG.DataFrame, col: DG.
   return msaCol;
 }
 
+//name: Bio | MSA
+//tags: bio, panel
+//input: column sequence { semType: Macromolecule }
+//output: column result
+export async function panelMSA(col: DG.Column): Promise<DG.Column | null> {
+  return multipleSequenceAlignmentAny(col.dataFrame, col);
+}
+
 //name: Composition Analysis
 //top-menu: Bio | Composition Analysis
 //output: viewer result
@@ -334,20 +338,20 @@ export function convertPanel(col: DG.Column): void {
   convert(col);
 }
 
-//name: aminoAcidsCellRenderer
+//name: monomerCellRenderer
 //tags: cellRenderer
-//meta.cellType: aminoAcids
+//meta.cellType: Monomer
 //output: grid_cell_renderer result
-export function aminoAcidsCellRenderer(): AminoAcidsCellRenderer {
-  return new AminoAcidsCellRenderer();
+export function monomerCellRenderer(): MonomerCellRenderer {
+  return new MonomerCellRenderer();
 }
 
-//name: alignedSequenceDifferenceCellRenderer
+//name: MacromoleculeDifferenceCellRenderer
 //tags: cellRenderer
-//meta.cellType: alignedSequenceDifference
+//meta.cellType: MacromoleculeDifference
 //output: grid_cell_renderer result
-export function alignedSequenceDifferenceCellRenderer(): AlignedSequenceDifferenceCellRenderer {
-  return new AlignedSequenceDifferenceCellRenderer();
+export function macromoleculeDifferenceCellRenderer(): MacromoleculeDifferenceCellRenderer {
+  return new MacromoleculeDifferenceCellRenderer();
 }
 
 //name: testDetectMacromolecule

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

@@ -4,10 +4,12 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {PositionInfo, PositionMonomerInfo, WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
+import {Column} from 'datagrok-api/dg';
 
 category('WebLogo-positions', () => {
   let tvList: DG.TableView[];
   let dfList: DG.DataFrame[];
+  let currentView: DG.View;
 
   const csvDf1 = `seq
     ATC-G-TTGC--
@@ -17,22 +19,24 @@ category('WebLogo-positions', () => {
     -TC-GCTTGC--`;
 
 
-  const resShrinkEmptyTailDf1: PositionInfo[] = [];
-
   before(async () => {
     tvList = [];
     dfList = [];
+    currentView = grok.shell.tv;
   });
 
   after(async () => {
-    dfList.forEach((df: DG.DataFrame) => { grok.shell.closeTable(df); });
+    dfList.forEach((df: DG.DataFrame) => { grok.shell.closeTable(df);});
     tvList.forEach((tv: DG.TableView) => tv.close());
+    currentView = grok.shell.tv;
   });
-
   test('allPositions', async () => {
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf1);
     const tv: DG.TableView = grok.shell.addTableView(df);
 
+    df.getCol('seq').semType = 'Macromolecule';
+    df.getCol('seq').setTag('units', 'fasta:SEQ.MSA:DNA');
+
     const wlViewer: WebLogo = await df.plot.fromType('WebLogo') as unknown as WebLogo;
     tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
 
@@ -55,12 +59,102 @@ category('WebLogo-positions', () => {
       new PositionInfo('11', {'-': new PositionMonomerInfo(5)}),
       new PositionInfo('12', {'-': new PositionMonomerInfo(5)})
     ];
-    // check all positions are equal resAllDf1
+
+    expect(positions.length, resAllDf1.length);
+
+    for (let i = 0; i < positions.length; i++) {
+      expect(positions[i].name, resAllDf1[i].name);
+      for (const key in positions[i].freq) {
+        expect(positions[i].freq[key].count, resAllDf1[i].freq[key].count);
+      }
+    }
+
+  });
+  test('positions with shrinkEmptyTail option true (filterd)', async () => {
+    let csvDf2 = `seq 
+    -TC-G-TTGC--
+    -TC-GCTTGC--
+    -T--C-GT-
+    -T--C-GT-
+    -T--C-GT-
+    -T--CCGT-`;
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf2);
+    const tv: DG.TableView = grok.shell.addTableView(df);
+
+    df.getCol('seq').semType = 'Macromolecule';
+    df.getCol('seq').setTag('units', 'fasta:SEQ.MSA:DNA');
+
+    let seq: Column = df.getCol('seq');
+    df.filter.init((i) => {
+      return i > 2;
+    });
+    df.filter.fireChanged();
+    const wlViewer: WebLogo = await df.plot.fromType('WebLogo', {'shrinkEmptyTail': true}) as unknown as WebLogo;
+
+    tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
+
+    tvList.push(tv);
+    dfList.push(df);
+
+    const positions: PositionInfo[] = wlViewer['positions'];
+
+    const resAllDf1: PositionInfo[] = [
+      new PositionInfo('1', {'-': new PositionMonomerInfo(3)}),
+      new PositionInfo('2', {'T': new PositionMonomerInfo(3)}),
+      new PositionInfo('3', {'-': new PositionMonomerInfo(3)}),
+      new PositionInfo('4', {'-': new PositionMonomerInfo(3)}),
+      new PositionInfo('5', {'C': new PositionMonomerInfo(3)}),
+      new PositionInfo('6', {'-': new PositionMonomerInfo(2), 'C': new PositionMonomerInfo(1)}),
+      new PositionInfo('7', {'G': new PositionMonomerInfo(3)}),
+      new PositionInfo('8', {'T': new PositionMonomerInfo(3)}),
+      new PositionInfo('9', {'-': new PositionMonomerInfo(3)}),
+    ];
+
+    expect(positions.length, resAllDf1.length);
+
+    for (let i = 0; i < positions.length; i++) {
+      expect(positions[i].name, resAllDf1[i].name);
+      for (const key in positions[i].freq) {
+        expect(positions[i].freq[key].count, resAllDf1[i].freq[key].count);
+      }
+    }
+
+  });
+
+  test('positions with skipEmptyPositions option', async () => {
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf1);
+    const tv: DG.TableView = grok.shell.addTableView(df);
+
+    df.getCol('seq').semType = 'Macromolecule';
+    df.getCol('seq').setTag('units', 'fasta:SEQ.MSA:DNA');
+
+    const wlViewer: WebLogo = await df.plot.fromType('WebLogo', {'skipEmptyPositions': true}) as unknown as WebLogo;
+    tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
+
+    tvList.push(tv);
+    dfList.push(df);
+
+    const positions: PositionInfo[] = wlViewer['positions'];
+
+    const resAllDf1: PositionInfo[] = [
+      new PositionInfo('1', {'A': new PositionMonomerInfo(2), '-': new PositionMonomerInfo(3)}),
+      new PositionInfo('2', {'T': new PositionMonomerInfo(5)}),
+      new PositionInfo('3', {'C': new PositionMonomerInfo(5)}),
+      new PositionInfo('5', {'G': new PositionMonomerInfo(5)}),
+      new PositionInfo('6', {'-': new PositionMonomerInfo(3), 'C': new PositionMonomerInfo(2)}),
+      new PositionInfo('7', {'T': new PositionMonomerInfo(5)}),
+      new PositionInfo('8', {'T': new PositionMonomerInfo(5)}),
+      new PositionInfo('9', {'G': new PositionMonomerInfo(5)}),
+      new PositionInfo('10', {'C': new PositionMonomerInfo(5)})
+    ];
+
+    expect(positions.length, resAllDf1.length);
+
     for (let i = 0; i < positions.length; i++) {
       expect(positions[i].name, resAllDf1[i].name);
-        for (const key in positions[i].freq) {
-          expect(positions[i].freq[key].count, resAllDf1[i].freq[key].count);
-        }
+      for (const key in positions[i].freq) {
+        expect(positions[i].freq[key].count, resAllDf1[i].freq[key].count);
+      }
     }
 
   });

package/src/tests/WebLogo-test.ts

@@ -146,3 +146,4 @@ export async function _testPickupPaletteAA2(dfAA2: DG.DataFrame) {
 
   expect(cp instanceof AminoacidsPalettes, true);
 }
+

package/src/tests/detectors-test.ts

@@ -190,6 +190,7 @@ MWRSWY-CKHP
     };
   };
 
+
   test('NegativeEmpty', async () => { await _testNeg(readCsv('csvDfEmpty', csvDfEmpty), 'col1'); });
   test('Negative1', async () => { await _testNeg(readCsv('csvDf1', csvDf1), 'col1'); });
   test('Negative2', async () => { await _testNeg(readCsv('csvDf2', csvDf2), 'col1'); });
@@ -197,44 +198,44 @@ MWRSWY-CKHP
   test('NegativeSmiles', async () => { await _testNeg(readCsv('csvDfSmiles', csvDfSmiles), 'col1'); });
 
   test('Dna1', async () => {
-    await _testPos(readCsv('csvDfDna1', csvDfDna1), 'seq', 'fasta:SEQ:DNA');
+    await _testPos(readCsv('csvDfDna1', csvDfDna1), 'seq', 'fasta', 'SEQ', 'DNA');
   });
   test('Rna1', async () => {
-    await _testPos(readCsv('csvDfRna1', csvDfRna1), 'seq', 'fasta:SEQ:RNA');
+    await _testPos(readCsv('csvDfRna1', csvDfRna1), 'seq', 'fasta', 'SEQ', 'RNA');
   });
   test('AA1', async () => {
-    await _testPos(readCsv('csvDfPt1', csvDfPt1), 'seq', 'fasta:SEQ:PT');
+    await _testPos(readCsv('csvDfPt1', csvDfPt1), 'seq', 'fasta', 'SEQ', 'PT');
   });
   test('MsaDna1', async () => {
-    await _testPos(readCsv('csvDfMsaDna1', csvDfMsaDna1), 'seq', 'fasta:SEQ.MSA:DNA');
+    await _testPos(readCsv('csvDfMsaDna1', csvDfMsaDna1), 'seq', 'fasta', 'SEQ.MSA', 'DNA');
   });
 
   test('MsaAA1', async () => {
-    await _testPos(readCsv('csvDfMsaPt1', csvDfMsaPt1), 'seq', 'fasta:SEQ.MSA:PT');
+    await _testPos(readCsv('csvDfMsaPt1', csvDfMsaPt1), 'seq', 'fasta', 'SEQ.MSA', 'PT');
   });
 
   test('SepDna', async () => {
-    await _testPos(readCsv('csvDfSepDna', csvDfSepDna), 'seq', 'separator:SEQ:DNA', '*');
+    await _testPos(readCsv('csvDfSepDna', csvDfSepDna), 'seq', 'separator', 'SEQ', 'DNA', '*');
   });
   test('SepRna', async () => {
-    await _testPos(readCsv('csvDfSepRna', csvDfSepRna), 'seq', 'separator:SEQ:RNA', '*');
+    await _testPos(readCsv('csvDfSepRna', csvDfSepRna), 'seq', 'separator', 'SEQ', 'RNA', '*');
   });
   test('SepPt', async () => {
-    await _testPos(readCsv('csvDfSepPt', csvDfSepPt), 'seq', 'separator:SEQ:PT', '-');
+    await _testPos(readCsv('csvDfSepPt', csvDfSepPt), 'seq', 'separator', 'SEQ', 'PT', '-');
   });
   test('SepUn1', async () => {
-    await _testPos(readCsv('csvDfSepUn1', csvDfSepUn1), 'seq', 'separator:SEQ:UN', '-');
+    await _testPos(readCsv('csvDfSepUn1', csvDfSepUn1), 'seq', 'separator', 'SEQ', 'UN', '-');
   });
   test('SepUn2', async () => {
-    await _testPos(readCsv('csvDfSepUn2', csvDfSepUn2), 'seq', 'separator:SEQ:UN', '/');
+    await _testPos(readCsv('csvDfSepUn2', csvDfSepUn2), 'seq', 'separator', 'SEQ', 'UN', '/');
   });
 
   test('SepMsaN1', async () => {
-    await _testPos(readCsv('csvDfSepMsaDna1', csvDfSepMsaDna1), 'seq', 'separator:SEQ.MSA:DNA', '-');
+    await _testPos(readCsv('csvDfSepMsaDna1', csvDfSepMsaDna1), 'seq', 'separator', 'SEQ.MSA', 'DNA', '-');
   });
 
   test('SamplesFastaCsvPt', async () => {
-    await _testPos(readSamples(Samples.fastaCsv), 'sequence', 'fasta:SEQ:PT');
+    await _testPos(readSamples(Samples.fastaCsv), 'sequence', 'fasta', 'SEQ', 'PT');
   });
   test('SamplesFastaCsvNegativeEntry', async () => {
     await _testNeg(readSamples(Samples.fastaCsv), 'Entry');
@@ -247,7 +248,7 @@ MWRSWY-CKHP
   });
 
   test('SamplesFastaFastaPt', async () => {
-    await _testPos(readSamples(Samples.fastaFasta, readFileFasta), 'sequence', 'fasta:SEQ:PT');
+    await _testPos(readSamples(Samples.fastaFasta, readFileFasta), 'sequence', 'fasta', 'SEQ', 'PT');
   });
 
   // peptidesComplex contains monomers with spaces in AlignedSequence columns, which are forbidden
@@ -265,7 +266,7 @@ MWRSWY-CKHP
   });
 
   test('samplesMsaComplexUn', async () => {
-    await _testPos(readSamples(Samples.msaComplex), 'MSA', 'separator:SEQ.MSA:UN', '/');
+    await _testPos(readSamples(Samples.msaComplex), 'MSA', 'separator', 'SEQ.MSA', 'UN', '/');
   });
   test('samplesMsaComplexNegativeActivity', async () => {
     await _testNeg(readSamples(Samples.msaComplex), 'Activity');
@@ -280,7 +281,7 @@ MWRSWY-CKHP
   });
 
   test('samplesHelmCsvHELM', async () => {
-    await _testPos(readSamples(Samples.helmCsv), 'HELM', 'HELM', null);
+    await _testPos(readSamples(Samples.helmCsv), 'HELM', 'HELM', null, null, null);
   });
 
   test('samplesHelmCsvNegativeActivity', async () => {
@@ -296,7 +297,7 @@ MWRSWY-CKHP
     await _testNeg(readSamples(Samples.testHelmCsv), 'Test type');
   });
   test('samplesTestHelmPositiveHelmString', async () => {
-    await _testPos(readSamples(Samples.testHelmCsv), 'HELM string', 'HELM');
+    await _testPos(readSamples(Samples.testHelmCsv), 'HELM string', 'HELM', null, null, null);
   });
   test('samplesTestHelmNegativeValid', async () => {
     await _testNeg(readSamples(Samples.testHelmCsv), 'Valid?');
@@ -328,7 +329,7 @@ MWRSWY-CKHP
   });
 
   test('samplesFastaPtPosSequence', async () => {
-    await _testPos(readSamples(Samples.fastaPtCsv), 'sequence', 'fasta:SEQ:PT');
+    await _testPos(readSamples(Samples.fastaPtCsv), 'sequence', 'fasta', 'SEQ', 'PT');
   });
 
   test('samplesTestCerealNegativeCerealName', async () => {
@@ -383,7 +384,7 @@ export async function _testNeg(readDf: DfReaderFunc, colName: string) {
   }
 }
 
-export async function _testPos(readDf: DfReaderFunc, colName: string, units: string, separator: string | null = null) {
+export async function _testPos(readDf: DfReaderFunc, colName: string, units: string, aligned: string | null, alphabet: string | null, 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});
@@ -392,6 +393,8 @@ export async function _testPos(readDf: DfReaderFunc, colName: string, units: str
 
   expect(col.semType === DG.SEMTYPE.MACROMOLECULE, true);
   expect(col.getTag(DG.TAGS.UNITS), units);
+  expect(col.getTag('aligned'), aligned);
+  expect(col.getTag('alphabet'), alphabet);
   if (separator)
     expect(col.getTag('separator'), separator);
 }

package/src/tests/fasta-handler-test.ts

@@ -0,0 +1,141 @@
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {category, expectArray, test} from '@datagrok-libraries/utils/src/test';
+import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+
+
+category('fastaFileHandler', () => {
+  const fastaNormalFormatting = `>description:1
+MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW
+
+>description:2
+MIEVFLFGIVLGLIPITLAGLFVTAYLQYRRGDQLDL
+
+>description:3
+MMELVLKTIIGPIVVGVVLRIVDKWLNKDK
+
+>description:4
+MDRTDEVSNHTHDKPTLTWFEEIFEEYHSPFHN
+`;
+
+  const fastaExtraSpaces = `>description:1
+     MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW
+
+>description:2
+MI  EVF  LFGIVLGLI  PITLAGLFVTAY        LQYRRGDQLDL
+
+>description:3
+M      MELVLKTI      IGPI    VVGVVLR      IVDKWLNKDK
+
+>description:4
+MDR    TDEVSNHTHDKP        TLTWFEEIFEEYHSPFHN
+    `;
+
+  const fastaExtraNewlines = `>description:1
+
+MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW
+
+>description:2
+MIEVF
+LFGIVLGLI
+PITLAGLFVTA
+YLQYRRGDQLDL
+
+>description:3
+M
+ME
+
+LVLKTIIG
+
+PIVVGVVLRI
+VDKWLNKDK
+
+
+>description:4
+
+MDRT
+
+DEVSNHTHDKP
+
+TLTWFEEIFEE
+
+
+
+YHSPFHN
+`;
+  // a "broken" fasta file
+  // const fastaBroken = `
+    
+  //   >description:1
+// MDYKETLLM
+// PKTDFPMRGGLPN
+// KEPQIQEKW
+
+
+
+  //     >description:2
+// MIEVFL    FGIVLGLIPI     TLAGLFVTAYLQYRRGDQLDL
+
+// >description:3
+
+// M
+  // MELVLKTIIGP
+ // IVVGVVLR
+// IVDKWLNKD
+
+// K
+
+  // >description:4
+  //       MDRTDEV
+
+  //   SNHTHDKP
+// TLTWFEEI
+// FEE
+
+// YHSPFHN
+
+
+  //       `;
+
+  const descriptionsArray = [
+    'description:1', 'description:2', 'description:3', 'description:4',
+  ];
+  const descriptionCol = DG.Column.fromStrings('description', descriptionsArray);
+
+  const sequencesArray = [
+    'MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW',
+    'MIEVFLFGIVLGLIPITLAGLFVTAYLQYRRGDQLDL',
+    'MMELVLKTIIGPIVVGVVLRIVDKWLNKDK',
+    'MDRTDEVSNHTHDKPTLTWFEEIFEEYHSPFHN',
+  ];
+  const sequencesCol = DG.Column.fromStrings('sequence', sequencesArray);
+  sequencesCol.semType = DG.SEMTYPE.MACROMOLECULE;
+  UnitsHandler.setUnitsToFastaColumn(sequencesCol);
+
+  const fastaDf = DG.DataFrame.fromColumns([descriptionCol, sequencesCol]);
+
+  function _testColumnsParser(inputFasta: string) {
+    const ffh = new FastaFileHandler(inputFasta);
+    const parsedDescriptionsArray = ffh.descriptionsArray;
+    const parsedSequencesArray = ffh.sequencesArray;
+    expectArray(
+      [parsedDescriptionsArray, parsedSequencesArray],
+      [descriptionsArray, sequencesArray]
+    );
+  }
+
+  // test parser
+  test('testNormalFormatting', async () => {
+    _testColumnsParser(fastaNormalFormatting);
+  });
+  test('testExtraSpaces', async () => {
+    _testColumnsParser(fastaExtraSpaces);
+  });
+  test('testExtraNewlines', async () => {
+    _testColumnsParser(fastaExtraNewlines);
+  });
+});