@datagrok/bio 2.27.0 → 2.27.2

package/src/analysis/sequence-activity-cliffs.ts

@@ -181,12 +181,14 @@ export function createDifferencesWithPositions(
 }
 
 export function createLinesGrid(df: DG.DataFrame, colNames: string[]): DG.Grid {
-  const seqDiffCol = DG.Column.string('seq_diff', df.rowCount)
-    .init((i) => `${df.get(colNames[0], i)}#${df.get(colNames[1], i)}`);
-  seqDiffCol.semType = 'MacromoleculeDifference';
-  seqDiffCol.meta.units = df.col(colNames[0])!.meta.units;
-  seqDiffCol.setTag(bioTAGS.separator, df.col(colNames[0])!.getTag(bioTAGS.separator));
-  df.columns.add(seqDiffCol);
+  if (!df.col('seq_diff')) {
+    const seqDiffCol = DG.Column.string('seq_diff', df.rowCount)
+      .init((i) => `${df.get(colNames[0], i)}#${df.get(colNames[1], i)}`);
+    seqDiffCol.semType = 'MacromoleculeDifference';
+    seqDiffCol.meta.units = df.col(colNames[0])!.meta.units;
+    seqDiffCol.setTag(bioTAGS.separator, df.col(colNames[0])!.getTag(bioTAGS.separator));
+    df.columns.add(seqDiffCol);
+  }
   const grid = df.plot.grid();
   grid.col(colNames[0])!.visible = false;
   grid.col(colNames[1])!.visible = false;

package/src/package-api.ts

@@ -15,8 +15,8 @@ export namespace scripts {
   /**
   Converts molecules to HELM notation based on monomer library
   */
-  export async function molToHelmConverterPy(moleculesDataframe: DG.DataFrame , moleculesColumn: DG.Column , libraryJSON: string ): Promise<DG.DataFrame> {
-    return await grok.functions.call('Bio:MolToHelmConverterPy', { moleculesDataframe, moleculesColumn, libraryJSON });
+  export async function molToHelmConverterPy(moleculesDataframe: DG.DataFrame , moleculesColumn: DG.Column , libraryFile: DG.FileInfo ): Promise<DG.DataFrame> {
+    return await grok.functions.call('Bio:MolToHelmConverterPy', { moleculesDataframe, moleculesColumn, libraryFile });
   }
 
   /**

package/src/package.g.ts

@@ -456,6 +456,13 @@ export async function pepseaMsa(sequenceCol: DG.Column<any>, method: string, gap
   return await PackageFunctions.pepseaMsa(sequenceCol, method, gapOpen, gapExtend);
 }
 
+//name: Compare Sequences
+//description: Builds a MacromoleculeDifference column from two sequence columns (seq1#seq2)
+//top-menu: Bio | Analyze | Compare sequences...
+export function compareSequences() : void {
+  PackageFunctions.compareSequences();
+}
+
 //name: Composition Analysis
 //description: Visualizes sequence composition on a WebLogo plot
 //output: viewer result

package/src/package.ts

@@ -44,6 +44,7 @@ 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 {convert} from './utils/convert';
+import {compareSequencesUI} from './utils/compare-sequences';
 import {getMacromoleculeColumnPropertyPanel} from './widgets/representations';
 import {getMonomerInfoWidget} from './widgets/monomer-info-widget';
 import {saveAsFastaUI} from './utils/save-as-fasta';
@@ -810,7 +811,8 @@ export class PackageFunctions {
     // collect current monomer library
     const monomerLib = _package.monomerLib;
     const libJSON = JSON.stringify(monomerLib.toJSON());
-    await api.scripts.molToHelmConverterPy(table, molecules, libJSON);
+    const fileInfo = DG.FileInfo.fromString('monomerLib.json', libJSON);
+    await api.scripts.molToHelmConverterPy(table, molecules, fileInfo);
 
     // semtype is not automatically set, so we set it manually
     const newCol = table.columns.toList().find((c) => c.name.toLowerCase().includes('regenerated sequence') && c.semType !== DG.SEMTYPE.MACROMOLECULE);
@@ -991,6 +993,15 @@ export class PackageFunctions {
     return alignWithPepsea(sequenceCol, method, gapOpen, gapExtend);
   }
 
+  @grok.decorators.func({
+    name: 'Compare Sequences',
+    description: 'Builds a MacromoleculeDifference column from two sequence columns (seq1#seq2)',
+    'top-menu': 'Bio | Analyze | Compare sequences...',
+  })
+  static compareSequences(): void {
+    compareSequencesUI();
+  }
+
   @grok.decorators.func({
     name: 'Composition Analysis',
     description: 'Visualizes sequence composition on a WebLogo plot',

package/src/utils/annotations/annotation-manager-ui.ts

@@ -63,7 +63,7 @@ export function showAnnotationManagerDialog(): void {
         setColumnAnnotations(selectedCol, updated);
         df.fireValuesChanged();
         refreshList();
-      });
+      }, 'Delete');
       removeBtn.style.cursor = 'pointer';
       removeBtn.style.color = '#999';
       removeBtn.style.marginLeft = '8px';

package/src/utils/compare-sequences.ts

@@ -0,0 +1,104 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {SeqTemps} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
+
+import * as C from './constants';
+import {getMacromoleculeColumns} from './ui-utils';
+
+/** Builds a `MacromoleculeDifference` column from two sequence columns by encoding each row as
+ *  `seq1#seq2`. The result copies the relevant metadata (notation, separator, notation provider)
+ *  from `seqCol1` — callers are responsible for ensuring the two input columns are compatible. */
+export function compareSequencesDo(
+  seqCol1: DG.Column<string>, seqCol2: DG.Column<string>, resultName?: string,
+): DG.Column<string> {
+  const rowCount = Math.min(seqCol1.length, seqCol2.length);
+  const values: string[] = new Array(rowCount);
+  for (let i = 0; i < rowCount; i++) {
+    const v1 = seqCol1.get(i) ?? '';
+    const v2 = seqCol2.get(i) ?? '';
+    values[i] = `${v1}#${v2}`;
+  }
+
+  const name = resultName ?? `${seqCol1.name} vs ${seqCol2.name}`;
+  const diffCol = DG.Column.fromStrings(name, values);
+  diffCol.semType = C.SEM_TYPES.MACROMOLECULE_DIFFERENCE;
+
+  const sep = seqCol1.getTag(bioTAGS.separator);
+  if (sep != null) diffCol.tags[bioTAGS.separator] = sep;
+  const units = seqCol1.getTag(DG.TAGS.UNITS);
+  if (units != null) diffCol.tags[DG.TAGS.UNITS] = units;
+  const aligned = seqCol1.getTag(bioTAGS.aligned);
+  if (aligned != null) diffCol.tags[bioTAGS.aligned] = aligned;
+  const alphabet = seqCol1.getTag(bioTAGS.alphabet);
+  if (alphabet != null) diffCol.tags[bioTAGS.alphabet] = alphabet;
+
+  diffCol.tags[DG.TAGS.CELL_RENDERER] = C.SEM_TYPES.MACROMOLECULE_DIFFERENCE;
+  diffCol.temp[SeqTemps.notationProvider] = seqCol1.temp[SeqTemps.notationProvider];
+
+  return diffCol;
+}
+
+/** Validates that two macromolecule columns are compatible for pair-wise difference rendering:
+ *  identical notation/alignment/alphabet and (for separator notation) matching separator. */
+function checkColumnsCompatible(c1: DG.Column, c2: DG.Column): string | null {
+  if (c1 === c2) return 'Please choose two distinct columns';
+  if (c1.semType !== DG.SEMTYPE.MACROMOLECULE || c2.semType !== DG.SEMTYPE.MACROMOLECULE)
+    return 'Both columns must be Macromolecule semantic type';
+  if (c1.getTag(DG.TAGS.UNITS) !== c2.getTag(DG.TAGS.UNITS))
+    return 'Columns must use the same notation (units)';
+  if ((c1.getTag(bioTAGS.separator) ?? '') !== (c2.getTag(bioTAGS.separator) ?? ''))
+    return 'Columns must use the same separator';
+  if ((c1.getTag(bioTAGS.alphabet) ?? '') !== (c2.getTag(bioTAGS.alphabet) ?? ''))
+    return 'Columns must use the same alphabet';
+  return null;
+}
+
+/** Top-menu entry point for `Bio | Analyze | Compare sequences`. Opens a simple dialog to pick
+ *  two Macromolecule columns from the current table and appends a `MacromoleculeDifference`
+ *  column to the dataframe. */
+export function compareSequencesUI(): void {
+  const tv = grok.shell.tv;
+  if (!tv || !tv.dataFrame) {
+    grok.shell.error('No active table');
+    return;
+  }
+  const df = tv.dataFrame;
+  const cols: DG.Column[] = getMacromoleculeColumns();
+  if (cols.length < 2) {
+    grok.shell.error('Current table needs at least two Macromolecule columns');
+    return;
+  }
+
+  const names = cols.map((c) => c.name);
+  const col1Input = ui.input.choice('Sequence column 1', {value: names[0], items: names});
+  const col2Input = ui.input.choice('Sequence column 2', {value: names[1], items: names});
+  const resultNameInput = ui.input.string('Result column name', {value: ''});
+  resultNameInput.setTooltip('Leave empty to auto-generate from the chosen columns');
+
+  ui.dialog({title: 'Compare Sequences'})
+    .add(col1Input)
+    .add(col2Input)
+    .add(resultNameInput)
+    .onOK(() => {
+      const c1 = df.col(col1Input.value ?? '');
+      const c2 = df.col(col2Input.value ?? '');
+      if (!c1 || !c2) {
+        grok.shell.error('Could not resolve chosen columns');
+        return;
+      }
+      const err = checkColumnsCompatible(c1, c2);
+      if (err != null) {
+        grok.shell.error(err);
+        return;
+      }
+      const desired = (resultNameInput.value ?? '').trim() || `${c1.name} vs ${c2.name}`;
+      const name = df.columns.getUnusedName(desired);
+      const diffCol = compareSequencesDo(
+        c1 as DG.Column<string>, c2 as DG.Column<string>, name);
+      df.columns.add(diffCol);
+    })
+    .show();
+}

package/src/utils/monomer-lib/library-file-manager/ui.ts

@@ -198,7 +198,7 @@ class LibraryControlsManager {
       updateLibrarySelectionStatus(libInput.value, libFileName);
     }});
     ui.tooltip.bind(libInput.root, `Include monomers from ${libFileName}`);
-    const deleteIcon = ui.iconFA('trash-alt', () => this.promptForLibraryDeletion(libFileName));
+    const deleteIcon = ui.iconFA('trash-alt', () => this.promptForLibraryDeletion(libFileName), 'Delete');
     const editIcon = ui.icons.edit(async () => {
       grok.shell.v = await (await MonomerManager.getInstance()).getViewRoot(libFileName);
     }, 'Edit monomer library');

package/src/utils/monomer-lib/monomer-manager/monomer-manager.ts

@@ -486,7 +486,7 @@ export class MonomerManager implements IMonomerManager {
       }
       const monomer = await monomerFromDfRow(this.tv!.dataFrame.rows.get(currentRowIdx));
       await this._newMonomerForm.removeMonomers([monomer], this.libInput.value!);
-    });
+    }, 'Delete');
 
     ui.tooltip.bind(deleteButton, () =>
       `${(this.tv?.dataFrame?.selection?.trueCount ?? 0) > 0 ? 'Delete selected monomers' : 'Delete monomer'}`);

package/src/utils/multiple-sequence-alignment-ui.ts

@@ -93,7 +93,7 @@ export async function multipleSequenceAlignmentUI(
         });
       }, 'Adjust alignment parameters such as penalties for opening and extending gaps');
       kalignParamsButton.classList.add('msa-params-button');
-      kalignParamsButton.prepend(ui.icons.settings(() => null));
+      kalignParamsButton.prepend(ui.icons.settings(() => null, 'Settings'));
 
       const kalignElements = [kalignParamsDiv, kalignParamsButton, kalignVersionDiv];
 
@@ -118,7 +118,7 @@ export async function multipleSequenceAlignmentUI(
         engineParamsDiv.hidden = !engineParamsDiv.hidden;
       }, 'Adjust engine-specific alignment parameters');
       engineParamsButton.classList.add('msa-params-button');
-      engineParamsButton.prepend(ui.icons.settings(() => null));
+      engineParamsButton.prepend(ui.icons.settings(() => null, 'Settings'));
 
       // "Include HELM" checkbox: shown when column has a notation provider with fromHelm
       const includeHelmInput = ui.input.bool('Include HELM', {value: true});