@datagrok/bio 2.0.25 → 2.0.27

package/files/tests/toAtomicLevelTest.csv

@@ -0,0 +1,7 @@
+seq
+A
+G
+C
+U
+AG
+CU

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.0.25",
+  "version": "2.0.27",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",
@@ -14,15 +14,10 @@
   },
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.2.0",
+    "@datagrok-libraries/bio": "^5.5.0",
     "@datagrok-libraries/chem-meta": "1.0.1",
     "@datagrok-libraries/ml": "^6.2.0",
     "@datagrok-libraries/utils": "^1.11.1",
-    "@deck.gl/core": "^8.7.5",
-    "@deck.gl/layers": "^8.7.5",
-    "@luma.gl/constants": "^8.5.10",
-    "@luma.gl/core": "^8.5.10",
-    "@phylocanvas/phylocanvas.gl": "^1.44.0",
     "cash-dom": "^8.0.0",
     "datagrok-api": "^1.7.0",
     "dayjs": "^1.11.4",
@@ -51,6 +46,10 @@
     "webpack": "^5.64.1",
     "webpack-cli": "^4.6.0"
   },
+  "grokDependencies": {
+    "@datagrok/chem": "1.3.16",
+    "@datagrok/helm": "latest"
+  },
   "scripts": {
     "link-api": "npm link datagrok-api",
     "link-bio": "npm link @datagrok-libraries/bio",

package/setup.sh

@@ -31,7 +31,7 @@ for dir in ${dirs[@]}; do
     npm run link-all
   fi
   echo -e $GREEN npm run build in$(pwd) $NO_COLOR
-  npm run build
+  npm run build || exit
 done
 
 cd $package_dir

package/src/calculations/monomerLevelMols.ts

@@ -8,17 +8,20 @@ import {getHelmMonomers} from '../package';
 
 const V2000_ATOM_NAME_POS = 31;
 
-export async function getMonomericMols(mcol: DG.Column, pattern: boolean = false): Promise<DG.Column> {
+export async function getMonomericMols(mcol: DG.Column,
+  pattern: boolean = false, monomersDict?: Map<string, string>): Promise<DG.Column> {
   const separator: string = mcol.tags[C.TAGS.SEPARATOR];
   const units: string = mcol.tags[DG.TAGS.UNITS];
   const splitter = bio.getSplitter(units, separator);
   let molV3000Array;
-  const monomersDict = new Map();
+  monomersDict ??= new Map();
   const monomers = units === 'helm' ?
     getHelmMonomers(mcol) : Object.keys(bio.getStats(mcol, 0, splitter).freq).filter((it) => it !== '');
 
-  for (let i = 0; i < monomers.length; i++)
-    monomersDict.set(monomers[i], `${i + 1}`);
+  for (let i = 0; i < monomers.length; i++) {
+    if (!monomersDict.has(monomers[i]))
+      monomersDict.set(monomers[i], `${monomersDict.size + 1}`);
+  }
 
   if (units === 'helm') {
     molV3000Array = await grok.functions.call('HELM:getMolFiles', {col: mcol});

package/src/package-test.ts

@@ -2,7 +2,6 @@ import * as DG from 'datagrok-api/dg';
 
 import {runTests, TestContext, tests} from '@datagrok-libraries/utils/src/test';
 
-import './tests/WebLogo-test';
 import './tests/Palettes-test';
 import './tests/detectors-test';
 import './tests/msa-tests';
@@ -13,9 +12,11 @@ import './tests/renderers-test';
 import './tests/convert-test';
 import './tests/fasta-handler-test';
 import './tests/fasta-export-tests';
+import './tests/bio-tests';
 import './tests/WebLogo-positions-test';
 import './tests/checkInputColumn-tests';
 import './tests/similarity-diversity-tests';
+import './tests/substructure-filter-tests';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -13,11 +13,16 @@ import {SequenceAlignment, Aligned} from './seq_align';
 import {getEmbeddingColsNames, sequenceSpace} from './analysis/sequence-space';
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {createPropPanelElement, createTooltipElement, getSimilaritiesMarix} from './analysis/sequence-activity-cliffs';
-import {createJsonMonomerLibFromSdf, encodeMonomers, getMolfilesFromSeq, HELM_CORE_LIB_FILENAME} from './utils/utils';
+import {createJsonMonomerLibFromSdf, encodeMonomers, getMolfilesFromSeq} from '@datagrok-libraries/bio/src/utils/monomer-utils';
+import {HELM_CORE_LIB_FILENAME} from '@datagrok-libraries/bio/src/utils/const';
 import {getMacroMol} from './utils/atomic-works';
 import {MacromoleculeSequenceCellRenderer} from './utils/cell-renderer';
 import {convert} from './utils/convert';
 import {getMacroMolColumnPropertyPanel, representationsWidget} from './widgets/representations';
+import {TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule'
+import {_toAtomicLevel} from '@datagrok-libraries/bio/src/utils/to-atomic-level';
+import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
 import {removeEmptyStringRows} from '@datagrok-libraries/utils/src/dataframe-utils';
 import {
   generateManySequences,
@@ -99,7 +104,7 @@ export function checkInputColumn(
     ) {
       const notationAdd = allowedNotations.length == 0 ? 'any notation' :
         (`notation${allowedNotations.length > 1 ? 's' : ''} ${allowedNotations.map((n) => `"${n}"`).join(', ')} `);
-      msg = `${name} analysis is allowed for Macromolecules with ${notationAdd}.`;
+      msg = `${name} + ' analysis is allowed for Macromolecules with notation ${notationAdd}.`;
       res = false;
     } else if (!uh.isHelm()) {
       // alphabet is not specified for 'helm' notation
@@ -169,10 +174,10 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
     'SPE': {cycles: 2000, lambda: 1.0, dlambda: 0.0005},
   };
   const tags = {
-    'units': macroMolecule.tags['units'],
-    'aligned': macroMolecule.tags['aligned'],
-    'separator': macroMolecule.tags['separator'],
-    'alphabet': macroMolecule.tags['alphabet'],
+    'units': macroMolecule.getTag(DG.TAGS.UNITS),
+    'aligned': macroMolecule.getTag(TAGS.aligned),
+    'separator': macroMolecule.getTag(TAGS.separator),
+    'alphabet': macroMolecule.getTag(TAGS.alphabet),
   };
   const sp = await getActivityCliffs(
     df,
@@ -247,20 +252,11 @@ export async function toAtomicLevel(df: DG.DataFrame, macroMolecule: DG.Column):
   }
   if (!checkInputColumnUi(macroMolecule, 'To Atomic Level'))
     return;
-
   const monomersLibFile = await _package.files.readAsText(HELM_CORE_LIB_FILENAME);
   const monomersLibObject: any[] = JSON.parse(monomersLibFile);
-  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, true);
-  await grok.data.detectSemanticTypes(df);
+  _toAtomicLevel(df, macroMolecule, monomersLibObject);
 }
 
-
 //top-menu: Bio | MSA...
 //name: MSA
 //input: dataframe table
@@ -528,5 +524,3 @@ export function saveAsFasta() {
 export function bioSubstructureFilter(): BioSubstructureFilter {
   return new BioSubstructureFilter();
 }
-
-

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

@@ -8,6 +8,14 @@ import {getMonomericMols} from '../calculations/monomerLevelMols';
 import {BitSet} from 'datagrok-api/dg';
 import {updateDivInnerHTML} from '../utils/ui-utils';
 
+export const MONOMER_MOLS_COL = 'monomeric-mols';
+
+const enum MONOMERIC_COL_TAGS{
+  MONOMERIC_MOLS = 'monomeric-mols',
+  LAST_INVALIDATED_VERSION = 'last-invalidated-version',
+  MONOMERS_DICT = 'monomers-dict'
+}
+
 /**
  * Searches substructure in each row of Macromolecule column
  *
@@ -67,29 +75,48 @@ export function substructureSearchDialog(col: DG.Column): void {
     .show();
 }
 
-export function linearSubstructureSearch(substructure: string, col: DG.Column): DG.BitSet {
-  const lowerCaseSubstr = substructure.toLowerCase();
+export function linearSubstructureSearch(substructure: string, col: DG.Column, separator?: string): DG.BitSet {
+  const re = separator ? prepareSubstructureRegex(substructure, separator) : substructure;
   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)
+    const macromolecule = col.get(i);
+    if (macromolecule.match(re) || macromolecule === substructure)
       resultArray.set(i, true, false);
   }
   return resultArray;
 }
 
+function prepareSubstructureRegex(substructure: string, separator: string) {
+  const char = `${separator}`.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+  const startsWithSep = substructure.charAt(0) === separator;
+  const endsWithSep = substructure.charAt(substructure.length - 1) === separator;
+  const substrWithoutSep = substructure.replace(new RegExp(`^${char}|${char}$`, 'g'), '');
+  const re = startsWithSep ? endsWithSep ? `${char}${substrWithoutSep}${char}` :
+    `${char}${substrWithoutSep}${char}|${char}${substrWithoutSep}$` :
+    endsWithSep ? `^${substrWithoutSep}${char}|${char}${substrWithoutSep}${char}` :
+      `^${substrWithoutSep}${char}|${char}${substrWithoutSep}${char}|${char}${substrWithoutSep}$`;
+  return re;
+}
+
 export async function helmSubstructureSearch(substructure: string, col: DG.Column): Promise<BitSet> {
-  const helmColWithSubstructure = DG.Column.string('helm', col.length + 1)
-    .init((i) => i === col.length ? substructure : col.get(i));
-  helmColWithSubstructure.setTag(DG.TAGS.UNITS, bio.NOTATION.HELM);
-  const monomericMolsCol = await getMonomericMols(helmColWithSubstructure, true);
-  const molSubstructure = monomericMolsCol.get(col.length);
-  const monomericMolsDf = DG.DataFrame.fromColumns([monomericMolsCol]);
-  monomericMolsDf.rows.removeAt(col.length);
+  if (col.version !== col.temp[MONOMERIC_COL_TAGS.LAST_INVALIDATED_VERSION])
+    await invalidateHelmMols(col);
+  const substructureCol = DG.Column.string('helm', 1).init((i) => substructure);
+  substructureCol.setTag(DG.TAGS.UNITS, bio.NOTATION.HELM);
+  const substructureMolsCol =
+    await getMonomericMols(substructureCol, true, col.temp[MONOMERIC_COL_TAGS.MONOMERS_DICT]);
   const matchesCol = await grok.functions.call('Chem:searchSubstructure', {
-    molStringsColumn: monomericMolsDf.columns.byIndex(0),
-    molString: molSubstructure,
+    molStringsColumn: col.temp[MONOMERIC_COL_TAGS.MONOMERIC_MOLS],
+    molString: substructureMolsCol.get(0),
     molBlockFailover: '',
   });
   return matchesCol.get(0);
 }
+
+export async function invalidateHelmMols(col: DG.Column) {
+  const monomersDict = new Map();
+  const monomericMolsCol = await getMonomericMols(col, true, monomersDict);
+  col.temp[MONOMERIC_COL_TAGS.MONOMERIC_MOLS] = monomericMolsCol;
+  col.temp[MONOMERIC_COL_TAGS.MONOMERS_DICT] = monomersDict;
+  col.temp[MONOMERIC_COL_TAGS.LAST_INVALIDATED_VERSION] = col.version;
+}

package/src/tests/{WebLogo-test.ts → bio-tests.ts}

@@ -5,7 +5,7 @@ import * as bio from '@datagrok-libraries/bio';
 
 import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
 
-category('WebLogo', () => {
+category('bio', () => {
   const csvDfN1: string = `seq
 ACGTCT
 CAGTGT
@@ -47,7 +47,21 @@ XZJ{}2
 `;
 
   // anonymous functions specified in test() registering must return Promise<any>
-  test('testGetStats', async () => { await _testGetStats(csvDfN1); });
+  test('testGetStatsHelm1', async () => {
+    const csv = `seq
+PEPTIDE1{meI}$$$$
+`;
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+    const seqCol: DG.Column = df.getCol('seq')!;
+    const stats = bio.getStats(seqCol, 1, bio.splitterAsHelm);
+
+    expectObject(stats.freq, {
+      'meI': 1
+    });
+    expect(stats.sameLength, true);
+  });
+
+  test('testGetStatsN1', async () => { await _testGetStats(csvDfN1); });
   test('testGetAlphabetSimilarity', async () => { await _testGetAlphabetSimilarity(); });
 
   test('testPickupPaletteN1', async () => { await _testPickupPaletteN1(csvDfN1); });

package/src/tests/checkInputColumn-tests.ts

@@ -8,10 +8,9 @@ import {after, before, category, test, expect, expectArray} from '@datagrok-libr
 
 import {checkInputColumn, multipleSequenceAlignmentAny} from '../package';
 import {UNITS} from 'datagrok-api/dg';
-
+import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 category('checkInputColumn', () => {
-
   const csv = `seq
 seq1,
 seq2,
@@ -22,7 +21,7 @@ seq4`;
     const func: DG.Func = DG.Func.find({package: 'Bio', name: 'multipleSequenceAlignmentAny'})[0];
     const funcInputColumnProperty: DG.Property = func.inputs.find((i) => i.name == 'sequence')!;
 
-    let k = 11;
+    const k = 11;
 
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
     const col: DG.Column = df.getCol('seq');
@@ -42,7 +41,7 @@ seq4`;
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
     const col: DG.Column = df.getCol('seq');
     col.semType = DG.SEMTYPE.MACROMOLECULE;
-    col.setTag(DG.TAGS.UNITS, 'helm');
+    col.setTag(DG.TAGS.UNITS, NOTATION.HELM);
     col.setTag(bio.TAGS.alphabetSize, '11');
     col.setTag(bio.TAGS.alphabetIsMultichar, 'true');
 
@@ -57,7 +56,7 @@ seq4`;
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
     const col: DG.Column = df.getCol('seq');
     col.semType = DG.SEMTYPE.MACROMOLECULE;
-    col.setTag(DG.TAGS.UNITS, 'fasta');
+    col.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
     col.setTag(bio.TAGS.alphabet, 'UN');
     col.setTag(bio.TAGS.alphabetSize, '11');
     col.setTag(bio.TAGS.alphabetIsMultichar, 'true');
@@ -73,6 +72,6 @@ seq4`;
   test('testGetActionFunctionMeta', async () => {
     const func: DG.Func = DG.Func.find({package: 'Bio', name: 'multipleSequenceAlignmentAny'})[0];
     const sequenceInput: DG.Property = func.inputs.find((i) => i.name == 'sequence')!;
-    let k = 11;
+    const k = 11;
   });
-});
+});

package/src/tests/detectors-test.ts

@@ -6,7 +6,6 @@ import * as bio from '@datagrok-libraries/bio';
 import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
 
 import {importFasta} from '../package';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 type DfReaderFunc = () => Promise<DG.DataFrame>;
 
@@ -200,44 +199,49 @@ MWRSWY-CKHP
   test('NegativeSmiles', async () => { await _testNeg(readCsv('csvDfSmiles', csvDfSmiles), 'col1'); });
 
   test('Dna1', async () => {
-    await _testPos(readCsv('csvDfDna1', csvDfDna1), 'seq', 'fasta', 'SEQ', 'DNA', 4, false);
+    await _testPos(readCsv('csvDfDna1', csvDfDna1), 'seq', bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ, bio.ALPHABET.DNA, 4, false);
   });
   test('Rna1', async () => {
-    await _testPos(readCsv('csvDfRna1', csvDfRna1), 'seq', 'fasta', 'SEQ', 'RNA', 4, false);
+    await _testPos(readCsv('csvDfRna1', csvDfRna1), 'seq', bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ, bio.ALPHABET.RNA, 4, false);
   });
   test('AA1', async () => {
-    await _testPos(readCsv('csvDfPt1', csvDfPt1), 'seq', 'fasta', 'SEQ', 'PT', 20, false);
+    await _testPos(readCsv('csvDfPt1', csvDfPt1), 'seq', bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ, bio.ALPHABET.PT, 20, false);
   });
   test('MsaDna1', async () => {
-    await _testPos(readCsv('csvDfMsaDna1', csvDfMsaDna1), 'seq', 'fasta', 'SEQ.MSA', 'DNA', 4, false);
+    await _testPos(readCsv('csvDfMsaDna1', csvDfMsaDna1), 'seq', bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ_MSA, bio.ALPHABET.DNA, 4, false);
   });
 
   test('MsaAA1', async () => {
-    await _testPos(readCsv('csvDfMsaPt1', csvDfMsaPt1), 'seq', 'fasta', 'SEQ.MSA', 'PT', 20, false);
+    await _testPos(readCsv('csvDfMsaPt1', csvDfMsaPt1), 'seq', bio.NOTATION.FASTA,
+      bio.ALIGNMENT.SEQ_MSA, bio.ALPHABET.PT, 20, false);
   });
 
   test('SepDna', async () => {
-    await _testPos(readCsv('csvDfSepDna', csvDfSepDna), 'seq', 'separator', 'SEQ', 'DNA', 4, false, '*');
+    await _testPos(readCsv('csvDfSepDna', csvDfSepDna), 'seq', bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ, bio.ALPHABET.DNA, 4, false, '*');
   });
   test('SepRna', async () => {
-    await _testPos(readCsv('csvDfSepRna', csvDfSepRna), 'seq', 'separator', 'SEQ', 'RNA', 4, false, '*');
+    await _testPos(readCsv('csvDfSepRna', csvDfSepRna), 'seq', bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ, bio.ALPHABET.RNA, 4, false, '*');
   });
   test('SepPt', async () => {
-    await _testPos(readCsv('csvDfSepPt', csvDfSepPt), 'seq', 'separator', 'SEQ', 'PT', 20, false, '-');
+    await _testPos(readCsv('csvDfSepPt', csvDfSepPt), 'seq',
+      bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ, bio.ALPHABET.PT, 20, false, '-');
   });
   test('SepUn1', async () => {
-    await _testPos(readCsv('csvDfSepUn1', csvDfSepUn1), 'seq', 'separator', 'SEQ', 'UN', 8, true, '-');
+    await _testPos(readCsv('csvDfSepUn1', csvDfSepUn1), 'seq',
+      bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ, bio.ALPHABET.UN, 8, true, '-');
   });
   test('SepUn2', async () => {
-    await _testPos(readCsv('csvDfSepUn2', csvDfSepUn2), 'seq', 'separator', 'SEQ', 'UN', 9, true, '/');
+    await _testPos(readCsv('csvDfSepUn2', csvDfSepUn2), 'seq',
+      bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ, bio.ALPHABET.UN, 9, true, '/');
   });
 
   test('SepMsaN1', async () => {
-    await _testPos(readCsv('csvDfSepMsaDna1', csvDfSepMsaDna1), 'seq', 'separator', 'SEQ.MSA', 'DNA', 4, false, '-');
+    await _testPos(readCsv('csvDfSepMsaDna1', csvDfSepMsaDna1), 'seq',
+      bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ_MSA, bio.ALPHABET.DNA, 4, false, '-');
   });
 
   test('SamplesFastaCsvPt', async () => {
-    await _testPos(readSamples(Samples.fastaCsv), 'sequence', 'fasta', 'SEQ', 'PT', 20, false);
+    await _testPos(readSamples(Samples.fastaCsv), 'sequence', bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ, bio.ALPHABET.PT, 20, false);
   });
   test('SamplesFastaCsvNegativeEntry', async () => {
     await _testNeg(readSamples(Samples.fastaCsv), 'Entry');
@@ -250,7 +254,8 @@ MWRSWY-CKHP
   });
 
   test('SamplesFastaFastaPt', async () => {
-    await _testPos(readSamples(Samples.fastaFasta, readFileFasta), 'sequence', 'fasta', 'SEQ', 'PT', 20, false);
+    await _testPos(readSamples(Samples.fastaFasta, readFileFasta),
+      'sequence', bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ, bio.ALPHABET.PT, 20, false);
   });
 
   // peptidesComplex contains monomers with spaces in AlignedSequence columns, which are forbidden
@@ -268,7 +273,8 @@ MWRSWY-CKHP
   });
 
   test('samplesMsaComplexUn', async () => {
-    await _testPos(readSamples(Samples.msaComplex), 'MSA', 'separator', 'SEQ.MSA', 'UN', 161, true, '/');
+    await _testPos(readSamples(Samples.msaComplex), 'MSA',
+      bio.NOTATION.SEPARATOR, bio.ALIGNMENT.SEQ_MSA, bio.ALPHABET.UN, 161, true, '/');
   });
   test('samplesMsaComplexNegativeActivity', async () => {
     await _testNeg(readSamples(Samples.msaComplex), 'Activity');
@@ -283,7 +289,7 @@ MWRSWY-CKHP
   });
 
   test('samplesHelmCsvHELM', async () => {
-    await _testPos(readSamples(Samples.helmCsv), 'HELM', 'helm', null, null, 160, true, null);
+    await _testPos(readSamples(Samples.helmCsv), 'HELM', bio.NOTATION.HELM, null, null, 160, true, null);
   });
 
   test('samplesHelmCsvNegativeActivity', async () => {
@@ -299,7 +305,7 @@ MWRSWY-CKHP
     await _testNeg(readSamples(Samples.testHelmCsv), 'Test type');
   });
   test('samplesTestHelmPositiveHelmString', async () => {
-    await _testPos(readSamples(Samples.testHelmCsv), 'HELM string', 'helm', null, null, 9, true, null);
+    await _testPos(readSamples(Samples.testHelmCsv), 'HELM string', bio.NOTATION.HELM, null, null, 9, true, null);
   });
   test('samplesTestHelmNegativeValid', async () => {
     await _testNeg(readSamples(Samples.testHelmCsv), 'Valid?');
@@ -331,7 +337,7 @@ MWRSWY-CKHP
   });
 
   test('samplesFastaPtPosSequence', async () => {
-    await _testPos(readSamples(Samples.fastaPtCsv), 'sequence', 'fasta', 'SEQ', 'PT', 20, false);
+    await _testPos(readSamples(Samples.fastaPtCsv), 'sequence', bio.NOTATION.FASTA, bio.ALIGNMENT.SEQ, bio.ALPHABET.PT, 20, false);
   });
 
   test('samplesTestCerealNegativeCerealName', async () => {
@@ -383,7 +389,7 @@ export async function _testNeg(readDf: DfReaderFunc, colName: string) {
     throw new Error(msg);
     // col.semType = '';
     // col.setTag(DG.TAGS.UNITS, '');
-    // col.setTag('separator', '');
+    // col.setTag(NOTATION.SEPARATOR, '');
   }
 }
 
@@ -406,7 +412,7 @@ export async function _testPos(
   if (separator)
     expect(col.getTag(bio.TAGS.separator), separator);
 
-  const uh = new UnitsHandler(col);
+  const uh = new bio.UnitsHandler(col);
   expect(uh.getAlphabetSize(), alphabetSize);
   expect(uh.getAlphabetIsMultichar(), alphabetIsMultichar);
   if (!uh.isHelm()) {

package/src/tests/renderers-test.ts

@@ -103,7 +103,7 @@ category('renderers', () => {
   async function _rendererMacromoleculeDifference() {
     const seqDiffCol: DG.Column = DG.Column.fromStrings('SequencesDiff',
       ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV']);
-    seqDiffCol.tags[DG.TAGS.UNITS] = 'separator';
+    seqDiffCol.tags[DG.TAGS.UNITS] = bio.NOTATION.SEPARATOR;
     seqDiffCol.tags[TAGS.SEPARATOR] = '/';
     seqDiffCol.semType = SEM_TYPES.MACROMOLECULE_DIFFERENCE;
     const df = DG.DataFrame.fromColumns([seqDiffCol]);
@@ -139,7 +139,7 @@ category('renderers', () => {
       `cell.renderer="${srcSeqCol!.getTag(DG.TAGS.CELL_RENDERER)}"`);
     expect(srcSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
     expect(srcSeqCol.getTag(DG.TAGS.UNITS), bio.NOTATION.FASTA);
-    expect(srcSeqCol.getTag(bio.TAGS.aligned), 'SEQ');
+    expect(srcSeqCol.getTag(bio.TAGS.aligned), bio.ALIGNMENT.SEQ);
     expect(srcSeqCol.getTag(bio.TAGS.alphabet), bio.ALPHABET.PT);
     expect(srcSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
 
@@ -148,7 +148,7 @@ category('renderers', () => {
 
     expect(msaSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
     expect(msaSeqCol.getTag(DG.TAGS.UNITS), bio.NOTATION.FASTA);
-    expect(msaSeqCol.getTag(bio.TAGS.aligned), 'SEQ.MSA');
+    expect(msaSeqCol.getTag(bio.TAGS.aligned), bio.ALIGNMENT.SEQ_MSA);
     expect(msaSeqCol.getTag(bio.TAGS.alphabet), bio.ALPHABET.PT);
     expect(msaSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
 
@@ -190,7 +190,7 @@ category('renderers', () => {
     /**/
     const seqDiffCol: DG.Column = DG.Column.fromStrings('SequencesDiff',
       ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV']);
-    seqDiffCol.tags[DG.TAGS.UNITS] = 'separator';
+    seqDiffCol.tags[DG.TAGS.UNITS] = bio.NOTATION.SEPARATOR;
     seqDiffCol.tags[TAGS.SEPARATOR] = '/';
     seqDiffCol.semType = SEM_TYPES.MACROMOLECULE_DIFFERENCE;
     const df = DG.DataFrame.fromColumns([seqDiffCol]);
@@ -206,10 +206,12 @@ category('renderers', () => {
         `view renderer has set to '${renderer}' instead of correct 'MacromoleculeDifference'.`);
   }
 
+  /** GROK-11212 Do not overwrite / recalculate 'cell.renderer' tag that has been set programmatically
+   * https://reddata.atlassian.net/browse/GROK-11212 */
   async function _setRendererManually() {
     const seqDiffCol: DG.Column = DG.Column.fromStrings('SequencesDiff',
       ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV']);
-    seqDiffCol.tags[DG.TAGS.UNITS] = 'separator';
+    seqDiffCol.tags[DG.TAGS.UNITS] = bio.NOTATION.SEPARATOR;
     seqDiffCol.tags[TAGS.SEPARATOR] = '/';
     seqDiffCol.semType = SEM_TYPES.MACROMOLECULE;
     const tgtCellRenderer = 'MacromoleculeDifference';

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

@@ -0,0 +1,61 @@
+import {after, before, category, test, expect, delay} from '@datagrok-libraries/utils/src/test';
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import {readDataframe} from './utils';
+import {BioSubstructureFilter, HelmFilter, SeparatorFilter} from '../widgets/bio-substructure-filter';
+
+
+category('substructureFilters', async () => {
+  test('fasta', async () => {
+    const fasta = await readDataframe('tests/filter_FASTA.csv');
+    const filter = new BioSubstructureFilter();
+    await grok.data.detectSemanticTypes(fasta);
+    filter.attach(fasta);
+    filter.bioFilter!.substructure = 'MD';
+    await delay(100);
+    expect(filter.dataFrame!.filter.trueCount, 3);
+    expect(filter.dataFrame!.filter.get(0), true);
+    expect(filter.dataFrame!.filter.get(3), true);
+    expect(filter.dataFrame!.filter.get(8), true);
+    expect(filter.dataFrame!.filter.get(1), false);
+  });
+
+  test('separator', async () => {
+    const msa = await readDataframe('tests/filter_MSA.csv');
+    const filter = new BioSubstructureFilter();
+    await grok.data.detectSemanticTypes(msa);
+    filter.attach(msa);
+    filter.bioFilter!.substructure = 'meI';
+    await delay(100);
+    expect(filter.dataFrame!.filter.trueCount, 7);
+    expect(filter.dataFrame!.filter.get(2), false);
+    filter.bioFilter!.substructure = '/meI';
+    await delay(100);
+    expect(filter.dataFrame!.filter.trueCount, 0);
+    filter.bioFilter!.substructure = 'meI-hHis';
+    (filter.bioFilter! as SeparatorFilter).separatorInput.value = '-';
+    await delay(100);
+    expect(filter.dataFrame!.filter.trueCount, 7);
+    expect(filter.dataFrame!.filter.get(2), false);
+  });
+
+  test('helm', async () => {
+    const helm = await readDataframe('tests/filter_HELM.csv');
+    const helmTableView = grok.shell.addTableView(helm);
+    const filter = new BioSubstructureFilter();
+    await grok.data.detectSemanticTypes(helm);
+    filter.attach(helm);
+    (filter.bioFilter! as HelmFilter).helmSubstructure = 'PEPTIDE1{C}$$$$V2.0';
+    filter.bioFilter!.onChanged.next();
+    await delay(1000);
+    expect(filter.dataFrame!.filter.trueCount, 2);
+    expect(filter.dataFrame!.filter.get(0), true);
+    expect(filter.dataFrame!.filter.get(3), true);
+    (filter.bioFilter! as HelmFilter).helmSubstructure = 'PEPTIDE1{A.C}$$$$V2.0';
+    filter.bioFilter!.onChanged.next();
+    await delay(100);
+    expect(filter.dataFrame!.filter.trueCount, 1);
+    expect(filter.dataFrame!.filter.get(3), true);
+    helmTableView.close();
+  });
+});

package/src/tests/test-sequnces-generators.ts

@@ -1,6 +1,8 @@
-import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
-import {DataFrame} from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import * as bio from '@datagrok-libraries/bio';
+
 
 export function generateManySequences(): DG.Column[] {
   let columns: DG.Column[] = [];
@@ -19,10 +21,10 @@ export function generateLongSequence(): DG.Column[] {
 
 export function setTagsMacromolecule(col: DG.Column) {
   col.semType = DG.SEMTYPE.MACROMOLECULE;
-  col.setTag('units', 'separator');
-  col.setTag('aligned', 'SEQ.MSA');
-  col.setTag('alphabet', 'UN');
-  col.setTag('separator', '/');
+  col.setTag(DG.TAGS.UNITS, bio.NOTATION.SEPARATOR);
+  col.setTag(bio.TAGS.aligned, bio.ALIGNMENT.SEQ_MSA);
+  col.setTag(bio.TAGS.alphabet, bio.ALPHABET.UN);
+  col.setTag(bio.TAGS.separator, '/');
   return col;
 }
 

package/src/utils/cell-renderer.ts

@@ -1,6 +1,8 @@
 import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+
+import {printLeftOrCentered, DrawStyle} from '@datagrok-libraries/bio/src/utils/cell-renderer';
 import * as bio from '@datagrok-libraries/bio';
 import * as C from './constants';
 
@@ -44,7 +46,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
   }
 
   onMouseMove(gridCell: DG.GridCell, e: MouseEvent): void {
-    if (gridCell.cell.column.getTag(bio.TAGS.aligned) !== 'SEQ.MSA')
+    if (gridCell.cell.column.getTag(bio.TAGS.aligned) !== bio.ALIGNMENT.SEQ_MSA)
       return;
 
     const maxLengthWordsSum = gridCell.cell.column.temp['bio-sum-maxLengthWords'];