@datagrok/bio 2.0.13 → 2.0.17

package/src/analysis/sequence-similarity-viewer.ts

@@ -0,0 +1,107 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {SequenceSearchBaseViewer} from './sequence-search-base-viewer';
+import {getMonomericMols} from '../calculations/monomerLevelMols';
+import * as C from '../utils/constants';
+import {createDifferenceCanvas, createDifferencesWithPositions} from './sequence-activity-cliffs';
+import {updateDivInnerHTML} from '../utils/ui-utils';
+import {WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
+import {TableView} from 'datagrok-api/dg';
+import { Subject } from 'rxjs';
+
+export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
+  hotSearch: boolean;
+  sketchedMolecule: string = '';
+  curIdx: number = 0;
+  molCol: DG.Column | null = null;
+  idxs: DG.Column | null = null;
+  scores: DG.Column | null = null;
+  cutoff: number;
+  gridSelect: boolean = false;
+  targetMoleculeIdx: number = 0;
+  computeCompleted = new Subject<boolean>();
+
+  constructor() {
+    super('similarity');
+    this.cutoff = this.float('cutoff', 0.01, {min: 0, max: 1});
+    this.hotSearch = this.bool('hotSearch', true);
+  }
+
+  init(): void {
+    this.hotSearch = true;
+    this.initialized = true;
+  }
+
+  async render(computeData = true): Promise<void> {
+    if (!this.beforeRender())
+      return;
+    if (this.moleculeColumn) {
+      this.curIdx = this.dataFrame!.currentRowIdx == -1 ? 0 : this.dataFrame!.currentRowIdx;
+      if (computeData && !this.gridSelect) {
+        this.targetMoleculeIdx = this.dataFrame!.currentRowIdx == -1 ? 0 : this.dataFrame!.currentRowIdx;
+        const monomericMols = await getMonomericMols(this.moleculeColumn);
+        //need to create df to calculate fingerprints
+        const monomericMolsDf = DG.DataFrame.fromColumns([monomericMols]);
+        const df = await grok.functions.call('Chem:callChemSimilaritySearch', {
+          df: this.dataFrame,
+          col: monomericMols,
+          molecule: monomericMols.get(this.targetMoleculeIdx),
+          metricName: this.distanceMetric,
+          limit: this.limit,
+          minScore: this.cutoff,
+          fingerprint: this.fingerprint
+        });
+        this.idxs = df.getCol('indexes');
+        this.scores = df.getCol('score');
+        this.molCol = DG.Column.string('sequence',
+          this.idxs!.length).init((i) => this.moleculeColumn?.get(this.idxs?.get(i)));
+        this.molCol.semType = DG.SEMTYPE.MACROMOLECULE;
+        this.tags.forEach((tag) => this.molCol!.setTag(tag, this.moleculeColumn!.getTag(tag)));
+        const resDf = DG.DataFrame.fromColumns([this.idxs!, this.molCol!, this.scores!]);
+        resDf.onCurrentRowChanged.subscribe((_) => {
+          this.dataFrame.currentRowIdx = resDf.col('indexes')!.get(resDf.currentRowIdx);
+          this.createPropertyPanel(resDf);
+          this.gridSelect = true;
+        });
+        const grid = resDf.plot.grid();
+        grid.col('indexes')!.visible = false;
+        const targetMolRow = this.idxs?.getRawData().findIndex((it) => it == this.targetMoleculeIdx);
+        const targetScoreCell = grid.cell('score', targetMolRow!);
+        targetScoreCell.cell.value = null;
+        (grok.shell.v as TableView).grid.root.addEventListener('click', (event: MouseEvent) => {
+          this.gridSelect = false;
+        });
+        updateDivInnerHTML(this.root, grid.root);
+        this.computeCompleted.next(true);
+      }
+    }
+  }
+
+
+  createPropertyPanel(resDf: DG.DataFrame) {
+    const propPanel = ui.div();
+    const molDifferences: { [key: number]: HTMLCanvasElement } = {};
+    const units = resDf.col('sequence')!.getTag(DG.TAGS.UNITS);
+    const separator = resDf.col('sequence')!.getTag(C.TAGS.SEPARATOR);
+    const splitter = WebLogo.getSplitter(units, separator);
+    const subParts1 = splitter(this.moleculeColumn!.get(this.targetMoleculeIdx));
+    const subParts2 = splitter(resDf.get('sequence', resDf.currentRowIdx));
+    const canvas = createDifferenceCanvas(subParts1, subParts2, units, molDifferences);
+    propPanel.append(ui.div(canvas, {style: {width: '300px', overflow: 'scroll'}}));
+    if (subParts1.length !== subParts2.length) {
+      propPanel.append(ui.divV([
+        ui.divText(`Different sequence length:`, {style: {fontWeight: 'bold'}}),
+        ui.divText(`target: ${subParts1.length} monomers`),
+        ui.divText(`selected: ${subParts2.length} monomers`)
+      ], {style: {paddingBottom: '10px'}}));
+    }
+    propPanel.append(createDifferencesWithPositions(molDifferences));
+    const acc = ui.accordion();
+    const accIcon = ui.element('i');
+    accIcon.className = 'grok-icon svg-icon svg-view-layout';
+    acc.addTitle(ui.span([accIcon, ui.label(`Similarity search`)]));
+    acc.addPane('Differeces', () => propPanel, true);
+    grok.shell.o = acc.root;
+  }
+}

package/src/calculations/monomerLevelMols.ts

@@ -1,25 +1,69 @@
 import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-
-import { getHelmMonomers } from '../package'
+import * as C from '../utils/constants';
+import {getHelmMonomers} from '../package';
+import {WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
 
 const V2000_ATOM_NAME_POS = 31;
 
 export async function getMonomericMols(mcol: DG.Column, pattern: boolean = false): Promise<DG.Column> {
-  const monomers = getHelmMonomers(mcol);
-  let mols = await grok.functions.call('HELM:getMolFiles', {mcol: mcol});
+  const separator: string = mcol.tags[C.TAGS.SEPARATOR];
+  const units: string = mcol.tags[DG.TAGS.UNITS];
+  const splitter = WebLogo.getSplitter(units, separator);
+  let molV3000Array;
+  const monomersDict = new Map();
+  const monomers = units === 'helm' ?
+    getHelmMonomers(mcol) : Object.keys(WebLogo.getStats(mcol, 0, splitter).freq).filter((it) => it !== '');
+
+  for (let i = 0; i < monomers.length; i++)
+    monomersDict.set(monomers[i], `${i + 1}`);
+
+  if (units === 'helm') {
+    molV3000Array = await grok.functions.call('HELM:getMolFiles', {col: mcol});
+    molV3000Array = changeV2000ToV3000(molV3000Array, monomersDict, pattern);
+  } else {
+    molV3000Array = new Array<string>(mcol.length);
+    for (let i = 0; i < mcol.length; i++) {
+      const sequenceMonomers = splitter(mcol.get(i)).filter((it) => it !== '');
+      const molV3000 = molV3000FromNonHelmSequence(sequenceMonomers, monomersDict, pattern);
+      molV3000Array[i] = molV3000;
+    }
+  }
+  return DG.Column.fromStrings('monomericMols', molV3000Array);
+}
+
+function molV3000FromNonHelmSequence(
+  monomers: Array<string>, monomersDict: Map<string, string>, pattern: boolean = false) {
+  let molV3000 = `
+  Datagrok macromolecule handler
+
+  0  0  0  0  0  0            999 V3000
+M  V30 BEGIN CTAB
+`;
+
+  molV3000 += `M  V30 COUNTS ${monomers.length} ${monomers.length - 1} 0 0 0\n`;
+  molV3000 += 'M  V30 BEGIN ATOM\n';
 
-  let dict = new Map(); 
-  for(let i = 0; i < monomers.length; i++)
-    dict.set(monomers[i], `${i + 1}`);
+  for (let atomRowI = 0; atomRowI < monomers.length; atomRowI++) {
+    molV3000 += pattern ?
+      `M  V30 ${atomRowI + 1} R${monomersDict.get(monomers[atomRowI])} 0.000 0.000 0 0\n` :
+      `M  V30 ${atomRowI + 1} At 0.000 0.000 0 0 MASS=${monomersDict.get(monomers[atomRowI])}\n`;
+  }
+
+  molV3000 += 'M  V30 END ATOM\n';
+  molV3000 += 'M  V30 BEGIN BOND\n';
 
-  mols = changeToV3000(mols, dict, pattern);
+  for (let bondRowI = 0; bondRowI < monomers.length - 1; bondRowI++)
+    molV3000 += `M  V30 ${bondRowI + 1} 1 ${bondRowI + 1} ${bondRowI + 2}\n`;
 
-  return DG.Column.fromStrings('monomericMols', mols);
+  molV3000 += 'M  V30 END BOND\n';
+  molV3000 += 'M  V30 END CTAB\n';
+  molV3000 += 'M  END';
+  return molV3000;
 }
 
-function changeToV3000(mols: Array<string>, dict: Map<string, string>, pattern: boolean = false): Array<string> {
+function changeV2000ToV3000(mols: DG.Column, dict: Map<string, string>, pattern: boolean = false): Array<string> {
+  const molsArray = new Array<string>(mols.length);
   for (let i = 0; i < mols.length; i++) {
     let curPos = 0;
     let endPos = 0;
@@ -30,7 +74,7 @@ function changeToV3000(mols: Array<string>, dict: Map<string, string>, pattern:
 M  V30 BEGIN CTAB
 `;
 
-    const mol = mols[i];
+    const mol = mols.get(i);
     curPos = mol.indexOf('\n', curPos) + 1;
     curPos = mol.indexOf('\n', curPos) + 1;
     curPos = mol.indexOf('\n', curPos) + 1;
@@ -45,10 +89,10 @@ M  V30 BEGIN CTAB
       curPos = mol.indexOf('\n', curPos) + 1 + V2000_ATOM_NAME_POS;
       endPos = mol.indexOf(' ', curPos);
       const monomerName: string = mol.substring(curPos, endPos);
-      molV3000 += pattern ? 
-                  `M  V30 ${atomRowI + 1} R${dict.get(monomerName)} 0.000 0.000 0 0\n` :
-                  `M  V30 ${atomRowI + 1} At 0.000 0.000 0 0 MASS=${dict.get(monomerName)}\n`;
-    } 
+      molV3000 += pattern ?
+        `M  V30 ${atomRowI + 1} R${dict.get(monomerName)} 0.000 0.000 0 0\n` :
+        `M  V30 ${atomRowI + 1} At 0.000 0.000 0 0 MASS=${dict.get(monomerName)}\n`;
+    }
 
     molV3000 += 'M  V30 END ATOM\n';
     molV3000 += 'M  V30 BEGIN BOND\n';
@@ -60,13 +104,13 @@ M  V30 BEGIN CTAB
       const order = parseInt(mol.substring(curPos + 6, curPos + 9).trim());
 
       molV3000 += `M  V30 ${bondRowI + 1} ${order} ${firstMonomer} ${secondMonomer}\n`;
-    } 
+    }
 
     molV3000 += 'M  V30 END BOND\n';
     molV3000 += 'M  V30 END CTAB\n';
     molV3000 += 'M  END';
-    mols[i] = molV3000;
+    molsArray[i] = molV3000;
   }
 
-  return mols;
-}
+  return molsArray;
+}

package/src/package-test.ts

@@ -12,8 +12,10 @@ import './tests/splitters-test';
 import './tests/renderers-test';
 import './tests/convert-test';
 import './tests/fasta-handler-test';
+import './tests/fasta-export-tests';
 import './tests/WebLogo-positions-test';
-import './tests/checkInputColumn-tests'
+import './tests/checkInputColumn-tests';
+import './tests/similarity-diversity-tests';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -12,15 +12,15 @@ import {runKalign, testMSAEnoughMemory} from './utils/multiple-sequence-alignmen
 import {SequenceAlignment, Aligned} from './seq_align';
 import {Nucleotides} from '@datagrok-libraries/bio/src/nucleotides';
 import {Aminoacids} from '@datagrok-libraries/bio/src/aminoacids';
-import {getEmbeddingColsNames, sequenceSpace} from './utils/sequence-space';
+import {getEmbeddingColsNames, sequenceSpace} from './analysis/sequence-space';
 import {AvailableMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
-import {createPropPanelElement, createTooltipElement, getSimilaritiesMarix} from './utils/sequence-activity-cliffs';
+import {createPropPanelElement, createTooltipElement, getSimilaritiesMarix} from './analysis/sequence-activity-cliffs';
 import {createJsonMonomerLibFromSdf, encodeMonomers, getMolfilesFromSeq, HELM_CORE_LIB_FILENAME} from './utils/utils';
 import {getMacroMol} from './utils/atomic-works';
 import {MacromoleculeSequenceCellRenderer} from './utils/cell-renderer';
 import {convert} from './utils/convert';
-import {representationsWidget} from './widgets/representations';
+import {getMacroMolColumnPropertyPanel, 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';
@@ -32,6 +32,10 @@ import {
 
 import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter';
 import * as C from './utils/constants';
+import {SequenceSimilarityViewer} from './analysis/sequence-similarity-viewer';
+import {SequenceDiversityViewer} from './analysis/sequence-diversity-viewer';
+import {substructureSearchDialog} from './substructure-search/substructure-search';
+import {saveAsFastaUI} from './utils/save-as-fasta';
 
 //tags: init
 export async function initBio() {
@@ -46,6 +50,14 @@ export function fastaSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
   return new MacromoleculeSequenceCellRenderer();
 }
 
+//name: Sequence Renderer
+//input: column molColumn {semType: Macromolecule}
+//tags: panel
+//output: widget result
+export function macroMolColumnPropertyPanel(molColumn: DG.Column): DG.Widget {
+  return getMacroMolColumnPropertyPanel(molColumn);
+}
+
 //name: separatorSequenceCellRenderer
 //tags: cellRenderer
 //meta.cellType: sequence
@@ -462,3 +474,52 @@ export function getHelmMonomers(seqCol: DG.Column<string>): string[] {
   const stats = WebLogo.getStats(seqCol, 1, WebLogo.splitterAsHelm);
   return Object.keys(stats.freq);
 }
+
+
+//name: SequenceSimilaritySearchViewer
+//tags: viewer
+//output: viewer result
+export function similaritySearchViewer(): SequenceSimilarityViewer {
+  return new SequenceSimilarityViewer();
+}
+
+//top-menu: Bio | Similarity Search...
+//name: similaritySearch
+//description: finds the most similar sequence
+//output: viewer result
+export function similaritySearchTopMenu(): void {
+  const view = (grok.shell.v as DG.TableView);
+  const viewer = view.addViewer('SequenceSimilaritySearchViewer');
+  view.dockManager.dock(viewer, 'down');
+}
+
+//name: SequenceDiversitySearchViewer
+//tags: viewer
+//output: viewer result
+export function diversitySearchViewer(): SequenceDiversityViewer {
+  return new SequenceDiversityViewer();
+}
+
+//top-menu: Bio | Diversity Search...
+//name: diversitySearch
+//description: finds the most diverse molecules
+//output: viewer result
+export function diversitySearchTopMenu() {
+  const view = (grok.shell.v as DG.TableView);
+  const viewer = view.addViewer('SequenceDiversitySearchViewer');
+  view.dockManager.dock(viewer, 'down');
+}
+
+//name: Bio | Substructure search ...
+//tags: panel, bio
+//input: column col {semType: Macromolecule}
+export function bioSubstructureSearch(col: DG.Column): void {
+  substructureSearchDialog(col);
+}
+
+//name: saveAsFasta
+//description: As FASTA...
+//tags: fileExporter
+export function saveAsFasta() {
+  saveAsFastaUI();
+}

package/src/substructure-search/substructure-search.ts

@@ -0,0 +1,65 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/units-handler';
+import * as C from '../utils/constants';
+
+/**
+ * Searches substructure in each row of Macromolecule column
+ *
+ * @param {DG.column} col Column with 'Macromolecule' semantic type
+ */
+export function substructureSearchDialog(col: DG.Column): void {
+  const units = col.getTag(DG.TAGS.UNITS);
+  const separator = col.getTag(C.TAGS.SEPARATOR);
+  const notations = [NOTATION.FASTA, NOTATION.SEPARATOR];
+
+  const substructureInput = ui.textInput('Substructure', '');
+  const notationInput = ui.choiceInput('Notation', units, notations);
+  const separatorInput = ui.textInput('Separator', separator);
+
+  // hide the separator input for non-SEPARATOR target notations
+  const toggleSeparator = () => {
+    if (notationInput.value !== NOTATION.SEPARATOR)
+      separatorInput.root.hidden = true;
+    else
+      separatorInput.root.hidden = false;
+  };
+
+  toggleSeparator();
+
+  notationInput.onChanged(() => {
+    toggleSeparator();
+  });
+
+  ui.dialog('Substructure search')
+    .add(ui.inputs([
+      substructureInput,
+      notationInput,
+      separatorInput
+    ]))
+    .onOK(() => {
+      let substructure = substructureInput.value;
+      if (notationInput.value !== NOTATION.FASTA && separatorInput.value !== separator)
+        substructure = substructure.replaceAll(separatorInput.value, separator);
+      const matchesColName = `Matches: ${substructure}`;
+      const colExists = col.dataFrame.columns.names()
+        .filter((it) => it.toLocaleLowerCase() === matchesColName.toLocaleLowerCase()).length > 0;
+      if (!colExists) {
+        const matches = substructureSearch(substructure, col);
+        col.dataFrame.columns.add(DG.Column.fromBitSet(matchesColName, matches));
+      } else { grok.shell.warning(`Search ${substructure} is already performed`); }
+    })
+    .show();
+}
+
+export function substructureSearch(substructure: string, col: DG.Column): DG.BitSet {
+  const lowerCaseSubstr = substructure.toLowerCase();
+  const resultArray = DG.BitSet.create(col.length);
+  for (let i = 0; i < col.length; i++) {
+    const macromolecule = col.get(i).toLowerCase();
+    if (macromolecule.indexOf(lowerCaseSubstr) !== -1)
+      resultArray.set(i, true, false);
+  }
+  return resultArray;
+}

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

@@ -41,7 +41,7 @@ ATC-G-TTGC--
     seqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
     seqCol.setTag(UnitsHandler.TAGS.alphabet, ALPHABET.DNA);
 
-    const wlViewer: WebLogo = await df.plot.fromType('WebLogo') as unknown as WebLogo;
+    const wlViewer: WebLogo = (await df.plot.fromType('WebLogo')) as WebLogo;
     tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
 
     tvList.push(tv);
@@ -94,8 +94,8 @@ ATC-G-TTGC--
       return i > 2;
     });
     df.filter.fireChanged();
-    const wlViewer: WebLogo = await df.plot.fromType('WebLogo', {'shrinkEmptyTail': true}) as unknown as WebLogo;
-
+    const wlViewer: WebLogo = (await df.plot.fromType('WebLogo',
+      {'shrinkEmptyTail': true})) as WebLogo;
     tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
 
     tvList.push(tv);
@@ -134,7 +134,8 @@ ATC-G-TTGC--
     seqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
     seqCol.setTag(UnitsHandler.TAGS.alphabet, ALPHABET.DNA);
 
-    const wlViewer: WebLogo = await df.plot.fromType('WebLogo', {'skipEmptyPositions': true}) as unknown as WebLogo;
+    const wlViewer: WebLogo = (await df.plot.fromType('WebLogo',
+      {'skipEmptyPositions': true})) as WebLogo;
     tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
 
     tvList.push(tv);

package/src/tests/WebLogo-test.ts

@@ -61,21 +61,21 @@ XZJ{}2
   test('testPickupPaletteX', async () => { await _testPickupPaletteX(csvDfX); });
 });
 
-category('WebLogo.monomerToText', () => {
+category('WebLogo.monomerToShort', () => {
   test('longMonomerSingle', async () => {
-    await expect(WebLogo.monomerToText('S'), 'S');
+    await expect(WebLogo.monomerToShort('S', 5), 'S');
   });
   test('longMonomerShort', async () => {
-    await expect(WebLogo.monomerToText('Short'), 'Short');
+    await expect(WebLogo.monomerToShort('Short', 5), 'Short');
   });
   test('longMonomerLong56', async () => {
-    await expect(WebLogo.monomerToText('Long56'), 'Long5…');
+    await expect(WebLogo.monomerToShort('Long56', 5), 'Long5…');
   });
   test('longMonomerComplexFirstPartShort', async () => {
-    await expect(WebLogo.monomerToText('Long-long'), 'Long…');
+    await expect(WebLogo.monomerToShort('Long-long', 5), 'Long…');
   });
   test('longMonomerComplexFirstPartLong56', async () => {
-    await expect(WebLogo.monomerToText('Long56-long'), 'Long5…');
+    await expect(WebLogo.monomerToShort('Long56-long', 5), 'Long5…');
   });
 });
 

package/src/tests/activity-cliffs-tests.ts

@@ -4,7 +4,7 @@ import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 
 import {readDataframe} from './utils';
-import { _testActivityCliffsOpen } from './activity-cliffs-utils';
+import {_testActivityCliffsOpen} from './activity-cliffs-utils';
 
 
 category('activityCliffs', async () => {
@@ -12,28 +12,20 @@ category('activityCliffs', async () => {
   let actCliffsDf: DG.DataFrame;
   let actCliffsTableViewWithEmptyRows: DG.TableView;
   let actCliffsDfWithEmptyRows: DG.DataFrame;
-  
 
-  before(async () => {
+  test('activityCliffsOpens', async () => {
     actCliffsDf = await readDataframe('tests/sample_MSA_data.csv');
     actCliffsTableView = grok.shell.addTableView(actCliffsDf);
-    actCliffsDfWithEmptyRows = await readDataframe('tests/sample_MSA_data_empty_vals.csv');
-    actCliffsTableViewWithEmptyRows = grok.shell.addTableView(actCliffsDfWithEmptyRows);
-  });
-
-  after(async () => {
+    await _testActivityCliffsOpen(actCliffsDf, 102, 'UMAP', 'MSA');
     grok.shell.closeTable(actCliffsDf);
     actCliffsTableView.close();
-    grok.shell.closeTable(actCliffsDfWithEmptyRows);
-    actCliffsTableViewWithEmptyRows.close();
   });
 
-  test('activityCliffsOpen', async () => {
-    await _testActivityCliffsOpen(actCliffsDf, 102, 'UMAP', 'MSA');
-  });
-
-  test('activityCliffsOpenWithEmptyRows', async () => {
+  test('activityCliffsWithEmptyRows', async () => {
+    actCliffsDfWithEmptyRows = await readDataframe('tests/sample_MSA_data_empty_vals.csv');
+    actCliffsTableViewWithEmptyRows = grok.shell.addTableView(actCliffsDfWithEmptyRows);
     await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 103, 'UMAP', 'MSA');
+    grok.shell.closeTable(actCliffsDfWithEmptyRows);
+    actCliffsTableViewWithEmptyRows.close();
   });
-  
 });

package/src/tests/activity-cliffs-utils.ts

@@ -2,10 +2,11 @@ import * as DG from 'datagrok-api/dg';
 import {delay, expect} from '@datagrok-libraries/utils/src/test';
 import {_package} from '../package-test';
 import { activityCliffs } from '../package';
-
+import * as grok from 'datagrok-api/grok';
 
 export async function _testActivityCliffsOpen(df: DG.DataFrame, numberCliffs: number, method: string, colName: string) {
-   const scatterPlot = await activityCliffs(
+  await grok.data.detectSemanticTypes(df);
+  const scatterPlot = await activityCliffs(
      df, 
      df.col(colName)!, 
      df.col('Activity')!, 

package/src/tests/convert-test.ts

@@ -1,7 +1,8 @@
-import {category, expectArray, test} from '@datagrok-libraries/utils/src/test';
-
-import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+
+import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
 
 import {ConverterFunc} from './types';
 import {NotationConverter} from '@datagrok-libraries/bio/src/utils/notation-converter';
@@ -139,6 +140,7 @@ RNA1{P.R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P.P.P}$$$
     return function(srcCol: DG.Column): DG.Column {
       const converter = new NotationConverter(srcCol);
       const resCol = converter.convert(tgtNotation, tgtSeparator);
+      expect(resCol.getTag('units'), tgtNotation);
       return resCol;
     };
   };

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

@@ -0,0 +1,110 @@
+import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+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 {WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
+
+type SaveAsFastaTestArgs = { srcCsv: string, idCols: string [], seqCol: string, lineWidth: number, tgtFasta: string };
+
+category('fastaExport', () => {
+
+  enum WrapDataTest {
+    single = 'single',
+    multi = 'multi'
+  }
+
+  const wrapData: { [key: string]: { src: string, tgt: string[] } } = {
+    [WrapDataTest.single]: {
+      src: 'MDYKETLLMPKTDFPMRGGLP',
+      tgt: ['MDYKETLLMP', 'KTDFPMRGGL', 'P'],
+    },
+    [WrapDataTest.multi]: {
+      src: 'M[MeI]YKETLL[MeF]PKTDFPMRGGL[MeA]',
+      tgt: ['M[MeI]YKETLL[MeF]P', 'KTDFPMRGGL', '[MeA]'],
+    },
+  };
+
+  enum SaveAsFastaTests {
+    test1 = 'test1',
+    test2 = 'test2'
+  }
+
+  const saveAsFastaData: {
+    [key: string]: SaveAsFastaTestArgs
+  } = {
+    [SaveAsFastaTests.test1]: {
+      srcCsv: `id,seq
+1,MDYKETLLMP
+2,KTDFPMRGGL
+3,P`,
+      idCols: ['id'],
+      seqCol: 'seq',
+      lineWidth: 10,
+      tgtFasta: `>1
+MDYKETLLMP
+>2
+KTDFPMRGGL
+>3
+P
+`
+    },
+    [SaveAsFastaTests.test2]: {
+      srcCsv: `id,id2,seq
+1,seqA,M[MeI]YKETLL[MeF]P
+2,seqB,KTDFPMRGGL
+3,seqC,[MeA]
+`,
+      idCols: ['id2', 'id'],
+      seqCol: 'seq',
+      lineWidth: 5,
+      tgtFasta: `>seqA|1
+M[MeI]YKE
+TLL[MeF]P
+>seqB|2
+KTDFP
+MRGGL
+>seqC|3
+[MeA]
+`
+    }
+  };
+
+  test('wrapSequenceSingle', async () => {
+    _testWrapSequence(WrapDataTest.single, 10);
+  });
+
+  test('wrapSequenceMulti', async () => {
+    _testWrapSequence(WrapDataTest.multi, 10);
+  });
+
+  test('saveAsFastaTest1', async () => {
+    _testSaveAsFasta(saveAsFastaData[SaveAsFastaTests.test1]);
+  });
+
+  test('saveAsFastaTest2', async () => {
+    _testSaveAsFasta(saveAsFastaData[SaveAsFastaTests.test2]);
+  });
+
+  function _testWrapSequence(testKey: string, lineWidth: number = 10) {
+    const splitter = WebLogo.splitterAsFasta;
+
+    const srcSeq: string = wrapData[testKey].src;
+    const wrapRes: string[] = wrapSequence(srcSeq, splitter, lineWidth);
+    const wrapTgt: string[] = wrapData[testKey].tgt;
+
+    expectArray(wrapRes, wrapTgt);
+  }
+
+  async function _testSaveAsFasta(args: SaveAsFastaTestArgs) {
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(args.srcCsv);
+
+    const seqCol: DG.Column = df.getCol(args.seqCol);
+    const idCols: DG.Column[] = args.idCols.map((colName) => df.getCol(colName));
+
+    const fastaRes: string = saveAsFastaDo(idCols, seqCol, args.lineWidth);
+    expect(fastaRes, args.tgtFasta);
+  }
+});
+