@datagrok/bio 2.27.1 → 2.27.2

package/package.json

@@ -5,7 +5,7 @@
     "name": "Davit Rizhinashvili",
     "email": "drizhinashvili@datagrok.ai"
   },
-  "version": "2.27.1",
+  "version": "2.27.2",
   "description": "Bioinformatics support (import/export of sequences, conversion, visualization, analysis). [See more](https://github.com/datagrok-ai/public/blob/master/packages/Bio/README.md) for details.",
   "repository": {
     "type": "git",
@@ -44,7 +44,7 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.63.6",
+    "@datagrok-libraries/bio": "^5.63.7",
     "@datagrok-libraries/chem-meta": "^1.2.9",
     "@datagrok-libraries/math": "^1.2.6",
     "@datagrok-libraries/ml": "^6.10.11",
@@ -69,7 +69,7 @@
     "@datagrok-libraries/helm-web-editor": "^1.1.16",
     "@datagrok-libraries/js-draw-lite": "^0.0.10",
     "@datagrok/chem": "^1.17.1",
-    "@datagrok/dendrogram": "^1.2.33",
+    "@datagrok/dendrogram": "^1.4.11",
     "@datagrok/eda": "^1.4.13",
     "@datagrok/helm": "^2.13.1",
     "@datagrok/peptides": "^1.27.4",

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';
@@ -992,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/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();
+}