@datagrok/bio 2.22.1 → 2.22.4

package/src/package-api.ts

@@ -0,0 +1,417 @@
+/**
+This file is auto-generated by the grok api command.
+If you notice any changes, please push them to the repository.
+Do not edit this file manually.
+*/
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+
+export namespace scripts {
+  export async function embed(molecule: string ): Promise<string> {
+    return await grok.functions.call('Bio:Embed', { molecule });
+  }
+
+  /**
+  Create the model peptides/DNA sequences with peptides data
+  */
+  export async function sequenceGenerator(clusters: number , num_sequences: number , alphabet_key: string , motif_length: number , max_variants_position: number , random_length: number , dispersion: number , activity_range: number , cliff_probability: number , cliff_strength: number , cliff_strength_dispersion: number , assay_noise_levels: string , assay_scales: string , disable_negatives: boolean , fasta_separator: string | null, helm_library_file: DG.FileInfo | null, helm_connection_mode: string ): Promise<DG.DataFrame> {
+    return await grok.functions.call('Bio:SequenceGenerator', { clusters, num_sequences, alphabet_key, motif_length, max_variants_position, random_length, dispersion, activity_range, cliff_probability, cliff_strength, cliff_strength_dispersion, assay_noise_levels, assay_scales, disable_negatives, fasta_separator, helm_library_file, helm_connection_mode });
+  }
+}
+
+export namespace funcs {
+  /**
+  Returns an instance of the monomer library helper
+  */
+  export async function getMonomerLibHelper(): Promise<any> {
+    return await grok.functions.call('Bio:GetMonomerLibHelper', {});
+  }
+
+  export async function initBio(): Promise<void> {
+    return await grok.functions.call('Bio:InitBio', {});
+  }
+
+  export async function sequenceTooltip(col: DG.Column ): Promise<any> {
+    return await grok.functions.call('Bio:SequenceTooltip', { col });
+  }
+
+  export async function getBioLib(): Promise<any> {
+    return await grok.functions.call('Bio:GetBioLib', {});
+  }
+
+  export async function getSeqHandler(sequence: DG.Column ): Promise<any> {
+    return await grok.functions.call('Bio:GetSeqHandler', { sequence });
+  }
+
+  /**
+  Creates a new column with sequences of the region between start and end
+  */
+  export async function getRegionPanel(seqCol: DG.Column ): Promise<any> {
+    return await grok.functions.call('Bio:GetRegionPanel', { seqCol });
+  }
+
+  /**
+  //tags: panel, exclude-actions-panel
+  */
+  export async function libraryPanel(seqColumn: DG.Column ): Promise<any> {
+    return await grok.functions.call('Bio:LibraryPanel', { seqColumn });
+  }
+
+  export async function getRegionEditor(call: any ): Promise<void> {
+    return await grok.functions.call('Bio:GetRegionEditor', { call });
+  }
+
+  export async function splitToMonomersEditor(call: any ): Promise<void> {
+    return await grok.functions.call('Bio:SplitToMonomersEditor', { call });
+  }
+
+  export async function sequenceSpaceEditor(call: any ): Promise<void> {
+    return await grok.functions.call('Bio:SequenceSpaceEditor', { call });
+  }
+
+  export async function seqActivityCliffsEditor(call: any ): Promise<void> {
+    return await grok.functions.call('Bio:SeqActivityCliffsEditor', { call });
+  }
+
+  export async function customSequenceCellRenderer(): Promise<any> {
+    return await grok.functions.call('Bio:CustomSequenceCellRenderer', {});
+  }
+
+  export async function fastaSequenceCellRenderer(): Promise<any> {
+    return await grok.functions.call('Bio:FastaSequenceCellRenderer', {});
+  }
+
+  export async function separatorSequenceCellRenderer(): Promise<any> {
+    return await grok.functions.call('Bio:SeparatorSequenceCellRenderer', {});
+  }
+
+  export async function macroMolColumnPropertyPanel(molColumn: DG.Column ): Promise<any> {
+    return await grok.functions.call('Bio:MacroMolColumnPropertyPanel', { molColumn });
+  }
+
+  export async function compositionAnalysisWidget(sequence: any ): Promise<any> {
+    return await grok.functions.call('Bio:CompositionAnalysisWidget', { sequence });
+  }
+
+  export async function macromoleculeDifferenceCellRenderer(): Promise<any> {
+    return await grok.functions.call('Bio:MacromoleculeDifferenceCellRenderer', {});
+  }
+
+  export async function sequenceAlignment(alignType: string , alignTable: string , gap: number , seq1: string , seq2: string ): Promise<any> {
+    return await grok.functions.call('Bio:SequenceAlignment', { alignType, alignTable, gap, seq1, seq2 });
+  }
+
+  /**
+  WebLogo
+  */
+  export async function webLogoViewer(): Promise<any> {
+    return await grok.functions.call('Bio:WebLogoViewer', {});
+  }
+
+  /**
+  V-Domain regions viewer
+  */
+  export async function vdRegionsViewer(): Promise<any> {
+    return await grok.functions.call('Bio:VdRegionsViewer', {});
+  }
+
+  /**
+  Gets a new column with sequences of the region between start and end
+  */
+  export async function getRegion(sequence: DG.Column , start?: string , end?: string , name?: string ): Promise<DG.Column> {
+    return await grok.functions.call('Bio:GetRegion', { sequence, start, end, name });
+  }
+
+  /**
+  Get sequences for a region specified from a Macromolecule
+  */
+  export async function getRegionTopMenu(table: DG.DataFrame , sequence: DG.Column , start?: string , end?: string , name?: string ): Promise<void> {
+    return await grok.functions.call('Bio:GetRegionTopMenu', { table, sequence, start, end, name });
+  }
+
+  /**
+  Detects pairs of molecules with similar structure and significant difference in any given property
+  */
+  export async function activityCliffs(table: DG.DataFrame , molecules: DG.Column , activities: DG.Column , similarity: number , methodName: string , similarityMetric: string , preprocessingFunction: any , options?: any , demo?: boolean ): Promise<void> {
+    return await grok.functions.call('Bio:ActivityCliffs', { table, molecules, activities, similarity, methodName, similarityMetric, preprocessingFunction, options, demo });
+  }
+
+  export async function macromoleculePreprocessingFunction(col: DG.Column , metric: string , gapOpen?: number , gapExtend?: number , fingerprintType?: string ): Promise<any> {
+    return await grok.functions.call('Bio:MacromoleculePreprocessingFunction', { col, metric, gapOpen, gapExtend, fingerprintType });
+  }
+
+  export async function helmPreprocessingFunction(col: DG.Column , _metric: string ): Promise<any> {
+    return await grok.functions.call('Bio:HelmPreprocessingFunction', { col, _metric });
+  }
+
+  /**
+  Creates 2D sequence space with projected sequences by pairwise distance
+  */
+  export async function sequenceSpaceTopMenu(table: DG.DataFrame , molecules: DG.Column , methodName: string , similarityMetric: string , plotEmbeddings: boolean , preprocessingFunction?: any , options?: any , clusterEmbeddings?: boolean , isDemo?: boolean ): Promise<void> {
+    return await grok.functions.call('Bio:SequenceSpaceTopMenu', { table, molecules, methodName, similarityMetric, plotEmbeddings, preprocessingFunction, options, clusterEmbeddings, isDemo });
+  }
+
+  /**
+  Converts sequences to molblocks
+  */
+  export async function toAtomicLevel(table: DG.DataFrame , seqCol: DG.Column , nonlinear: boolean , highlight: boolean ): Promise<void> {
+    return await grok.functions.call('Bio:ToAtomicLevel', { table, seqCol, nonlinear, highlight });
+  }
+
+  export async function toAtomicLevelAction(seqCol: DG.Column ): Promise<void> {
+    return await grok.functions.call('Bio:ToAtomicLevelAction', { seqCol });
+  }
+
+  export async function toAtomicLevelPanel(sequence: any ): Promise<any> {
+    return await grok.functions.call('Bio:ToAtomicLevelPanel', { sequence });
+  }
+
+  export async function sequence3dStructureWidget(sequence: any ): Promise<any> {
+    return await grok.functions.call('Bio:Sequence3dStructureWidget', { sequence });
+  }
+
+  /**
+  Performs multiple sequence alignment
+  */
+  export async function multipleSequenceAlignmentDialog(): Promise<void> {
+    return await grok.functions.call('Bio:MultipleSequenceAlignmentDialog', {});
+  }
+
+  /**
+  Multiple sequence alignment
+  */
+  export async function alignSequences(sequenceCol: DG.Column , clustersCol: DG.Column , options?: any ): Promise<DG.Column> {
+    return await grok.functions.call('Bio:AlignSequences', { sequenceCol, clustersCol, options });
+  }
+
+  /**
+  Visualizes sequence composition on a WebLogo plot
+  */
+  export async function compositionAnalysis(): Promise<any> {
+    return await grok.functions.call('Bio:CompositionAnalysis', {});
+  }
+
+  /**
+  Opens FASTA file
+  */
+  export async function importFasta(fileContent: string ): Promise<any> {
+    return await grok.functions.call('Bio:ImportFasta', { fileContent });
+  }
+
+  /**
+  Opens Bam file
+  */
+  export async function importBam(fileContent: string ): Promise<any> {
+    return await grok.functions.call('Bio:ImportBam', { fileContent });
+  }
+
+  export async function convertDialog(): Promise<void> {
+    return await grok.functions.call('Bio:ConvertDialog', {});
+  }
+
+  export async function convertColumnAction(col: DG.Column ): Promise<void> {
+    return await grok.functions.call('Bio:ConvertColumnAction', { col });
+  }
+
+  export async function monomerCellRenderer(): Promise<any> {
+    return await grok.functions.call('Bio:MonomerCellRenderer', {});
+  }
+
+  export async function testDetectMacromolecule(path: string ): Promise<DG.DataFrame> {
+    return await grok.functions.call('Bio:TestDetectMacromolecule', { path });
+  }
+
+  export async function splitToMonomersTopMenu(table: DG.DataFrame , sequence: DG.Column ): Promise<DG.DataFrame> {
+    return await grok.functions.call('Bio:SplitToMonomersTopMenu', { table, sequence });
+  }
+
+  export async function getHelmMonomers(sequence: DG.Column ): Promise<any> {
+    return await grok.functions.call('Bio:GetHelmMonomers', { sequence });
+  }
+
+  export async function similaritySearchViewer(): Promise<any> {
+    return await grok.functions.call('Bio:SimilaritySearchViewer', {});
+  }
+
+  /**
+  Finds similar sequences
+  */
+  export async function similaritySearchTopMenu(): Promise<any> {
+    return await grok.functions.call('Bio:SimilaritySearchTopMenu', {});
+  }
+
+  export async function diversitySearchViewer(): Promise<any> {
+    return await grok.functions.call('Bio:DiversitySearchViewer', {});
+  }
+
+  /**
+  Finds the most diverse sequences
+  */
+  export async function diversitySearchTopMenu(): Promise<any> {
+    return await grok.functions.call('Bio:DiversitySearchTopMenu', {});
+  }
+
+  export async function searchSubsequenceEditor(call: any ): Promise<void> {
+    return await grok.functions.call('Bio:SearchSubsequenceEditor', { call });
+  }
+
+  export async function subsequenceSearchTopMenu(macromolecules: DG.Column ): Promise<void> {
+    return await grok.functions.call('Bio:SubsequenceSearchTopMenu', { macromolecules });
+  }
+
+  /**
+  Adds a column with fraction of matching monomers
+  */
+  export async function sequenceIdentityScoring(table: DG.DataFrame , macromolecule: DG.Column , reference: string ): Promise<DG.Column> {
+    return await grok.functions.call('Bio:SequenceIdentityScoring', { table, macromolecule, reference });
+  }
+
+  /**
+  Adds a column with similarity scores, calculated as sum of monomer fingerprint similarities
+  */
+  export async function sequenceSimilarityScoring(table: DG.DataFrame , macromolecule: DG.Column , reference: string ): Promise<DG.Column> {
+    return await grok.functions.call('Bio:SequenceSimilarityScoring', { table, macromolecule, reference });
+  }
+
+  /**
+  Manage HELM monomer libraries
+  */
+  export async function manageMonomerLibraries(): Promise<void> {
+    return await grok.functions.call('Bio:ManageMonomerLibraries', {});
+  }
+
+  export async function manageLibrariesView(): Promise<void> {
+    return await grok.functions.call('Bio:ManageLibrariesView', {});
+  }
+
+  /**
+  Edit and create monomers
+  */
+  export async function manageMonomersView(): Promise<void> {
+    return await grok.functions.call('Bio:ManageMonomersView', {});
+  }
+
+  export async function manageMonomerLibrariesView(): Promise<DG.View> {
+    return await grok.functions.call('Bio:ManageMonomerLibrariesView', {});
+  }
+
+  export async function manageMonomerLibrariesViewTreeBrowser(treeNode: any , browsePanel: any ): Promise<void> {
+    return await grok.functions.call('Bio:ManageMonomerLibrariesViewTreeBrowser', { treeNode, browsePanel });
+  }
+
+  /**
+  As FASTA...
+  */
+  export async function saveAsFasta(): Promise<void> {
+    return await grok.functions.call('Bio:SaveAsFasta', {});
+  }
+
+  /**
+  Substructure filter for macromolecules
+  */
+  export async function bioSubstructureFilter(): Promise<any> {
+    return await grok.functions.call('Bio:BioSubstructureFilter', {});
+  }
+
+  /**
+  Substructure filter for Helm package tests
+  */
+  export async function bioSubstructureFilterTest(): Promise<any> {
+    return await grok.functions.call('Bio:BioSubstructureFilterTest', {});
+  }
+
+  export async function webLogoLargeApp(): Promise<void> {
+    return await grok.functions.call('Bio:WebLogoLargeApp', {});
+  }
+
+  export async function webLogoAggApp(): Promise<void> {
+    return await grok.functions.call('Bio:WebLogoAggApp', {});
+  }
+
+  export async function getRegionApp(): Promise<void> {
+    return await grok.functions.call('Bio:GetRegionApp', {});
+  }
+
+  export async function getRegionHelmApp(): Promise<void> {
+    return await grok.functions.call('Bio:GetRegionHelmApp', {});
+  }
+
+  export async function longSeqTableSeparator(): Promise<void> {
+    return await grok.functions.call('Bio:LongSeqTableSeparator', {});
+  }
+
+  export async function longSeqTableFasta(): Promise<void> {
+    return await grok.functions.call('Bio:LongSeqTableFasta', {});
+  }
+
+  export async function longSeqTableHelm(): Promise<void> {
+    return await grok.functions.call('Bio:LongSeqTableHelm', {});
+  }
+
+  export async function addCopyMenu(cell: any , menu: any ): Promise<void> {
+    return await grok.functions.call('Bio:AddCopyMenu', { cell, menu });
+  }
+
+  /**
+  Sequence similarity tracking and evaluation dataset diversity
+  */
+  export async function demoBioSimilarityDiversity(): Promise<void> {
+    return await grok.functions.call('Bio:DemoBioSimilarityDiversity', {});
+  }
+
+  /**
+  Exploring sequence space of Macromolecules, comparison with hierarchical clustering results
+  */
+  export async function demoBioSequenceSpace(): Promise<void> {
+    return await grok.functions.call('Bio:DemoBioSequenceSpace', {});
+  }
+
+  /**
+  Activity Cliffs analysis on Macromolecules data
+  */
+  export async function demoBioActivityCliffs(): Promise<void> {
+    return await grok.functions.call('Bio:DemoBioActivityCliffs', {});
+  }
+
+  /**
+  Atomic level structure of Macromolecules
+  */
+  export async function demoBioAtomicLevel(): Promise<void> {
+    return await grok.functions.call('Bio:DemoBioAtomicLevel', {});
+  }
+
+  export async function sdfToJsonLib(table: DG.DataFrame ): Promise<void> {
+    return await grok.functions.call('Bio:SdfToJsonLib', { table });
+  }
+
+  /**
+  Converts a `Macromolecule` sequence to its atomic level `Molecule` representation
+  */
+  export async function seq2atomic(seq: string , nonlinear: boolean ): Promise<string> {
+    return await grok.functions.call('Bio:Seq2atomic', { seq, nonlinear });
+  }
+
+  /**
+  Gets identity to a reference sequence
+  */
+  export async function seqIdentity(seq: string , ref: string ): Promise<number> {
+    return await grok.functions.call('Bio:SeqIdentity', { seq, ref });
+  }
+
+  export async function detectMacromoleculeProbe(file: DG.FileInfo , colName: string , probeCount: number ): Promise<void> {
+    return await grok.functions.call('Bio:DetectMacromoleculeProbe', { file, colName, probeCount });
+  }
+
+  export async function getSeqHelper(): Promise<any> {
+    return await grok.functions.call('Bio:GetSeqHelper', {});
+  }
+
+  export async function getMolFromHelm(df: DG.DataFrame , helmCol: DG.Column , chiralityEngine: boolean ): Promise<DG.Column> {
+    return await grok.functions.call('Bio:GetMolFromHelm', { df, helmCol, chiralityEngine });
+  }
+
+  export async function test1(): Promise<any> {
+    return await grok.functions.call('Bio:Test1', {});
+  }
+}

package/src/package.g.ts

@@ -0,0 +1 @@
+import * as DG from 'datagrok-api/dg';

package/src/package.ts

@@ -74,7 +74,7 @@ import {MonomerManager} from './utils/monomer-lib/monomer-manager/monomer-manage
 import {calculateScoresWithEmptyValues} from './utils/calculate-scores';
 import {SeqHelper} from './utils/seq-helper/seq-helper';
 import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
-import {toAtomicLevelWidget} from './widgets/to-atomic-level-widget';
+import {molecular3DStructureWidget, toAtomicLevelWidget} from './widgets/to-atomic-level-widget';
 import {handleSequenceHeaderRendering} from './widgets/sequence-scrolling-widget';
 export const _package = new BioPackage(/*{debug: true}/**/);
 
@@ -455,17 +455,17 @@ export async function getRegionTopMenu(
 //input: func preprocessingFunction
 //input: object options {optional: true}
 //input: bool demo {optional: true}
-//output: viewer result
 //editor: Bio:SeqActivityCliffsEditor
 export async function activityCliffs(table: DG.DataFrame, molecules: DG.Column<string>, activities: DG.Column,
   similarity: number, methodName: DimReductionMethods,
   similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics, preprocessingFunction: DG.Func,
   options?: (IUMAPOptions | ITSNEOptions) & Options, demo?: boolean): Promise<DG.Viewer | undefined> {
   //workaround for functions which add viewers to tableView (can be run only on active table view)
-  if (table.name !== grok.shell.tv.dataFrame.name) {
+  if (table !== grok.shell.tv.dataFrame) {
     grok.shell.error(`Table ${table.name} is not a current table view`);
     return;
   }
+  const tv = grok.shell.tv;
   if (!checkInputColumnUI(molecules, 'Activity Cliffs'))
     return;
   const axesNames = getEmbeddingColsNames(table);
@@ -509,7 +509,7 @@ export async function activityCliffs(table: DG.DataFrame, molecules: DG.Column<s
   }
 
   const pi = DG.TaskBarProgressIndicator.create(`Running sequence activity cliffs ...`);
-  return new Promise<DG.Viewer | undefined>((resolve, reject) => {
+  const scRes = (await new Promise<DG.Viewer | undefined>((resolve, reject) => {
     if (table.rowCount > fastRowCount && !options?.[BYPASS_LARGE_DATA_WARNING]) {
       ui.dialog().add(ui.divText(`Activity cliffs analysis might take several minutes.
     Do you want to continue?`))
@@ -524,7 +524,13 @@ export async function activityCliffs(table: DG.DataFrame, molecules: DG.Column<s
     const [errMsg, errStack] = errInfo(err);
     _package.logger.error(errMsg, undefined, errStack);
     throw err;
-  }).finally(() => { pi.close(); });
+  }).finally(() => { pi.close(); })) as DG.ScatterPlotViewer | undefined;
+  if (scRes?.props?.xColumnName && scRes?.props?.yColumnName && table.col(scRes.props.xColumnName) && table.col(scRes.props.yColumnName)) {
+    table.col(scRes.props.xColumnName)!.set(0, table.col(scRes.props.xColumnName)!.get(0)); // to trigger rendering
+    table.col(scRes.props.yColumnName)!.set(0, table.col(scRes.props.yColumnName)!.get(0)); // to trigger rendering
+  }
+
+  return scRes;
 }
 
 //name: Encode Sequences
@@ -544,8 +550,9 @@ export async function macromoleculePreprocessingFunction(
   fingerprintType = 'Morgan'): Promise<PreprocessFunctionReturnType> {
   if (col.semType !== DG.SEMTYPE.MACROMOLECULE)
     return {entries: col.toList(), options: {}};
-  const {seqList, options} = await getEncodedSeqSpaceCol(col, metric, fingerprintType);
-  return {entries: seqList, options: {...options, gapOpen, gapExtend}};
+
+  const {seqList, options} = await getEncodedSeqSpaceCol(col, metric, fingerprintType, gapOpen, gapExtend);
+  return {entries: seqList, options};
 }
 
 //name: Helm Fingerprints
@@ -658,6 +665,14 @@ export async function toAtomicLevelPanel(sequence: DG.SemanticValue): Promise<DG
   return toAtomicLevelWidget(sequence);
 }
 
+//name: Molecular 3D Structure
+//tags: panel, bio, widgets
+//input: semantic_value sequence { semType: Macromolecule }
+//output: widget result
+export async function sequence3dStructureWidget(sequence: DG.SemanticValue): Promise<DG.Widget> {
+  return molecular3DStructureWidget(sequence);
+}
+
 //top-menu: Bio | Analyze | MSA...
 //name: MSA
 //description: Performs multiple sequence alignment
@@ -986,7 +1001,7 @@ export async function manageMonomerLibrariesView(): Promise<DG.View> {
 //name: Monomer Manager Tree Browser
 //input: dynamic treeNode
 //input: dynamic browsePanel
-export async function manageLibrariesAppTreeBrowser(treeNode: DG.TreeViewGroup, browsePanel: DG.BrowsePanel) {
+export async function manageMonomerLibrariesViewTreeBrowser(treeNode: DG.TreeViewGroup, browsePanel: DG.BrowsePanel) {
   const libraries = (await (await MonomerLibManager.getInstance()).getFileManager()).getValidLibraryPaths();
   libraries.forEach((libName) => {
     const nodeName = libName.endsWith('.json') ? libName.substring(0, libName.length - 5) : libName;
@@ -1100,7 +1115,7 @@ export function longSeqTableHelm(): void {
 
 // -- Handle context menu --
 
-///name: addCopyMenu
+//name: addCopyMenu
 //input: object cell
 //input: object menu
 export function addCopyMenu(cell: DG.Cell, menu: DG.Menu): void {

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

@@ -12,7 +12,7 @@ export async function _testActivityCliffsOpen(df: DG.DataFrame, drMethod: DimRed
   similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics, preprocessingFunction: DG.Func,
 ): Promise<void> {
   await grok.data.detectSemanticTypes(df);
-  const scatterPlot = (await grok.functions.call('Bio:activityCliffs', {
+  (await grok.functions.call('Bio:activityCliffs', {
     table: df,
     molecules: df.getCol(seqColName),
     activities: df.getCol(activityColName),
@@ -23,7 +23,8 @@ export async function _testActivityCliffsOpen(df: DG.DataFrame, drMethod: DimRed
     options: {[`${BYPASS_LARGE_DATA_WARNING}`]: true},
     demo: false,
   })) as DG.Viewer | undefined;
-  expect(scatterPlot != null, true);
+  const scatterPlot = Array.from(grok.shell.tv.viewers)[1];
+  expect(scatterPlot?.type === DG.VIEWER.SCATTER_PLOT, true);
 
   await awaitCheck(() => {
     const link = Array.from(scatterPlot!.root.getElementsByClassName('scatter_plot_link'));

package/src/tests/msa-tests.ts

@@ -140,7 +140,7 @@ async function _testMsaIsCorrect(srcCsv: string, tgtCsv: string): Promise<void>
   expect(srcCol.semType, DG.SEMTYPE.MACROMOLECULE);
 
   const tgtCol: DG.Column = tgtDf.getCol('seq')!;
-  const resCol: DG.Column = await runKalign(srcCol, true);
+  const resCol: DG.Column = await runKalign(srcDf, srcCol, true);
   expectArray(resCol.toList(), tgtCol.toList());
 }
 

package/src/tests/pepsea-tests.ts

@@ -31,7 +31,7 @@ category('PepSeA', () => {
 
   test('Basic alignment', async () => {
     const df = DG.DataFrame.fromCsv(testCsv);
-    const resMsaCol = await runPepsea(df.getCol('HELM'), 'msa(HELM)');
+    const resMsaCol = await runPepsea(df, df.getCol('HELM'), 'msa(HELM)');
     const tgtMsaCol = df.getCol('MSA');
     for (let i = 0; i < resMsaCol!.length; ++i)
       expect(resMsaCol!.get(i) == tgtMsaCol.get(i), true);
@@ -40,7 +40,7 @@ category('PepSeA', () => {
   test('stderr', async () => {
     const logger = new TestLogger();
     const df = DG.DataFrame.fromCsv(pepseaStderrCsv);
-    const resMsaCol = await runPepsea(df.getCol('HELM'), 'msa(HELM)',
+    const resMsaCol = await runPepsea(df, df.getCol('HELM'), 'msa(HELM)',
       undefined, undefined, undefined, undefined, logger);
     const tgtMsaCol = df.getCol('MSA');
     expectArray(resMsaCol!.toList(), tgtMsaCol.toList());
@@ -51,7 +51,7 @@ category('PepSeA', () => {
     const logger = new TestLogger();
     try {
       const df = DG.DataFrame.fromCsv(pepseaErrorCsv);
-      const _resMsaCol = await runPepsea(df.getCol('HELM'), 'msa(HELM)',
+      const _resMsaCol = await runPepsea(df, df.getCol('HELM'), 'msa(HELM)',
         undefined, undefined, undefined, undefined, logger);
     } catch (err: any) {
       const [errMsg, errStack] = errInfo(err);

package/src/tests/similarity-diversity-tests.ts

@@ -48,17 +48,17 @@ async function _testSimilaritySearchViewer() {
 
   /* eslint-disable max-len */
   const str0: string = 'D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me';
-  const str1: string = 'Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/Chg/N/D-Orn/D-aThr//Phe_4Me';
+  const str1: string = '/D-Tyr_Et/meQ/dV/E/N/dV///Phe_4Me';
   const simStr1: string = 'meI/hHis/Aca/Cys_SEt/T/dK/Thr_PO3H2/Aca/Tyr_PO3H2/D-Chg/dV/Phe_ab-dehydro/N/D-Orn/D-aThr//Phe_4Me';
   /* eslint-enable max-len */
 
   expect(similaritySearchViewer.fingerprint, 'Morgan');
-  expect(similaritySearchViewer.distanceMetric, 'Tanimoto');
+  expect(similaritySearchViewer.distanceMetric, 'Hamming');
   expect(similaritySearchViewer.scores!.get(0), DG.FLOAT_NULL);
   expect(similaritySearchViewer.idxs!.get(0), 0);
   expect(similaritySearchViewer.molCol!.get(0), str0);
-  expect((similaritySearchViewer.scores!.get(1) as number).toFixed(2), '0.73');
-  expect(similaritySearchViewer.idxs!.get(1), 4);
+  expect((similaritySearchViewer.scores!.get(1) as number).toFixed(2), '0.10');
+  expect(similaritySearchViewer.idxs!.get(1), 7);
   expect(similaritySearchViewer.molCol!.get(1), str1);
   moleculesView.dataFrame.currentRowIdx = 1;
   await awaitCheck(() => similaritySearchViewer.targetMoleculeIdx === 1,
@@ -98,7 +98,7 @@ async function _testDiversitySearchViewer() {
     'Sequence Diversity Search viewer grid has not been created', 100);
 
   expect(diversitySearchViewer.fingerprint, 'Morgan');
-  expect(diversitySearchViewer.distanceMetric, 'Tanimoto');
+  expect(diversitySearchViewer.distanceMetric, 'Hamming');
   expect(diversitySearchViewer.initialized, true);
   expect(diversitySearchViewer.renderMolIds!.length > 0, true);
 }

package/src/utils/context-menu.ts

@@ -1,30 +1,31 @@
+/* eslint-disable max-len */
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 import {_package} from '../package';
+import {TAGS as bioTags} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 
 export function addCopyMenuUI(cell: DG.Cell, menu: DG.Menu, seqHelper: ISeqHelper): void {
-  const sh = seqHelper.getSeqHandler(cell.column);
-  const tgtNotationList: string[] = Object.values(NOTATION).filter((v) => v !== sh.units);
+  const tgtNotationList: string[] = Object.values(NOTATION).filter((v) => v !== NOTATION.CUSTOM);
 
   menu.group('Copy')
     .items(tgtNotationList, (tgtNotation) => {
       const srcCol = cell.column;
       const srcRowIdx = cell.rowIndex;
       const srcSh = seqHelper.getSeqHandler(srcCol);
-      const separator = tgtNotation === NOTATION.SEPARATOR ? _package.properties.defaultSeparator : undefined;
+      const separator = tgtNotation === NOTATION.SEPARATOR ? (_package.properties.defaultSeparator ?? '-') : undefined;
       const joiner = srcSh.getJoiner({notation: tgtNotation as NOTATION, separator});
       const srcSS = srcSh.getSplitted(srcRowIdx);
       const tgtSeq = joiner(srcSS);
 
-      if (!navigator.clipboard) {
+      if (!navigator.clipboard)
         grok.shell.warning('The clipboard functionality requires a secure origin — either HTTPS or localhost');
-      } else {
+      else {
         navigator.clipboard.writeText(tgtSeq);
         grok.shell.info(`Value of notation '${tgtNotation}' copied to clipboard`);
       }

package/src/utils/helm-to-molfile/converter/mol-wrapper.ts

@@ -16,7 +16,7 @@ export abstract class MolfileWrapper {
   protected shiftR1GroupToOrigin(): void {
     const r1Idx = this.rGroups.getAtomicIdx(1);
     if (r1Idx === null)
-      throw new Error(`Cannot find R1 group for monomer ${this.monomerSymbol}`);
+      return; // R1 group is not present, nothing to shift
     const {x, y} = this.atoms.atomCoordinates[r1Idx];
     this.atoms.shift({x: -x, y: -y});
   }