@datagrok/bio 2.1.12 → 2.4.2

package/src/package.ts

@@ -7,24 +7,14 @@ export const _package = new DG.Package();
 
 import {MacromoleculeDifferenceCellRenderer, MonomerCellRenderer} from './utils/cell-renderer';
 import {VdRegionsViewer} from './viewers/vd-regions-viewer';
-import {runKalign, testMSAEnoughMemory} from './utils/multiple-sequence-alignment';
-import {SequenceAlignment, Aligned} from './seq_align';
-import {getEmbeddingColsNames, sequenceSpace, sequenceSpaceByFingerprints} from './analysis/sequence-space';
+import {runKalign} from './utils/multiple-sequence-alignment';
+import {SequenceAlignment} from './seq_align';
+import {getEmbeddingColsNames, sequenceSpaceByFingerprints} from './analysis/sequence-space';
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {
-  createLinesGrid,
-  createPropPanelElement,
-  createTooltipElement,
-  getChemSimilaritiesMarix,
-  getSimilaritiesMarix
+  createLinesGrid, createPropPanelElement, createTooltipElement, getChemSimilaritiesMatrix,
 } from './analysis/sequence-activity-cliffs';
-import {
-  createJsonMonomerLibFromSdf,
-  encodeMonomers,
-  getMolfilesFromSeq
-} from '@datagrok-libraries/bio/src/monomer-works/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';
@@ -36,23 +26,39 @@ 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 {invalidateMols, MONOMERIC_COL_TAGS, substructureSearchDialog} from './substructure-search/substructure-search';
+import {substructureSearchDialog} from './substructure-search/substructure-search';
 import {saveAsFastaUI} from './utils/save-as-fasta';
 import {BioSubstructureFilter} from './widgets/bio-substructure-filter';
-import {getMonomericMols} from './calculations/monomerLevelMols';
 import {delay} from '@datagrok-libraries/utils/src/test';
-import {from, Observable, Subject} from 'rxjs';
 import {
+  getStats,
+  NOTATION,
+  splitterAsHelm,
   TAGS as bioTAGS,
-  Monomer, IMonomerLib, MonomerWorks, MonomerLib, readLibrary,
-  SeqPalette, UnitsHandler, WebLogoViewer, getStats, splitterAsHelm
-} from '@datagrok-libraries/bio';
-
-const STORAGE_NAME = 'Libraries';
-const LIB_PATH = 'System:AppData/Bio/libraries';
-const LIBS_PATH = 'libraries/';
+  ALPHABET
+} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {pepseaMethods, runPepsea} from './utils/pepsea';
+import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
+import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {WebLogoViewer} from './viewers/web-logo-viewer';
+import {createJsonMonomerLibFromSdf, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {LIB_PATH, LIB_STORAGE_NAME, MonomerLibHelper} from './utils/monomer-lib';
+import {getMacromoleculeColumn} from './utils/ui-utils';
+import {IUMAPOptions, ITSNEOptions} from '@datagrok-libraries/ml/src/reduce-dimensionality';
+import {SequenceSpaceFunctionEditor} from '@datagrok-libraries/ml/src/functionEditors/seq-space-editor';
+import {ActivityCliffsFunctionEditor} from '@datagrok-libraries/ml/src/functionEditors/activity-cliffs-editor';
+
+// /** Avoid reassinging {@link monomerLib} because consumers subscribe to {@link IMonomerLib.onChanged} event */
+// let monomerLib: MonomerLib | null = null;
+
+//name: getMonomerLibHelper
+//description:
+//output: object result
+export function getMonomerLibHelper(): IMonomerLibHelper {
+  return MonomerLibHelper.instance;
+}
 
-let monomerLib: IMonomerLib | null = null;
 export let hydrophobPalette: SeqPaletteCustom | null = null;
 
 export class SeqPaletteCustom implements SeqPalette {
@@ -67,14 +73,19 @@ export class SeqPaletteCustom implements SeqPalette {
   }
 }
 
+// let loadLibrariesPromise: Promise<void> = Promise.resolve();
+
 //tags: init
 export async function initBio() {
-  await loadLibraries();
+  // loadLibrariesPromise = loadLibrariesPromise.then(() => {
+  await MonomerLibHelper.instance.loadLibraries(); // from initBio()
+  // });
+  // await loadLibrariesPromise;
+  const monomerLib = MonomerLibHelper.instance.getBioLib();
   const monomers: string[] = [];
   const logPs: number[] = [];
   const module = await grok.functions.call('Chem:getRdKitModule');
 
-
   const series = monomerLib!.getMonomerMolsByType('PEPTIDE')!;
   Object.keys(series).forEach((symbol) => {
     monomers.push(symbol);
@@ -95,29 +106,27 @@ export async function initBio() {
   hydrophobPalette = new SeqPaletteCustom(palette);
 }
 
-async function loadLibraries() {
-  //TODO handle if files are in place
-
-  const uploadedLibraries: string[] = Object.values(await grok.dapi.userDataStorage.get(STORAGE_NAME, true));
-  if (uploadedLibraries.length == 0 && monomerLib == null)
-    monomerLib = new MonomerLib({});
-  for (let i = 0; i < uploadedLibraries.length; ++i)
-    await monomerManager(uploadedLibraries[i]);
-}
-
-//name: monomerManager
-//input: string value
-export async function monomerManager(value: string) {
-  if (monomerLib == null)
-    monomerLib = await readLibrary(LIB_PATH, value);
-  else
-    monomerLib!.update(await readLibrary(LIB_PATH, value));
+//name: sequenceTooltip
+//tags: tooltip
+//input: column col {semType: Macromolecule}
+//output: widget result
+export async function sequenceTooltip(col: DG.Column): Promise<DG.Widget<any>> {
+  const tv = grok.shell.tv;
+  const viewer = await tv.dataFrame.plot.fromType('WebLogo', {
+    sequenceColumnName: col.name,
+    backgroundColor: 0xFFfdffe5,
+    fitArea: false,
+    positionHeight: 'Entropy',
+    fixWidth: true
+  });
+  viewer.root.style.height = '50px';
+  return viewer;
 }
 
 //name: getBioLib
 //output: object monomerLib
-export function getBioLib(): IMonomerLib | null {
-  return monomerLib;
+export function getBioLib(): IMonomerLib {
+  return MonomerLibHelper.instance.getBioLib();
 }
 
 //name: manageFiles
@@ -130,31 +139,38 @@ export async function manageFiles() {
 }
 
 //name: Manage Libraries
-//tags: panel, widgets
 //input: column seqColumn {semType: Macromolecule}
+//tags: panel, exclude-actions-panel
 //output: widget result
 export async function libraryPanel(seqColumn: DG.Column): Promise<DG.Widget> {
   //@ts-ignore
   const filesButton: HTMLButtonElement = ui.button('Manage', manageFiles);
   const divInputs: HTMLDivElement = ui.div();
-  const librariesList: string[] = (await _package.files.list(`${LIBS_PATH}`, false, ''))
+  const libFileNameList: string[] = (await grok.dapi.files.list(`${LIB_PATH}`, false, ''))
     .map((it) => it.fileName);
-  const uploadedLibraries: string[] = Object.values(await grok.dapi.userDataStorage.get(STORAGE_NAME, true));
-  for (let i = 0; i < uploadedLibraries.length; ++i) {
-    const libraryName: string = uploadedLibraries[i];
-    divInputs.append(ui.boolInput(libraryName, true, async () => {
-      grok.dapi.userDataStorage.remove(STORAGE_NAME, libraryName, true);
-      await loadLibraries();
-    }).root);
-  }
-  const unusedLibraries: string[] = librariesList.filter((x) => !uploadedLibraries.includes(x));
-  for (let i = 0; i < unusedLibraries.length; ++i) {
-    const libraryName: string = unusedLibraries[i];
-    divInputs.append(ui.boolInput(libraryName, false, () => {
-      monomerManager(libraryName);
-      grok.dapi.userDataStorage.postValue(STORAGE_NAME, libraryName, libraryName, true);
-    }).root);
+  const librariesUserSettingsSet: Set<string> = new Set<string>(Object.keys(
+    await grok.dapi.userDataStorage.get(LIB_STORAGE_NAME, true)));
+
+  let userStoragePromise: Promise<void> = Promise.resolve();
+  for (const libFileName of libFileNameList) {
+    const libInput: DG.InputBase<boolean | null> = ui.boolInput(libFileName, librariesUserSettingsSet.has(libFileName),
+      () => {
+        userStoragePromise = userStoragePromise.then(async () => {
+          if (libInput.value == true) {
+            // Save checked library to user settings 'Libraries'
+            await grok.dapi.userDataStorage.postValue(LIB_STORAGE_NAME, libFileName, libFileName, true);
+            await MonomerLibHelper.instance.loadLibraries(); // from libraryPanel()
+          } else {
+            // Remove unchecked library from user settings 'Libraries'
+            await grok.dapi.userDataStorage.remove(LIB_STORAGE_NAME, libFileName, true);
+            await MonomerLibHelper.instance.loadLibraries(true); // from libraryPanel()
+          }
+          grok.shell.info('Monomer library user settings saved.');
+        });
+      });
+    divInputs.append(libInput.root);
   }
+
   return new DG.Widget(ui.splitV([
     divInputs,
     ui.divV([filesButton])
@@ -197,11 +213,10 @@ export function macromoleculeDifferenceCellRenderer(): MacromoleculeDifferenceCe
 }
 
 
-function checkInputColumnUi(
-  col: DG.Column, name: string, allowedNotations: string[] = [], allowedAlphabets: string[] = []
-): boolean {
+function checkInputColumnUi(col: DG.Column, name: string, allowedNotations: string[] = [],
+  allowedAlphabets: string[] = [], notify: boolean = true): boolean {
   const [res, msg]: [boolean, string] = checkInputColumn(col, name, allowedNotations, allowedAlphabets);
-  if (!res)
+  if (notify && !res)
     grok.shell.warning(msg);
   return res;
 }
@@ -258,9 +273,10 @@ export function sequenceAlignment(alignType: string, alignTable: string, gap: nu
 }
 
 //name: WebLogo
-//description: WebLogo viewer
+//description: WebLogo
 //tags: viewer, panel
 //output: viewer result
+//meta.icon: files/icons/weblogo-viewer.svg
 export function webLogoViewer() {
   return new WebLogoViewer();
 }
@@ -268,27 +284,42 @@ export function webLogoViewer() {
 //name: VdRegions
 //description: V-Domain regions viewer
 //tags: viewer, panel
+//meta.icon: files/icons/vdregions-viewer.svg
 //output: viewer result
 export function vdRegionViewer() {
   return new VdRegionsViewer();
 }
 
+//name: SeqActivityCliffsEditor
+//tags: editor
+//input: funccall call
+export function SeqActivityCliffsEditor(call: DG.FuncCall) {
+  const funcEditor = new ActivityCliffsFunctionEditor(DG.SEMTYPE.MACROMOLECULE);
+  ui.dialog({title: 'Activity Cliffs'})
+    .add(funcEditor.paramsUI)
+    .onOK(async () => {
+      call.func.prepare(funcEditor.funcParams).call(true);
+    })
+    .show();
+}
+
 //top-menu: Bio | Sequence Activity Cliffs...
 //name: Sequence Activity Cliffs
 //description: detect activity cliffs
 //input: dataframe table [Input data table]
-//input: column macroMolecule {semType: Macromolecule}
+//input: column molecules {semType: Macromolecule}
 //input: column activities
 //input: double similarity = 80 [Similarity cutoff]
-//input: string methodName { choices:["UMAP", "t-SNE", "SPE"] }
+//input: string methodName { choices:["UMAP", "t-SNE"] }
+//input: object options {optional: true}
+//output: viewer result
+//editor: Bio:SeqActivityCliffsEditor
 export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column, activities: DG.Column,
-  similarity: number, methodName: string): Promise<DG.Viewer | undefined> {
+  similarity: number, methodName: string, options?: IUMAPOptions | ITSNEOptions
+): Promise<DG.Viewer | undefined> {
   if (!checkInputColumnUi(macroMolecule, 'Activity Cliffs'))
     return;
   const axesNames = getEmbeddingColsNames(df);
-  const options = {
-    'SPE': {cycles: 2000, lambda: 1.0, dlambda: 0.0005},
-  };
   const tags = {
     'units': macroMolecule.getTag(DG.TAGS.UNITS),
     'aligned': macroMolecule.getTag(bioTAGS.aligned),
@@ -308,23 +339,38 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
     DG.SEMTYPE.MACROMOLECULE,
     tags,
     sequenceSpaceByFingerprints,
-    getChemSimilaritiesMarix,
+    getChemSimilaritiesMatrix,
     createTooltipElement,
     createPropPanelElement,
     createLinesGrid,
-    (options as any)[methodName]);
+    options);
   return sp;
 }
 
+//name: SequenceSpaceEditor
+//tags: editor
+//input: funccall call
+export function SequenceSpaceEditor(call: DG.FuncCall) {
+  const funcEditor = new SequenceSpaceFunctionEditor(DG.SEMTYPE.MACROMOLECULE);
+  ui.dialog({title: 'Sequence Space'})
+    .add(funcEditor.paramsUI)
+    .onOK(async () => {
+      call.func.prepare(funcEditor.funcParams).call(true);
+    })
+    .show();
+}
+
 //top-menu: Bio | Sequence Space...
 //name: Sequence Space
 //input: dataframe table
-//input: column macroMolecule { semType: Macromolecule }
-//input: string methodName { choices:["UMAP", "t-SNE", "SPE"] }
+//input: column molecules { semType: Macromolecule }
+//input: string methodName { choices:["UMAP", "t-SNE"] }
 //input: string similarityMetric { choices:["Tanimoto", "Asymmetric", "Cosine", "Sokal"] }
 //input: bool plotEmbeddings = true
+//input: object options {optional: true}
+//editor: Bio:SequenceSpaceEditor
 export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: DG.Column, methodName: string,
-  similarityMetric: string = 'Tanimoto', plotEmbeddings: boolean): Promise<DG.Viewer | undefined> {
+  similarityMetric: string = 'Tanimoto', plotEmbeddings: boolean, options?: IUMAPOptions | ITSNEOptions): Promise<DG.Viewer | undefined> {
   // Delay is required for initial function dialog to close before starting invalidating of molfiles.
   // Otherwise, dialog is freezing
   await delay(10);
@@ -339,7 +385,8 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
     seqCol: withoutEmptyValues.col(macroMolecule.name)!,
     methodName: methodName,
     similarityMetric: similarityMetric,
-    embedAxesNames: embedColsNames
+    embedAxesNames: embedColsNames,
+    options: options
   };
   const sequenceSpaceRes = await sequenceSpaceByFingerprints(chemSpaceParams);
   const embeddings = sequenceSpaceRes.coordinates;
@@ -401,40 +448,76 @@ export async function toAtomicLevel(df: DG.DataFrame, macroMolecule: DG.Column):
 }
 
 //top-menu: Bio | MSA...
-//name: MSA
-//input: dataframe table
-//input: column sequence { semType: Macromolecule, units: ['fasta'], alphabet: ['DNA', 'RNA', 'PT'] }
-//output: column result
-export async function multipleSequenceAlignmentAny(
-  table: DG.DataFrame, sequence: DG.Column
-): Promise<DG.Column | null> {
-  const func: DG.Func = DG.Func.find({package: 'Bio', name: 'multipleSequenceAlignmentAny'})[0];
-
-  if (!checkInputColumnUi(sequence, 'MSA', ['fasta'], ['DNA', 'RNA', 'PT']))
-    return null;
-
-  const unUsedName = table.columns.getUnusedName(`msa(${sequence.name})`);
-  const msaCol = await runKalign(sequence, false, unUsedName);
-  table.columns.add(msaCol);
-
-  // This call is required to enable cell renderer activation
-  await grok.data.detectSemanticTypes(table);
-
-  // const tv: DG.TableView = grok.shell.tv;
-  // tv.grid.invalidate();
-  return msaCol;
-}
-
-//name: Bio | MSA
+//name: MSA...
 //tags: bio, panel
-//input: column sequence { semType: Macromolecule }
-//output: column result
-export async function panelMSA(sequence: DG.Column): Promise<DG.Column | null> {
-  return multipleSequenceAlignmentAny(sequence.dataFrame, sequence);
+export function multipleSequenceAlignmentAny(col: DG.Column<string> | null = null): void {
+  const table = col?.dataFrame ?? grok.shell.t;
+  const seqCol = col ?? table.columns.bySemType(DG.SEMTYPE.MACROMOLECULE);
+  if (seqCol == null) {
+    grok.shell.warning(`MSAError: dataset doesn't conain any Macromolecule column`);
+    return;
+  }
+
+  let performAlignment: () => Promise<DG.Column<string> | null> = async () => null;
+  const methodInput = ui.choiceInput('Method', pepseaMethods[0], pepseaMethods);
+  methodInput.setTooltip('Alignment method');
+  const gapOpenInput = ui.floatInput('Gap open', 1.53);
+  gapOpenInput.setTooltip('Gap opening penalty at group-to-group alignment');
+  const gapExtendInput = ui.floatInput('Gap extend', 0);
+  gapExtendInput.setTooltip('Gap extension penalty to skip the alignment');
+  const inputRootStyles = [methodInput.root.style, gapOpenInput.root.style, gapExtendInput.root.style];
+
+  const colInput = ui.columnInput('Sequence', table, seqCol, () => {
+    const potentialCol = colInput.value;
+    const unusedName = table.columns.getUnusedName(`msa(${potentialCol.name})`);
+
+    if (checkInputColumnUi(
+      potentialCol, potentialCol.name, [NOTATION.FASTA], [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT], false)) {
+      for (const inputRootStyle of inputRootStyles)
+        inputRootStyle.display = 'none';
+
+      performAlignment = () => runKalign(potentialCol, false, unusedName, clustersColInput.value);
+    } else if (checkInputColumnUi(potentialCol, potentialCol.name, [NOTATION.HELM], [], false)) {
+      for (const inputRootStyle of inputRootStyles)
+        inputRootStyle.display = 'initial';
+
+      performAlignment = () => runPepsea(potentialCol, unusedName, methodInput.value!, gapOpenInput.value!,
+        gapExtendInput.value!, clustersColInput.value);
+    } else {
+      for (const inputRootStyle of inputRootStyles)
+        inputRootStyle.display = 'none';
+
+      performAlignment = async () => null;
+    }
+  }) as DG.InputBase<DG.Column<string>>;
+  colInput.setTooltip('Sequences column to use for alignment');
+  colInput.fireChanged();
+
+  const clustersColInput = ui.columnInput('Clusters', table, null);
+  clustersColInput.nullable = true;
+
+  let msaCol: DG.Column<string> | null = null;
+  ui.dialog('MSA')
+    .add(colInput)
+    .add(clustersColInput)
+    .add(methodInput)
+    .add(gapOpenInput)
+    .add(gapExtendInput)
+    .onOK(async () => {
+      colInput.fireChanged();
+      msaCol = await performAlignment();
+      if (msaCol == null)
+        return grok.shell.warning('Wrong column format');
+
+      table.columns.add(msaCol);
+      await grok.data.detectSemanticTypes(table);
+    })
+    .show();
 }
 
 //name: Composition Analysis
 //top-menu: Bio | Composition Analysis
+//meta.icon: files/icons/composition-analysis.svg
 //output: viewer result
 export async function compositionAnalysis(): Promise<void> {
   // Higher priority for columns with MSA data to show with WebLogo.
@@ -491,8 +574,8 @@ export async function compositionAnalysis(): Promise<void> {
   await handler(col);
 }
 
-//top-menu: Bio | Sdf to Json lib...
-//name: sdfToJsonLib
+//top-menu: Bio | SDF to JSON lib...
+//name: SDF to JSON Lib
 //input: dataframe table
 export async function sdfToJsonLib(table: DG.DataFrame) {
   const jsonMonomerLibrary = createJsonMonomerLibFromSdf(table);
@@ -520,11 +603,10 @@ export function importFasta(fileContent: string): DG.DataFrame [] {
   return ffh.importFasta();
 }
 
-//name: Bio | Convert ...
-//friendly-name: Bio | Convert
-//tags: panel, bio
-//input: column col {semType: Macromolecule}
-export function convertPanel(col: DG.Column): void {
+//top-menu: Bio | Convert...
+//name: convertDialog
+export function convertDialog() {
+  const col = getMacromoleculeColumn();
   convert(col);
 }
 
@@ -587,17 +669,17 @@ export async function testDetectMacromolecule(path: string): Promise<DG.DataFram
   return resDf;
 }
 
-//name: Bio | Split to monomers
-//tags: panel, bio
-//input: column col {semType: Macromolecule}
-export function splitToMonomers(col: DG.Column<string>): void {
+//top-menu: Bio | Split to monomers
+//name: splitToMonomers
+export function splitToMonomers(): void {
+  const col = getMacromoleculeColumn();
   const tempDf = splitAlignedSequences(col);
   const originalDf = col.dataFrame;
   for (const tempCol of tempDf.columns) {
     const newCol = originalDf.columns.add(tempCol);
     newCol.semType = C.SEM_TYPES.MONOMER;
     newCol.setTag(DG.TAGS.CELL_RENDERER, C.SEM_TYPES.MONOMER);
-    newCol.setTag(C.TAGS.ALPHABET, col.getTag(C.TAGS.ALPHABET));
+    newCol.setTag(bioTAGS.alphabet, col.getTag(bioTAGS.alphabet));
   }
   grok.shell.tv.grid.invalidate();
 }
@@ -610,44 +692,46 @@ export function getHelmMonomers(sequence: DG.Column<string>): string[] {
 }
 
 
-//name: SequenceSimilaritySearchViewer
+//name: Sequence Similarity Search
 //tags: viewer
+//meta.icon: files/icons/sequence-similarity-viewer.svg
 //output: viewer result
 export function similaritySearchViewer(): SequenceSimilarityViewer {
   return new SequenceSimilarityViewer();
 }
 
-//top-menu: Bio | Similarity Search...
+//top-menu: Bio | Search | 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');
+  const viewer = view.addViewer('Sequence Similarity Search');
   view.dockManager.dock(viewer, 'down');
 }
 
-//name: SequenceDiversitySearchViewer
+//name: Sequence Diversity Search
 //tags: viewer
+//meta.icon: files/icons/sequence-diversity-viewer.svg
 //output: viewer result
 export function diversitySearchViewer(): SequenceDiversityViewer {
   return new SequenceDiversityViewer();
 }
 
-//top-menu: Bio | Diversity Search...
+//top-menu: Bio | Search | 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');
+  const viewer = view.addViewer('Sequence Diversity Search');
   view.dockManager.dock(viewer, 'down');
 }
 
-//name: Bio | Substructure search ...
-//tags: panel, bio
-//input: column col {semType: Macromolecule}
-export function bioSubstructureSearch(col: DG.Column): void {
+//top-menu: Bio | Substructure Search ...
+//name: bioSubstructureSearch
+export function bioSubstructureSearch(): void {
+  const col = getMacromoleculeColumn();
   substructureSearchDialog(col);
 }
 

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

@@ -2,11 +2,10 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import * as C from '../utils/constants';
 import {getMonomericMols} from '../calculations/monomerLevelMols';
 import {updateDivInnerHTML} from '../utils/ui-utils';
 import {delay} from '@datagrok-libraries/utils/src/test';
-import {NOTATION} from '@datagrok-libraries/bio';
+import {TAGS as bioTAGS, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 export const MONOMER_MOLS_COL = 'monomeric-mols';
 
@@ -16,14 +15,16 @@ export const enum MONOMERIC_COL_TAGS {
   MONOMERS_DICT = 'monomers-dict'
 }
 
+const SUBSTR_HELM_COL_NAME = 'substr_helm';
+
 /**
  * Searches substructure in each row of Macromolecule column
  *
  * @param {DG.column} col Column with 'Macromolecule' semantic type
  */
-export function substructureSearchDialog(col: DG.Column): void {
+export function substructureSearchDialog(col: DG.Column<string>): void {
   const units = col.getTag(DG.TAGS.UNITS);
-  const separator = col.getTag(C.TAGS.SEPARATOR);
+  const separator = col.getTag(bioTAGS.separator);
   // const notations = [NOTATION.FASTA, NOTATION.SEPARATOR, NOTATION.HELM];
 
   const substructureInput = ui.textInput('Substructure', '');
@@ -32,14 +33,15 @@ export function substructureSearchDialog(col: DG.Column): void {
     updateDivInnerHTML(inputsDiv, grid.root);
     await ui.tools.waitForElementInDom(grid.root);
     setTimeout(() => {
-      grid.cell('substr_helm', 0).element.children[0].dispatchEvent(new KeyboardEvent('keydown', {key: 'Enter'}));
+      grid.cell(SUBSTR_HELM_COL_NAME, 0).element.children[0].dispatchEvent(
+        new KeyboardEvent('keydown', {key: 'Enter'}));
     }, 100);
   });
 
   const df = DG.DataFrame.create(1);
-  df.columns.addNewString('substr_helm').init((i) => '');
-  df.col('substr_helm')!.semType = col.semType;
-  df.col('substr_helm')!.setTag(DG.TAGS.UNITS, NOTATION.HELM);
+  df.columns.addNewString(SUBSTR_HELM_COL_NAME).init((i) => '');
+  df.col(SUBSTR_HELM_COL_NAME)!.semType = col.semType;
+  df.col(SUBSTR_HELM_COL_NAME)!.setTag(DG.TAGS.UNITS, NOTATION.HELM);
   const grid = df.plot.grid();
   const separatorInput = ui.textInput('Separator', separator);
 
@@ -51,13 +53,13 @@ export function substructureSearchDialog(col: DG.Column): void {
 
   updateDivInnerHTML(inputsDiv, inputs);
 
-  ui.dialog('Substructure search')
+  ui.dialog('Substructure Search')
     .add(ui.divV([
       ui.divText(`Notation: ${units}`),
       inputsDiv
     ]))
     .onOK(async () => {
-      let substructure = units === NOTATION.HELM ? df.get('substr_helm', 0) : substructureInput.value;
+      let substructure = units === NOTATION.HELM ? df.get(SUBSTR_HELM_COL_NAME, 0) : substructureInput.value;
       if (units === NOTATION.SEPARATOR && separatorInput.value !== separator && separatorInput.value !== '')
         substructure = substructure.replaceAll(separatorInput.value, separator);
       const matchesColName = `Matches: ${substructure}`;
@@ -75,11 +77,11 @@ export function substructureSearchDialog(col: DG.Column): void {
     .show();
 }
 
-export function linearSubstructureSearch(substructure: string, col: DG.Column, separator?: string): DG.BitSet {
+export function linearSubstructureSearch(substructure: string, col: DG.Column<string>, 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);
+    const macromolecule: string = col.get(i)!;
     if (macromolecule.match(re) || macromolecule === substructure)
       resultArray.set(i, true, false);
   }
@@ -91,17 +93,18 @@ function prepareSubstructureRegex(substructure: string, separator: string) {
   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}` :
+  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<DG.BitSet> {
+export async function helmSubstructureSearch(substructure: string, col: DG.Column<string>): Promise<DG.BitSet> {
   if (col.version !== col.temp[MONOMERIC_COL_TAGS.LAST_INVALIDATED_VERSION])
     await invalidateMols(col, true);
-  const substructureCol = DG.Column.string('helm', 1).init((i) => substructure);
+  const substructureCol: DG.Column<string> = DG.Column.string('helm', 1).init((i) => substructure);
   substructureCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
   const substructureMolsCol =
     await getMonomericMols(substructureCol, true, col.temp[MONOMERIC_COL_TAGS.MONOMERS_DICT]);
@@ -113,7 +116,7 @@ export async function helmSubstructureSearch(substructure: string, col: DG.Colum
   return matchesCol.get(0);
 }
 
-export async function invalidateMols(col: DG.Column, pattern: boolean) {
+export async function invalidateMols(col: DG.Column<string>, pattern: boolean) {
   const progressBar = DG.TaskBarProgressIndicator.create(`Invalidating molfiles for ${col.name}`);
   await delay(10);
   const monomersDict = new Map();

package/src/tests/Palettes-test.ts

@@ -5,7 +5,7 @@ import * as DG from 'datagrok-api/dg';
 import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
 
 import {_testPaletteN, _testPaletteAA} from '@datagrok-libraries/bio/src/tests/palettes-tests';
-import { AminoacidsPalettes } from '@datagrok-libraries/bio';
+import {AminoacidsPalettes} from '@datagrok-libraries/bio/src/aminoacids';
 
 category('Palettes', () => {
   test('testPaletteN', async () => { await _testPaletteN(); });