@datagrok/bio 2.26.2 → 2.26.5

package/src/utils/convert.ts

@@ -162,10 +162,16 @@ export async function convertDo(srcCol: DG.Column, seqHelper: ISeqHelper, target
         return '';
       }
     });
+    newCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    newCol.meta.units = NOTATION.CUSTOM;
+    newCol.setTag('separator', '-');
+    newCol.setTag('aligned', 'SEQ');
+    newCol.setTag('alphabet', 'UN');
+    newCol.setTag('.alphabetIsMultichar', 'true');
     srcCol.dataFrame.columns.add(newCol);
-    const semType = await grok.functions.call('Bio:detectMacromolecule', {col: newCol});
-    if (semType)
-      newCol.semType = semType;
+    // const semType = await grok.functions.call('Bio:detectMacromolecule', {col: newCol});
+    // if (semType)
+    //   newCol.semType = semType;
     await grok.data.detectSemanticTypes(srcCol.dataFrame);
     return newCol;
   } else {

package/src/utils/monomer-cell-renderer.ts

@@ -3,7 +3,8 @@ import * as DG from 'datagrok-api/dg';
 import {GridCell} from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 import {ALPHABET, monomerToShort} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {BioTags, GAP_SYMBOL, MONOMER_MOTIF_SPLITTER, TAGS as bioTAGS,} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {BioTags, GAP_SYMBOL, MONOMER_CANONICALIZER_FUNC_TAG, MONOMER_CANONICALIZER_TEMP, MONOMER_MOTIF_SPLITTER, TAGS as bioTAGS,} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {IMonomerCanonicalizer} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 import {MONOMER_RENDERER_TAGS} from '@datagrok-libraries/bio/src/utils/cell-renderer';
 import {getGridCellColTemp} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
 
@@ -24,6 +25,34 @@ export class MonomerCellRendererBack extends CellRendererWithMonomerLibBackBase
     super(gridCol, tableCol);
   }
 
+  private static readonly _canonLoadingKey = MONOMER_CANONICALIZER_TEMP + '.loading';
+
+  /** Lazily resolves and caches the IMonomerCanonicalizer from the column tag/temp.
+   *  Uses async apply() so the plugin package doesn't need to be loaded yet.
+   *  Returns null while loading; the resolved instance is cached for subsequent calls. */
+  private getCanonicalizer(col: DG.Column): IMonomerCanonicalizer | null {
+    const cached: IMonomerCanonicalizer | null = col.temp[MONOMER_CANONICALIZER_TEMP] ?? null;
+    if (cached) return cached;
+    // Already loading — don't fire another request
+    if (col.temp[MonomerCellRendererBack._canonLoadingKey]) return null;
+    const funcName = col.getTag(MONOMER_CANONICALIZER_FUNC_TAG);
+    if (!funcName) return null;
+    const parts = funcName.includes(':') ? funcName.split(':') : [undefined, funcName];
+    const funcs = DG.Func.find({name: parts[1], package: parts[0]});
+    if (funcs.length === 0) return null;
+    col.temp[MonomerCellRendererBack._canonLoadingKey] = true;
+    funcs[0].apply({}).then((canon: IMonomerCanonicalizer) => {
+      col.temp[MONOMER_CANONICALIZER_TEMP] = canon;
+      col.temp[MonomerCellRendererBack._canonLoadingKey] = false;
+      // Invalidate the grid so cells re-render with the canonicalizer
+      if (this.gridCol?.grid?.invalidate)
+        this.gridCol.grid.invalidate();
+    }).catch(() => {
+      col.temp[MonomerCellRendererBack._canonLoadingKey] = false;
+    });
+    return null;
+  }
+
   render(g: CanvasRenderingContext2D,
     x: number, y: number, w: number, h: number, gridCell: DG.GridCell, cellStyle: DG.GridCellStyle
   ): void {
@@ -41,6 +70,10 @@ export class MonomerCellRendererBack extends CellRendererWithMonomerLibBackBase
       g.textAlign = 'left';
 
       let value: string = gridCell.cell.value;
+      // render original value
+      // const canonicalizer = this.getCanonicalizer(gridCell.cell.column);
+      // if (canonicalizer && value)
+      //   value = canonicalizer.canonicalize(value);
       if (!value || value === GAP_SYMBOL)
         value = DASH_GAP_SYMBOL;
       const symbols = value.split(MONOMER_MOTIF_SPLITTER).map((s) => !s || s === GAP_SYMBOL ? DASH_GAP_SYMBOL : s.trim());
@@ -88,12 +121,16 @@ export class MonomerCellRendererBack extends CellRendererWithMonomerLibBackBase
     ) return false;
 
     const alphabet = tableCol.getTag(bioTAGS.alphabet) as ALPHABET;
-    const monomerName: string = gridCell.cell.value;
+    const rawMonomerName: string = gridCell.cell.value;
+    const canonicalizer = this.getCanonicalizer(tableCol);
+    const monomerName = canonicalizer && rawMonomerName ? canonicalizer.canonicalize(rawMonomerName) : rawMonomerName;
     const canvasClientRect = gridCell.grid.canvas.getBoundingClientRect();
     const x1 = gridCell.bounds.right + canvasClientRect.left - 4;
     const y1 = gridCell.bounds.bottom + canvasClientRect.top - 4;
 
-    if (!monomerName || monomerName == GAP_SYMBOL || monomerName == DASH_GAP_SYMBOL) {
+    const isGap = !rawMonomerName || rawMonomerName == GAP_SYMBOL || rawMonomerName == DASH_GAP_SYMBOL ||
+      (canonicalizer != null && canonicalizer.isGap(rawMonomerName));
+    if (isGap) {
       ui.tooltip.show(ui.divText('gap'), x1, y1);
       return true;
     }

package/src/utils/seq-helper/seq-handler.ts

@@ -44,6 +44,15 @@ export class SeqHandler implements ISeqHandler {
   private _refinerPromise: Promise<void> = Promise.resolve();
   public get refinerPromise(): Promise<void> { return this._refinerPromise; }
 
+  private runInnerDetector() {
+    if (!this._column.temp['seqHandlerDetectorRun']) {
+      this._column.temp['seqHandlerDetectorRun'] = true;
+      const detectorFunc = DG.Func.find({name: 'detectMacromolecule', meta: {role: 'semTypeDetector'}})[0];
+      if (detectorFunc)
+        detectorFunc.applySync({col: this._column});
+    }
+  }
+
   protected constructor(col: DG.Column<string>,
     private readonly seqHelper: SeqHelper,
   ) {
@@ -53,19 +62,20 @@ export class SeqHandler implements ISeqHandler {
     let units: string | null = this._column.meta.units;
     if (!units) {
       // it may be from layout that the macromolecule semtype is set but every other tag is missing, so we manually run detectors
-      if (!this._column.temp['seqHandlerDetectorRun']) {
-        this._column.temp['seqHandlerDetectorRun'] = true;
-        const detectorFunc = DG.Func.find({name: 'detectMacromolecule', meta: {role: 'semTypeDetector'}})[0];
-        if (detectorFunc)
-          detectorFunc.applySync({col: this._column});
-        units = this._column.meta.units;
-      }
+      this.runInnerDetector();
+      units = this._column.meta.units;
       if (!units)
         throw new Error('Units are not specified in column');
     }
     this._units = units!;
 
     this._notation = this.getNotation();
+    if ([NOTATION.BILN, NOTATION.CUSTOM, NOTATION.SEPARATOR].includes(this._notation) && !this.column.getTag(TAGS.separator)) {
+      this.runInnerDetector();
+      if (!this.column.getTag(TAGS.separator))
+        throw new Error(`Separator tag '${TAGS.separator}' is not set for notation '${this._notation}'.`);
+    }
+
     if (this.isCustom() || this.isBiln()) {
       // this.column.temp[SeqTemps.notationProvider] must be set at detector stage
       this.notationProvider = this.column.temp[SeqTemps.notationProvider] ?? null;
@@ -185,7 +195,7 @@ export class SeqHandler implements ISeqHandler {
   public static setTags(uh: SeqHandler): void {
     const units = uh.column.meta.units as NOTATION;
 
-    if ([NOTATION.FASTA, NOTATION.SEPARATOR].includes(units)) {
+    if ([NOTATION.FASTA, NOTATION.SEPARATOR, NOTATION.BILN].includes(units)) {
       // Empty monomer alphabet is allowed, only if alphabet tag is annotated
       if (!uh.column.getTag(TAGS.alphabet) && Object.keys(uh.stats.freq).length === 0)
         throw new Error('Alphabet is empty and not annotated.');