@datagrok/bio 2.26.0 → 2.26.1

package/package.json

@@ -5,7 +5,7 @@
     "name": "Davit Rizhinashvili",
     "email": "drizhinashvili@datagrok.ai"
   },
-  "version": "2.26.0",
+  "version": "2.26.1",
   "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.0",
+    "@datagrok-libraries/bio": "^5.63.2",
     "@datagrok-libraries/chem-meta": "^1.2.9",
     "@datagrok-libraries/math": "^1.2.6",
     "@datagrok-libraries/ml": "^6.10.9",

package/src/package-api.ts

@@ -178,6 +178,13 @@ export namespace funcs {
     return await grok.functions.call('Bio:ManageAnnotations', {});
   }
 
+  /**
+  Creates a new input for sequence columns with ability to extract a region
+  */
+  export async function sequenceColumnInput(name: string , options: any ): Promise<any> {
+    return await grok.functions.call('Bio:SequenceColumnInput', { name, options });
+  }
+
   /**
   Detects pairs of molecules with similar structure and significant difference in any given property
   */

package/src/package.g.ts

@@ -244,6 +244,15 @@ export function manageAnnotations() : void {
   PackageFunctions.manageAnnotations();
 }
 
+//name: Sequence Column Input
+//description: Creates a new input for sequence columns with ability to extract a region
+//input: string name 
+//input: dynamic options 
+//output: dynamic result
+export function sequenceColumnInput(name: string, options: any) : any {
+  return PackageFunctions.sequenceColumnInput(name, options);
+}
+
 //name: Sequence Activity Cliffs
 //description: Detects pairs of molecules with similar structure and significant difference in any given property
 //input: dataframe table { description: Input data table }

package/src/package.ts

@@ -79,6 +79,8 @@ import {handleSequenceHeaderRendering} from './widgets/sequence-scrolling-widget
 import {PolymerType} from '@datagrok-libraries/js-draw-lite/src/types/org';
 import {BilnNotationProvider} from './utils/biln';
 import {showMonomerCollectionsView} from './utils/monomer-lib/monomer-collections-view';
+import {ISequenceColumnInput} from '@datagrok-libraries/bio/src/utils/sequence-column-input';
+import {SequenceColumnInput} from './utils/sequence-column-input';
 
 import * as api from './package-api';
 export const _package = new BioPackage(/*{debug: true}/**/);
@@ -488,6 +490,14 @@ export class PackageFunctions {
     import('./utils/annotations/annotation-manager-ui').then((m) => m.showAnnotationManagerDialog());
   }
 
+  @grok.decorators.func({
+    name: 'Sequence Column Input',
+    description: 'Creates a new input for sequence columns with ability to extract a region',
+  })
+  static sequenceColumnInput(name: string, options: any): ISequenceColumnInput {
+    return SequenceColumnInput.create(name, options);
+  }
+
   @grok.decorators.func({
     name: 'Sequence Activity Cliffs',
     description: 'Detects pairs of molecules with similar structure and significant difference in any given property',

package/src/tests/substructure-filters-tests.ts

@@ -428,6 +428,7 @@ category('bio-substructure-filters', async () => {
     await awaitGrid(view.grid);
 
     const seqFilter = fg.filters[0] as BioSubstructureFilter;
+    await awaitCheck(() => seqFilter.bioFilter !== null, 'FastaBioFilter hasn\'t been created', 1000);
     const seqBf = seqFilter.bioFilter as FastaBioFilter;
     await testEvent(df.onRowsFiltered, () => {}, () => {
       seqBf.props = new BioFilterProps(fSubStr, undefined, _package.logger);

package/src/utils/annotations/liability-scanner.ts

@@ -45,7 +45,7 @@ function getCanonicalString(sh: ISeqHandler, rowIdx: number): string {
   const splitted = sh.getSplitted(rowIdx);
   const chars: string[] = new Array(splitted.length);
   for (let i = 0; i < splitted.length; i++)
-    chars[i] = splitted.getCanonical(i);
+    chars[i] = splitted.getOriginal(i);
   return chars.join('');
 }
 

package/src/utils/annotations/numbering-ui.ts

@@ -14,6 +14,8 @@ import {
 } from './annotation-manager';
 import {_package} from '../../package';
 import type {NumberingResult, Scheme} from '../antibody-numbering (WIP)';
+import {VdRegionsViewer} from '../../viewers/vd-regions-viewer';
+import { VdRegion, VdRegionType } from '@datagrok-libraries/bio/src/viewers/vd-regions';
 
 const BUILTIN_ENGINE_KEY = '__builtin__';
 const BUILTIN_ENGINE_LABEL = 'Built-in (TypeScript)';
@@ -34,8 +36,10 @@ function discoverEngines(): NumberingEngine[] {
   const engines: NumberingEngine[] = [];
 
   const funcs = DG.Func.find({meta: {role: 'antibodyNumbering'}});
-  if (funcs.length === 0)
+  if (funcs.length === 0) {
+    grok.shell.error('No antibody numbering engines found. Make sure that Proteomics plugin is installed and up to date.');
     throw new Error('No external antibody numbering engines found. Make sure that Proteomics plugin is installed and up to date.');
+  }
   for (const f of funcs) {
     const pkgName = f.package?.name ?? '';
     const label = f.friendlyName || f.name;
@@ -439,6 +443,23 @@ function applyNumberingResults(
         const regionAnnotations: SeqAnnotation[] = JSON.parse(annotationsJson);
         const existing = getColumnAnnotations(alignment.alignedCol).filter((a) => a.category !== AnnotationCategory.Structure);
         setColumnAnnotations(alignment.alignedCol, [...existing, ...regionAnnotations]);
+        // chunk for vd regions viewer if that becomes a desired feature in the future
+        // if (grok.shell.tv?.dataFrame === df) {
+        //   (async () => {
+        //     const vdRegionsViewer: VdRegionsViewer = await grok.shell.tv.dataFrame.plot.fromType('VdRegions',) as VdRegionsViewer;
+        //     vdRegionsViewer.chains = [chainType];
+        //     vdRegionsViewer.setData(regionAnnotations.map((a, i) => ({
+        //       type: a.name?.toLowerCase().startsWith('cdr') ? VdRegionType.CDR : VdRegionType.FR,
+        //       name: a.name,
+        //       chain: chainType,
+        //       order: i,
+        //       sequenceColumnName: alignment.alignedCol.name,
+        //       positionStartName: a.start ?? '',
+        //       positionEndName: a.end ?? '',
+        //     } satisfies VdRegion)));
+        //     grok.shell.tv.addViewer(vdRegionsViewer);
+        //   })();
+        // }
       } catch (err) {
         console.warn('Failed to set column-level annotations on aligned column:', err);
       }
@@ -446,5 +467,6 @@ function applyNumberingResults(
   }
 
   df.fireValuesChanged();
+
   grok.shell.info(`Numbering applied: ${schemeName}, chain type: ${chainType}`);
 }

package/src/utils/get-region.ts

@@ -10,33 +10,119 @@ import {getAnnotationColumnName, cacheAllRowAnnotations} from './annotations/ann
 import {_package} from '../package';
 
 export function getRegionUI(col: DG.Column<string>): void {
+  showGetRegionDialog(col);
+}
+
+/** Shows the Get Region dialog for the given column.
+ *  When the user confirms, the region column is extracted, added to the dataframe, and
+ *  {@link onRegionCreated} is called with it (if provided).
+ *  Returns the dialog instance for further control. */
+export function showGetRegionDialog(
+  col: DG.Column<string>,
+  onRegionCreated?: (regCol: DG.Column<string>) => void,
+): DG.Dialog {
   const sh = _package.seqHelper.getSeqHandler(col);
 
   const nameInput = ui.input.string('Name', {value: ''});
   const startPositionInput = ui.input.choice('Start Position', {value: sh.posList[0], items: sh.posList,
-    onValueChanged: () => { /* TODO: update name placeholder with getDefaultName() */ }});
-  const endPositionInput = ui.input.choice('End Position', {value: sh.posList[sh.posList.length], items: sh.posList,
-    onValueChanged: () => { /* TODO: update name placeholder with getDefaultName() */ }});
+    onValueChanged: () => updateNamePlaceholder()});
+  const endPositionInput = ui.input.choice('End Position', {value: sh.posList[sh.posList.length - 1], items: sh.posList,
+    onValueChanged: () => updateNamePlaceholder()});
+
+  let selectedRegionName: string | null = null;
 
   const getDefaultName = (): string => {
-    return `${col.name}:${startPositionInput.value}-${endPositionInput.value}`;
+    return selectedRegionName
+      ? `${col.name}(${selectedRegionName}): ${startPositionInput.value}-${endPositionInput.value}`
+      : `${col.name}:${startPositionInput.value}-${endPositionInput.value}`;
+  };
+
+  const updateNamePlaceholder = (): void => {
+    if (!nameInput.value)
+      nameInput.input.setAttribute('placeholder', getDefaultName());
   };
+  updateNamePlaceholder();
+
+  // Build region presets from annotations (new system) or .regions tag (legacy)
+  const regionInput = _buildRegionPresetsInput(col, startPositionInput, endPositionInput, (regionName) => {
+    selectedRegionName = regionName;
+    updateNamePlaceholder();
+  });
+
+  const inputsList: DG.InputBase[] = [];
+  if (regionInput) inputsList.push(regionInput);
+  inputsList.push(nameInput, startPositionInput, endPositionInput);
+
+  const dlg = ui.dialog({title: 'Get Region'}).add(ui.inputs(inputsList))
+    .onOK(() => {
+      const pi = DG.TaskBarProgressIndicator.create('Getting region...');
+      try {
+        const name: string = nameInput.value || getDefaultName();
+        const regCol = getRegionDo(col, startPositionInput.value, endPositionInput.value, name);
+        col.dataFrame.columns.add(regCol);
+        regCol.setTag(DG.TAGS.CELL_RENDERER, 'sequence');
+        onRegionCreated?.(regCol);
+      } catch (err: any) {
+        grok.shell.error(err.toString());
+      } finally { pi.close(); }
+    });
+  dlg.show();
+  return dlg;
+}
 
-  ui.dialog({title: 'Get Region'}).add(ui.inputs([
-    nameInput,
-    startPositionInput,
-    endPositionInput,
-  ])).onOK(() => {
-    const pi = DG.TaskBarProgressIndicator.create('Getting region...');
+/** Builds a Region preset dropdown from column annotations / legacy .regions tag.
+ *  Returns null if the column has no annotated regions. */
+function _buildRegionPresetsInput(
+  col: DG.Column<string>,
+  startInput: DG.InputBase<string | null>,
+  endInput: DG.InputBase<string | null>,
+  onRegionSelected?: (regionName: string | null) => void,
+): DG.InputBase | null {
+  type RegionPreset = { name: string, start: string, end: string };
+  let regionList: RegionPreset[] | null = null;
+
+  // New annotation system
+  const annotationsTag: string | null = col.getTag(bioTAGS.annotations);
+  if (annotationsTag) {
     try {
-      const name: string = nameInput.value ?? getDefaultName();
-      const regCol = getRegionDo(col, startPositionInput.value, endPositionInput.value, name);
-      col.dataFrame.columns.add(regCol);
-      regCol.setTag(DG.TAGS.CELL_RENDERER, 'sequence');
-    } catch (err: any) {
-      grok.shell.error(err.toString());
-    } finally { pi.close(); }
+      const annotations = JSON.parse(annotationsTag);
+      const structAnnots = annotations.filter(
+        (a: any) => a.category === AnnotationCategory.Structure && a.start && a.end);
+      if (structAnnots.length > 0) {
+        regionList = structAnnots.map((a: any) => ({
+          name: a.name, start: a.start, end: a.end,
+        }));
+      }
+    } catch { /* ignore parse errors */ }
+  }
+
+  // Legacy .regions tag
+  if (!regionList) {
+    const regionsTagTxt: string | null = col.getTag(bioTAGS.regions);
+    if (regionsTagTxt) {
+      try { regionList = JSON.parse(regionsTagTxt); } catch { /* ignore */ }
+    }
+  }
+
+  if (!regionList || regionList.length === 0) return null;
+
+  const items = ['', ...regionList.map((r) => `${r.name}: ${r.start}-${r.end}`)];
+  const regionInput = ui.input.choice('Region', {
+    value: '', items: items,
+    onValueChanged: (value: string) => {
+      if (!value) {
+        onRegionSelected?.(null);
+        return;
+      }
+      const preset = regionList!.find((r) => `${r.name}: ${r.start}-${r.end}` === value);
+      if (preset) {
+        startInput.value = preset.start;
+        endInput.value = preset.end;
+        onRegionSelected?.(preset.name);
+      }
+    },
   });
+  return regionInput;
 }
 
 /** {@link startPosName} and {@link endPosName} are according positionNames tag (or default ['1', '2',...]) */

package/src/utils/sequence-column-input.ts

@@ -0,0 +1,57 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {showGetRegionDialog} from './get-region';
+import {ISequenceColumnInput} from '@datagrok-libraries/bio/src/utils/sequence-column-input';
+
+/** A column input that filters to macromolecule columns and provides a
+ *  "get region" button so users can extract a sub-region and use it instead. */
+export class SequenceColumnInput implements ISequenceColumnInput {
+  private readonly colInput: DG.InputBase<DG.Column | null>;
+
+  private constructor(
+    name: string,
+    options: ui.input.IColumnInputInitOptions<DG.Column>,
+  ) {
+    const filter = options.filter;
+    this.colInput = ui.input.column(name, {
+      ...options,
+      filter: (col: DG.Column) => {
+        if (col.semType !== DG.SEMTYPE.MACROMOLECULE) return false;
+        return filter ? filter(col) : true;
+      },
+    });
+
+    const regionIcon = ui.iconFA('cut', () => this.onRegionIconClick(), 'Extract a region from the sequence');
+    this.colInput.addOptions(regionIcon);
+  }
+
+  /** Creates a new SequenceColumnInput.
+   *  @param name - Caption for the input.
+   *  @param options - Same options as {@link ui.input.column}, table is required.
+   *    The `filter` option is extended to always require semType === Macromolecule. */
+  static create(
+    name: string,
+    options: ui.input.IColumnInputInitOptions<DG.Column>,
+  ): SequenceColumnInput {
+    return new SequenceColumnInput(name, options);
+  }
+
+  get root(): HTMLElement { return this.colInput.root; }
+  get value(): DG.Column | null { return this.colInput.value; }
+  set value(col: DG.Column | null) { this.colInput.value = col; }
+  get inputBase(): DG.InputBase<DG.Column | null> { return this.colInput; }
+
+  private onRegionIconClick(): void {
+    const col = this.colInput.value;
+    if (!col) {
+      grok.shell.warning('Select a macromolecule column first.');
+      return;
+    }
+
+    showGetRegionDialog(col, (regCol) => {
+      this.colInput.value = regCol;
+    });
+  }
+}

package/src/viewers/vd-regions-viewer.ts

@@ -322,6 +322,8 @@ export class VdRegionsViewer extends DG.JsViewer implements IVdRegionsViewer {
       for (const chain of this.chains) {
         const region: VdRegion | undefined = regionsFiltered
           .find((r) => r.order == orderList[orderI] && r.chain == chain);
+        if (!region)
+          continue;
         logoPromiseList.push((async (): Promise<[number, string, WebLogoViewer]> => {
           const wl: WebLogoViewer = await this.dataFrame.plot.fromType('WebLogo', {
             sequenceColumnName: region!.sequenceColumnName,