@datagrok/bio 1.5.9 → 1.7.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "@datagrok/bio",
   "beta": false,
   "friendlyName": "Bio",
-  "version": "1.5.9",
+  "version": "1.7.0",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",
@@ -11,7 +11,7 @@
   },
   "dependencies": {
     "@biowasm/aioli": ">=2.4.0",
-    "@datagrok-libraries/bio": "^2.4.1",
+    "@datagrok-libraries/bio": "^2.5.0",
     "@datagrok-libraries/utils": "^1.0.0",
     "@datagrok-libraries/ml": "^2.0.9",
     "cash-dom": "latest",

package/scripts/generate_fasta_csv_for_alphabets.R

@@ -0,0 +1,70 @@
+require(tidyverse)
+library(random)
+
+alphabetDna <- c('A','C','G','T')
+alphabetRna <- c('A','C','G','U')
+alphabetPt <- c('G', 'L', 'Y', 'S', 'E', 'Q', 'D', 'N', 'F', 'A',
+                'K', 'R', 'H', 'C', 'V', 'P', 'W', 'I', 'M', 'T',)
+
+toAlphabet <- function(v, a;ph){
+  paste(sapply(v, function(ci){ alph[ci]; }), collapse = '')
+}
+
+mutateString <- function(s, p){
+
+}
+
+seq <- toAlphabet(sample.int(4, 35, replace=TRUE), alphabet);
+seqPt <- toAlphabet(sample.int(20, 35, replace=TRUE), alphabetPt);
+seqDna <- toAlphabet(sample.int(4, 35, replace=TRUE), alphabetDna);
+seqRna <- toAlphabet(sample.int(4, 35, replace=TRUE), alphabetRna);
+# probability to mutate
+seq_p1 <- c(100,  100,  100, 100, 100,   5,  2,  2,  50, 3,
+           100,  100,   7,  2,  2,   7,  2,  33,  100, 100,
+           100,  100,  100, 100, 100, 100, 100, 100, 100, 2,
+           100,  100,  100, 100, 100)
+seq_p2 <- c(100,  100,   7,  2,  2,   7,  2,  33,  100, 100,
+           100,  100,  100, 100, 100, 100, 100, 100, 100, 2,
+           100,  100,  100, 100, 100,   5,  2,  2,  50, 3,
+           100,  100,  100, 100, 100)
+
+# mutate string s with probability p and alphabet
+seq_mutate <- function(s, p, alphabet){
+  # s <- seqDna
+  # p <- seq_p
+  # alphabet <- alphabetDna
+  res_s <- s
+  res_p <- p
+  for (i in 1:(str_length(res_s)*2)) {
+    pos <- sample.int(str_length(res_s), 1)
+    if (sample.int(100, 1) < res_p[pos]) {
+      cast <- sample.int(100, 1) # mutation type probabilty
+      if (0 < cast && cast <= 2 ) {
+        #insertion
+        res_s <- paste(substr(res_s, 1, pos), alphabet[sample.int(4, 1)], substr(res_s, pos+1, str_length(res_s)), collapse='', sep='')
+        res_p <- c(res_p[1:pos], c(100), res_p[(pos+1):length(res_p)])
+        #cat('insertion');
+      } else if (2 < cast && cast <= 4 ) {
+        # deletion
+        res_s <- paste(substr(res_s, 1, pos-1), substr(res_s, pos+1, str_length(res_s)), collapse = '', sep='')
+        res_p <- c(res_p[1: (pos-1)], res_p[(pos+1):length(res_p)])
+        #cat('deletion');
+      } else {
+        # replace
+        res_s <- paste(substr(res_s, 1, pos-1), alphabet[sample.int(4, 1)], substr(res_s, pos+1, str_length(res_s)), collapse='', sep='')
+        #cat('replace')
+      }
+      #cat(res, '\n')
+    }
+  }
+  res_s;
+}
+
+fastaDna_df <- data.frame(id = 1:100, sequence = sapply(1:100, function(id){ seq_mutate(seqDna, seq_p1, alphabetDna)}));
+write_csv(fastaDna_df, 'D:/HOME/atanas/Datagrok/projs/public/packages/Bio/files/samples/sample_FASTA_DNA.csv');
+
+fastaRna_df <- data.frame(id = 1:100, sequence = sapply(1:100, function(id){ seq_mutate(seqRna, seq_p2, alphabetRna)}));
+write_csv(fastaRna_df, 'D:/HOME/atanas/Datagrok/projs/public/packages/Bio/files/samples/sample_FASTA_RNA.csv');
+
+fastaPt_df <- data.frame(id = 1:100, sequence = sapply(1:100, function(id){ seq_mutate(seqPt, seq_p2, alphabetPt)}));
+write_csv(fastaPt_df, 'D:/HOME/atanas/Datagrok/projs/public/packages/Bio/files/samples/sample_FASTA_PT.csv');

package/src/package-test.ts

@@ -10,6 +10,7 @@ import './tests/sequence-space-test';
 import './tests/activity-cliffs-tests';
 import './tests/splitter-test';
 import './tests/renderer-test';
+import './tests/convert-test';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -19,6 +19,10 @@ import {sequenceGetSimilarities, drawTooltip} from './utils/sequence-activity-cl
 import {getMolfilesFromSeq, HELM_CORE_LIB_FILENAME} from './utils/utils';
 import {getMacroMol} from './utils/atomic-works';
 import {MacromoleculeSequenceCellRenderer} from './utils/cell-renderer';
+import {Column} from 'datagrok-api/dg';
+import {SEM_TYPES} from './utils/constants';
+import { delay } from '@datagrok-libraries/utils/src/test';
+import { TableView } from 'datagrok-api/dg';
 
 //tags: init
 export async function initBio(): Promise<void> {
@@ -38,6 +42,29 @@ export function macromoleculeSequenceCellRenderer(): MacromoleculeSequenceCellRe
   return new MacromoleculeSequenceCellRenderer();
 }
 
+function checkInputColumn(col: DG.Column, name: string,
+  allowedNotations: string[] = [], allowedAlphabets: string[] = []): boolean {
+  const units: string = col.getTag(DG.TAGS.UNITS);
+  if (col.semType !== DG.SEMTYPE.MACROMOLECULE) {
+    grok.shell.warning(name + ' analysis is allowed for Macromolecules semantic type');
+    return false;
+  } else if (
+    (allowedAlphabets.length > 0 &&
+      !allowedAlphabets.some((a) => units.toUpperCase().endsWith(a.toUpperCase()))) ||
+    (allowedNotations.length > 0 &&
+      !allowedNotations.some((n) => units.toUpperCase().startsWith(n.toUpperCase())))
+  ) {
+    const notationAdd = allowedNotations.length == 0 ? 'any notation' :
+      (`notation${allowedNotations.length > 1 ? 's' : ''} ${allowedNotations.map((n) => `"${n}"`).join(', ')} `);
+    const alphabetAdd = allowedNotations.length == 0 ? 'any alphabet' :
+      (`alphabet${allowedAlphabets.length > 1 ? 's' : ''} ${allowedAlphabets.map((a) => `"${a}"`).join(', ')}.`);
+
+    grok.shell.warning(name + ' analysis is allowed for Macromolecules with ' + notationAdd + ' and ' + alphabetAdd);
+    return false;
+  }
+
+  return true;
+}
 
 //name: sequenceAlignment
 //input: string alignType {choices: ['Local alignment', 'Global alignment']}
@@ -73,20 +100,23 @@ export function vdRegionViewer() {
 //name: Sequence Activity Cliffs
 //description: detect activity cliffs
 //input: dataframe table [Input data table]
-//input: column sequence {semType: Macromolecule}
+//input: column macroMolecule {semType: Macromolecule}
 //input: column activities
 //input: double similarity = 80 [Similarity cutoff]
 //input: string methodName { choices:["UMAP", "t-SNE", "SPE"] }
-export async function activityCliffs(df: DG.DataFrame, sequence: DG.Column, activities: DG.Column,
+export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column, activities: DG.Column,
   similarity: number, methodName: string): Promise<void> {
+  if (!checkInputColumn(macroMolecule, 'Activity Cliffs'))
+    return;
+
   const axesNames = getEmbeddingColsNames(df);
   const options = {
     'SPE': {cycles: 2000, lambda: 1.0, dlambda: 0.0005},
   };
-  const units = sequence!.tags[DG.TAGS.UNITS];
+  const units = macroMolecule!.tags[DG.TAGS.UNITS];
   await getActivityCliffs(
     df,
-    sequence,
+    macroMolecule,
     axesNames,
     'Activity cliffs',
     activities,
@@ -110,6 +140,9 @@ export async function activityCliffs(df: DG.DataFrame, sequence: DG.Column, acti
 //input: bool plotEmbeddings = true
 export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: DG.Column, methodName: string,
   similarityMetric: string = 'Levenshtein', plotEmbeddings: boolean): Promise<void> {
+  if (!checkInputColumn(macroMolecule, 'Activity Cliffs'))
+    return;
+
   const embedColsNames = getEmbeddingColsNames(table);
   const chemSpaceParams = {
     seqCol: macroMolecule,
@@ -133,17 +166,40 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
 //name: To Atomic Level
 //description: returns molfiles for each monomer from HELM library
 //input: dataframe df [Input data table]
-//input: column sequence {semType: Macromolecule}
-export async function toAtomicLevel(df: DG.DataFrame, sequence: DG.Column): Promise<void> {
+//input: column macroMolecule {semType: Macromolecule}
+export async function toAtomicLevel(df: DG.DataFrame, macroMolecule: DG.Column): Promise<void> {
+  if (DG.Func.find({package: 'Chem', name: 'getRdKitModule'}).length === 0) {
+    grok.shell.warning('Transformation to atomic level requires package "Chem" installed.');
+    return;
+  }
+  if (!checkInputColumn(macroMolecule, 'To Atomic Level'))
+    return;
+
+  let currentView: TableView;
+  for (let view of grok.shell.tableViews) {
+    if (df.name === view.name) {
+      currentView = view;
+    }
+  }
+  const file = await _package.files.readAsText('samples/sar-small.csv');
+  const df2 = DG.DataFrame.fromCsv(file);
+  const v = grok.shell.addTableView(df2);
+  setTimeout(()=> {
+    grok.shell.closeTable(df2);
+    v.close();
+    grok.shell.v = currentView;
+  }, 100);
+  
   const monomersLibFile = await _package.files.readAsText(HELM_CORE_LIB_FILENAME);
   const monomersLibObject: any[] = JSON.parse(monomersLibFile);
-  const atomicCodes = getMolfilesFromSeq(sequence, monomersLibObject);
+  const atomicCodes = getMolfilesFromSeq(macroMolecule, monomersLibObject);
   const result = await getMacroMol(atomicCodes!);
 
   const col = DG.Column.fromStrings('regenerated', result);
   col.semType = DG.SEMTYPE.MOLECULE;
   col.tags[DG.TAGS.UNITS] = 'molblock';
-  df.columns.add(col);
+  df.columns.add(col, true);
+
 }
 
 
@@ -152,7 +208,10 @@ export async function toAtomicLevel(df: DG.DataFrame, sequence: DG.Column): Prom
 //input: dataframe table
 //input: column sequence { semType: Macromolecule }
 //output: column result
-export async function multipleSequenceAlignmentAny(table: DG.DataFrame, col: DG.Column): Promise<DG.Column> {
+export async function multipleSequenceAlignmentAny(table: DG.DataFrame, col: DG.Column): Promise<DG.Column | null> {
+  if (!checkInputColumn(col, 'MSA', ['fasta'], ['DNA', 'RNA', 'PT']))
+    return null;
+
   const msaCol = await runKalign(col, false);
   table.columns.add(msaCol);
 
@@ -171,19 +230,24 @@ export async function compositionAnalysis(): Promise<void> {
   // Higher priority for columns with MSA data to show with WebLogo.
   const tv = grok.shell.tv;
   const df = tv.dataFrame;
-  const semTypeColList = df.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
-  let col: DG.Column | undefined = semTypeColList.find((col) => {
-    const units = col.getTag(DG.TAGS.UNITS);
-    return units ? units.indexOf('MSA') !== -1 : false;
-  });
-  if (!col)
-    col = semTypeColList[0];
 
+  const col: DG.Column | null = WebLogo.pickUpSeqCol2(df);
   if (!col) {
     grok.shell.error('Current table does not contain sequences');
     return;
   }
 
+  if (!checkInputColumn(col, 'Composition'))
+    return;
+
+  const allowedNotations: string[] = ['fasta', 'separator'];
+  const units = col.getTag(DG.TAGS.UNITS);
+  if (!allowedNotations.some((n) => units.toUpperCase().startsWith(n.toUpperCase()))) {
+    grok.shell.warning('Composition analysis is allowed for ' +
+      `notation${allowedNotations.length > 1 ? 's' : ''} ${allowedNotations.map((n) => `"${n}"`).join(', ')}.`);
+    return;
+  }
+
   tv.addViewer('WebLogo', {sequenceColumnName: col.name});
 }
 
@@ -201,7 +265,7 @@ function parseMacromolecule(
 //name: importFasta
 //description: Opens FASTA file
 //tags: file-handler
-//meta.ext: fasta, fna, ffn, faa, frn, fa
+//meta.ext: fasta, fna, ffn, faa, frn, fa, fst
 //input: string fileContent
 //output: list tables
 export function importFasta(fileContent: string): DG.DataFrame [] {
@@ -221,13 +285,34 @@ export function importFasta(fileContent: string): DG.DataFrame [] {
   const descriptionsArrayCol = DG.Column.fromStrings('description', descriptionsArray);
   const sequenceCol = DG.Column.fromStrings('sequence', sequencesArray);
   sequenceCol.semType = 'Macromolecule';
-
   const stats: SeqColStats = WebLogo.getStats(sequenceCol, 5, WebLogo.splitterAsFasta);
   const seqType = stats.sameLength ? 'SEQ.MSA' : 'SEQ';
+
+  const PeptideFastaAlphabet = new Set([
+    'G', 'L', 'Y', 'S', 'E', 'Q', 'D', 'N', 'F', 'A',
+    'K', 'R', 'H', 'C', 'V', 'P', 'W', 'I', 'M', 'T',
+  ]);
+
+  const DnaFastaAlphabet = new Set(['A', 'C', 'G', 'T']);
+
+  const RnaFastaAlphabet = new Set(['A', 'C', 'G', 'U']);
+
+  //const SmilesRawAlphabet = new Set([
+  //  'O', 'C', 'c', 'N', 'S', 'F', '(', ')',
+  //  '1', '2', '3', '4', '5', '6', '7',
+  //  '+', '-', '@', '[', ']', '/', '\\', '#', '=']);
+
   const alphabetCandidates: [string, Set<string>][] = [
-    ['NT', new Set(Object.keys(Nucleotides.Names))],
-    ['PT', new Set(Object.keys(Aminoacids.Names))],
+    ['PT', PeptideFastaAlphabet],
+    ['DNA', DnaFastaAlphabet],
+    ['RNA', RnaFastaAlphabet],
   ];
+
+  //const alphabetCandidates: [string, Set<string>][] = [
+  //  ['NT', new Set(Object.keys(Nucleotides.Names))],
+  //  ['PT', new Set(Object.keys(Aminoacids.Names))],
+  //];
+
   // Calculate likelihoods for alphabet_candidates
   const alphabetCandidatesSim: number[] = alphabetCandidates.map(
     (c) => WebLogo.getAlphabetSimilarity(stats.freq, c[1]));

package/src/tests/convert-test.ts

@@ -44,7 +44,7 @@ PEPTIDE1{M.K.P.S.E.Y.V}$$$
 ACGTC
 CAGTGT
 TTCAAC
-    `,
+`,
     separatorDna: `seq
 A/C/G/T/C
 C/A/G/T/G/T
@@ -59,7 +59,7 @@ DNA1{D(T)P.D(T)P.D(C)P.D(A)P.D(A)P.D(C)P}$$$
 ACGUC
 CAGUGU
 UUCAAC
-    `,
+`,
     separatorRna: `seq
 A*C*G*U*C
 C*A*G*U*G*U
@@ -90,10 +90,10 @@ RNA1{R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P}$$$
     return _csvDfs[key];
   };
 
-  function converter(tgtNotation: NOTATION, separator: string | null = null): ConverterFunc {
+  function converter(tgtNotation: NOTATION, tgtSeparator: string | null = null): ConverterFunc {
     return function(srcCol: DG.Column): DG.Column {
       const converter = new NotationConverter(srcCol);
-      const resCol = converter.convert(NOTATION.SEPARATOR, separator);
+      const resCol = converter.convert(tgtNotation, tgtSeparator);
       return resCol;
     };
   };
@@ -127,7 +127,7 @@ RNA1{R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P}$$$
     await _testConvert(Samples.fastaDna, converter(NOTATION.HELM), Samples.helmDna);
   });
   test('testFastaRnaToHelm', async () => {
-    await _testConvert(Samples.fastaDna, converter(NOTATION.HELM), Samples.helmRna);
+    await _testConvert(Samples.fastaRna, converter(NOTATION.HELM), Samples.helmRna);
   });
 
   test('testSeparatorPtToFasta', async () => {
@@ -136,15 +136,15 @@ RNA1{R(U)P.R(U)P.R(C)P.R(A)P.R(A)P.R(C)P}$$$
   test('testSeparatorDnaToFasta', async () => {
     await _testConvert(Samples.separatorDna, converter(NOTATION.FASTA), Samples.fastaDna);
   });
-  test('testSeparatorDnaToFasta', async () => {
+  test('testSeparatorRnaToFasta', async () => {
     await _testConvert(Samples.separatorRna, converter(NOTATION.FASTA), Samples.fastaRna);
   });
 
   test('testSeparatorPtToHelm', async () => {
-    await _testConvert(Samples.separatorRna, converter(NOTATION.HELM), Samples.helmPt);
+    await _testConvert(Samples.separatorPt, converter(NOTATION.HELM), Samples.helmPt);
   });
   test('testSeparatorDnaToHelm', async () => {
-    await _testConvert(Samples.separatorRna, converter(NOTATION.HELM), Samples.helmDna);
+    await _testConvert(Samples.separatorDna, converter(NOTATION.HELM), Samples.helmDna);
   });
   test('testSeparatorRnaToHelm', async () => {
     await _testConvert(Samples.separatorRna, converter(NOTATION.HELM), Samples.helmRna);

package/src/tests/detectors-test.ts

@@ -104,24 +104,28 @@ MWRSWY-CKHP
     peptidesComplex = 'peptidesComplex',
     fastaCsv = 'fastaCsv',
     fastaFasta = 'fastaFasta',
+    fastaPtCsv = 'fastaPtCsv',
     msaComplex = 'msaComplex',
     helmCsv = 'helmCsv',
+    testDemogCsv = 'testDemogCsv',
+    testHelmCsv = 'testHelmCsv',
     testIdCsv = 'testIdCsv',
     testSmilesCsv = 'testSmilesCsv',
-    testHelmCsv = 'testHelmCsv',
-    testDemogCsv = 'testDemogCsv',
+    testSmiles2Csv = 'testSmiles2Csv',
   }
 
   const samples: { [key: string]: string } = {
     'peptidesComplex': 'System:AppData/Bio/samples/peptides_complex_msa.csv',
     'fastaCsv': 'System:AppData/Bio/samples/sample_FASTA.csv',
     'fastaFasta': 'System:AppData/Bio/samples/sample_FASTA.fasta',
+    'fastaPtCsv': 'System:AppData/Bio/samples/sample_FASTA_PT.csv',
     'msaComplex': 'System:AppData/Bio/samples/sample_MSA.csv',
     'helmCsv': 'System:AppData/Bio/samples/sample_HELM.csv',
     'testDemogCsv': 'System:AppData/Bio/samples/testDemog.csv',
-    'testIdCsv': 'System:AppData/Bio/samples/id.csv',
     'testHelmCsv': 'System:AppData/Bio/samples/testHelm.csv',
+    'testIdCsv': 'System:AppData/Bio/samples/id.csv',
     'testSmilesCsv': 'System:AppData/Bio/samples/testSmiles.csv',
+    'testSmiles2Csv': 'System:AppData/Bio/samples/testSmiles2.csv',
   };
 
   const _samplesDfs: { [key: string]: Promise<DG.DataFrame> } = {};
@@ -288,6 +292,14 @@ MWRSWY-CKHP
     for (const col of df.columns.toList())
       await _testNeg(dfFunc, col.name);
   });
+
+  test('samplesTestSmiles2NegativeSmiles', async () => {
+    await _testNeg(readSamples(Samples.testSmiles2Csv), 'SMILES');
+  });
+
+  test('samplesFastaPtPosSequence', async () => {
+    await (_testPos(readSamples(Samples.fastaPtCsv), 'sequence', 'fasta:SEQ:PT'));
+  });
 });
 
 export async function _testNeg(readDf: DfReaderFunc, colName: string) {

package/src/tests/renderer-test.ts

@@ -6,31 +6,53 @@ import * as DG from 'datagrok-api/dg';
 import {importFasta, multipleSequenceAlignmentAny} from '../package';
 
 category('renderers', () => {
+  let tvList: DG.TableView[];
+
+  before(async () => {
+    tvList = [];
+  });
+
+  after(async () => {
+    tvList.forEach((tv: DG.TableView) => tv.close());
+  });
+
   test('afterMsa', async () => {
     await _testAfterMsa();
   });
-});
 
-export async function _testAfterMsa() {
-  const fastaTxt: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA.fasta');
-  const df: DG.DataFrame = importFasta(fastaTxt)[0];
+  async function _testAfterMsa() {
+    const fastaTxt: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA.fasta');
+    const df: DG.DataFrame = importFasta(fastaTxt)[0];
+
+    const srcSeqCol: DG.Column | null = df.col('sequence');
+    expect(srcSeqCol !== null, true);
+    console.log('Bio: tests/renderers/afterMsa, src data loaded');
 
-  const seqCol: DG.Column | null = df.col('sequence');
-  expect(seqCol !== null, true);
+    const tv: DG.TableView = grok.shell.addTableView(df);
+    console.log('Bio: tests/renderers/afterMsa, table view');
 
-  const tv: DG.TableView = grok.shell.addTableView(df);
-  await grok.data.detectSemanticTypes(df);
+    await grok.data.detectSemanticTypes(df);
+    console.log('Bio: tests/renderers/afterMsa, detectSemanticTypes');
 
-  expect(seqCol!.semType, DG.SEMTYPE.MACROMOLECULE);
-  expect(seqCol!.getTag(DG.TAGS.UNITS), 'fasta:SEQ:PT');
-  expect(seqCol!.getTag('cell.renderer'), 'Macromolecule');
+    console.log('Bio: tests/renderers/afterMsa, src before test semType' +
+      `semType="${srcSeqCol!.semType}", units="${srcSeqCol!.getTag(DG.TAGS.UNITS)}", ` +
+      `cell.renderer="${srcSeqCol!.getTag('cell.renderer')}"`);
+    expect(srcSeqCol!.semType, DG.SEMTYPE.MACROMOLECULE);
+    expect(srcSeqCol!.getTag(DG.TAGS.UNITS), 'fasta:SEQ:PT');
+    expect(srcSeqCol!.getTag('cell.renderer'), 'Macromolecule');
+    console.log('Bio: tests/renderers/afterMsa, src semType tested');
 
-  const seqMsaCol: DG.Column = await multipleSequenceAlignmentAny(df, seqCol!);
-  tv.grid.invalidate();
+    const msaSeqCol: DG.Column | null = await multipleSequenceAlignmentAny(df, srcSeqCol!);
+    console.log('Bio: tests/renderers/afterMsa, msaSeqCol created');
 
-  expect(seqMsaCol!.semType, DG.SEMTYPE.MACROMOLECULE);
-  expect(seqMsaCol!.getTag(DG.TAGS.UNITS), 'fasta:SEQ.MSA:PT');
-  expect(seqMsaCol!.getTag('cell.renderer'), 'Macromolecule');
+    tv.grid.invalidate();
+    console.log('Bio: tests/renderers/afterMsa, tv.grid invalidated');
 
-  // tv.close();
-}
+    expect(msaSeqCol!.semType, DG.SEMTYPE.MACROMOLECULE);
+    expect(msaSeqCol!.getTag(DG.TAGS.UNITS), 'fasta:SEQ.MSA:PT');
+    expect(msaSeqCol!.getTag('cell.renderer'), 'Macromolecule');
+    console.log('Bio: tests/renderers/afterMsa, msa semType tested');
+
+    tvList.push(tv);
+  }
+});