@datagrok/bio 2.11.28 → 2.11.30

package/src/tests/to-atomic-level-tests.ts

@@ -21,22 +21,30 @@ import {_package} from '../package-test';
 const appPath = 'System:AppData/Bio';
 const fileSource = new DG.FileSource(appPath);
 
-const testNames: { [k: string]: string } = {
-  PT: 'peptides-fasta',
-  DNA: 'dna-fasta',
-  MSA: 'msa-separator',
-};
-
-const inputPath: { [k: string]: string } = {
-  PT: 'tests/to-atomic-level-peptides-fasta-input.csv',
-  DNA: 'tests/to-atomic-level-dna-fasta-input.csv',
-  MSA: 'tests/to-atomic-level-msa-separator-input.csv',
-};
+const enum Tests {
+  PT = 'peptides-fasta',
+  DNA = 'dna-fasta',
+  MSA_SEPARATOR = 'msa-separator',
+  MSA_FASTA = 'msa-fasta',
+}
 
-const outputPath: { [k: string]: string } = {
-  PT: 'tests/to-atomic-level-peptides-fasta-output.csv',
-  DNA: 'tests/to-atomic-level-dna-fasta-output.csv',
-  MSA: 'tests/to-atomic-level-msa-separator-output.csv',
+const TestsData: { [testName: string]: { inPath: string, outPath: string } } = {
+  [Tests.PT]: {
+    inPath: 'tests/to-atomic-level-peptides-fasta-input.csv',
+    outPath: 'tests/to-atomic-level-peptides-fasta-output.csv'
+  },
+  [Tests.DNA]: {
+    inPath: 'tests/to-atomic-level-dna-fasta-input.csv',
+    outPath: 'tests/to-atomic-level-dna-fasta-output.csv'
+  },
+  [Tests.MSA_SEPARATOR]: {
+    inPath: 'tests/to-atomic-level-msa-separator-input.csv',
+    outPath: 'tests/to-atomic-level-msa-separator-output.csv'
+  },
+  [Tests.MSA_FASTA]: {
+    inPath: 'tests/to-atomic-level-msa-fasta-input.csv',
+    outPath: 'tests/to-atomic-level-msa-fasta-output.csv'
+  },
 };
 
 const inputColName = 'sequence';
@@ -57,10 +65,12 @@ category('toAtomicLevel', async () => {
     await setUserLibSettingsForTests();
     await monomerLibHelper.loadLibraries(true);
 
-    for (const key in testNames) {
-      sourceDf[key] = DG.DataFrame.fromCsv((await fileSource.readAsText(inputPath[key])).replace(/\n$/, ''));
-      await grok.data.detectSemanticTypes(sourceDf[key]);
-      targetDf[key] = DG.DataFrame.fromCsv((await fileSource.readAsText(outputPath[key])).replace(/\n$/, ''));
+    for (const [testName, testData] of Object.entries(TestsData)) {
+      const inputPath = testData.inPath;
+
+      sourceDf[testName] = DG.DataFrame.fromCsv((await fileSource.readAsText(testData.inPath)).replace(/\n$/, ''));
+      await grok.data.detectSemanticTypes(sourceDf[testName]);
+      targetDf[testName] = DG.DataFrame.fromCsv((await fileSource.readAsText(testData.outPath)).replace(/\n$/, ''));
     }
   });
 
@@ -79,9 +89,9 @@ category('toAtomicLevel', async () => {
     expectArray(obtainedArray, expectedArray);
   }
 
-  for (const key in testNames) {
-    test(`${testNames[key]}`, async () => {
-      await getTestResult(sourceDf[key], targetDf[key]);
+  for (const [testName, testData] of Object.entries(TestsData)) {
+    test(`${testName}`, async () => {
+      await getTestResult(sourceDf[testName], targetDf[testName]);
     });
   }
 

package/src/tests/utils/sequences-generators.ts

@@ -1,8 +1,11 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
+
 import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {awaitCheck} from '@datagrok-libraries/utils/src/test';
+import {expect} from '@datagrok-libraries/utils/src/test';
+
+import {awaitGrid} from '../utils';
 
 
 export function generateManySequences(): DG.Column[] {
@@ -32,8 +35,8 @@ export async function performanceTest(generateFunc: () => DG.Column[], testName:
   const col: DG.Column = df.columns.byName('MSA');
   const view: DG.TableView = grok.shell.addTableView(df);
 
-  await awaitCheck(() => { return view.grid.dataFrame !== df; },
-    'View grid has wrong data frame ', 100);
+  await awaitGrid(view.grid);
+  expect(view.grid.dataFrame.id, df.id);
 
   const endTime: number = Date.now();
   const elapsedTime: number = endTime - startTime;

package/src/tests/utils.ts

@@ -3,6 +3,8 @@ import * as grok from 'datagrok-api/grok';
 
 import {delay, expect, testEvent} from '@datagrok-libraries/utils/src/test';
 
+import {startDockerContainer} from '../utils/docker';
+
 import {_package} from '../package-test';
 
 export async function loadFileAsText(name: string): Promise<string> {
@@ -34,12 +36,10 @@ export function _testTableIsNotEmpty(table: DG.DataFrame): void {
 
 /** Waits if container is not started
  * @param {number} ms - time to wait in milliseconds */
-export async function awaitContainerStart(ms: number = 10000): Promise<void> {
-  const container = await grok.dapi.docker.dockerContainers.filter('bio').first();
-  if (container.status !== 'started' && container.status !== 'checking')
-    await delay(ms);
-    // TODO: Enable with new JS API version
-    // await grok.dapi.docker.dockerContainers.run(container.id, true);
+export async function awaitContainerStart(ms: number = 30000): Promise<void> {
+  const dc = await grok.dapi.docker.dockerContainers.filter('bio').first();
+  const dcId = dc.id;
+  await startDockerContainer(dcId, ms);
 }
 
 export async function awaitGrid(grid: DG.Grid, timeout: number = 5000): Promise<void> {

package/src/utils/cell-renderer.ts

@@ -215,6 +215,8 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
 
       const tempReferenceSequence: string | null = tableColTemp[tempTAGS.referenceSequence];
       const tempCurrentWord: string | null = tableColTemp[tempTAGS.currentWord];
+      if (tempCurrentWord && tableCol?.dataFrame?.currentRowIdx === -1)
+        tableColTemp[tempTAGS.currentWord] = null;
       const referenceSequence: ISeqSplitted = splitterFunc(
         ((tempReferenceSequence != null) && (tempReferenceSequence != '')) ?
           tempReferenceSequence : tempCurrentWord ?? '');

package/src/utils/docker.ts

@@ -0,0 +1,36 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {delay} from '@datagrok-libraries/utils/src/test';
+
+export async function startDockerContainer(dcId: string, timeout: number = 30000): Promise<void> {
+  // TODO: Use the new dockerContainers API
+  const res = await grok.dapi.docker.dockerContainers.run(dcId /*, true */);
+  let end: boolean = false;
+  for (let i = 0; i < timeout / 200; ++i) {
+    const dc = await grok.dapi.docker.dockerContainers.find(dcId);
+    switch (dc.status) {
+      case 'stopped': {
+        await grok.dapi.docker.dockerContainers.run(dcId);
+        break;
+      }
+      case 'pending change':
+      case 'changing': {
+        // skip to wait
+        break;
+      }
+      case 'checking':
+      case 'started': {
+        end = true;
+        break;
+      }
+      case 'error': {
+        throw new Error('Docker container error state.');
+      }
+    }
+    if (end) break;
+    await delay(200);
+  }
+  if (!end) throw new Error('Docker container run timeout.');
+  // this.dc = await grok.dapi.docker.dockerContainers.find(dcId);
+}

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

@@ -520,5 +520,9 @@ export class VdRegionsViewer extends DG.JsViewer implements IVdRegionsViewer {
     await testEvent(this.onRendered, () => {}, () => {
       this.invalidate();
     }, timeout);
+
+    // Rethrow stored syncer error (for test purposes)
+    const viewErrors = this.viewSyncer.resetErrors();
+    if (viewErrors.length > 0) throw viewErrors[0];
   }
 }

package/src/viewers/web-logo-viewer.ts

@@ -1297,6 +1297,10 @@ export class WebLogoViewer extends DG.JsViewer implements IWebLogoViewer {
     await testEvent(this.onRendered, () => {}, () => {
       this.invalidate();
     }, timeout);
+
+    // Rethrow stored syncer error (for test purposes)
+    const viewErrors = this.viewSyncer.resetErrors();
+    if (viewErrors.length > 0) throw viewErrors[0];
   }
 }
 

package/src/widgets/bio-substructure-filter-helm.ts

@@ -0,0 +1,168 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import $ from 'cash-dom';
+import {fromEvent, Observable, Subject, Unsubscribable} from 'rxjs';
+
+import {IHelmWebEditor, IWebEditorApp} from '@datagrok-libraries/bio/src/helm/types';
+import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+import {delay, testEvent} from '@datagrok-libraries/utils/src/test';
+
+import {updateDivInnerHTML} from '../utils/ui-utils';
+import {helmSubstructureSearch} from '../substructure-search/substructure-search';
+import {BioFilterBase, BioFilterProps} from './bio-substructure-filter-types';
+
+import {_package} from '../package';
+
+export class HelmBioFilter extends BioFilterBase<BioFilterProps> /* implements IRenderer */ {
+  readonly emptyProps = new BioFilterProps('');
+
+  helmEditor: IHelmWebEditor;
+  _filterPanel = ui.div('', {style: {cursor: 'pointer'}});
+
+  private readonly logger: ILogger;
+
+  private static viewerCounter: number = -1;
+  private readonly viewerId: number = ++HelmBioFilter.viewerCounter;
+
+  private viewerToLog(): string { return `HelmBioFilter<${this.viewerId}>`; }
+
+  get type(): string { return 'HelmBioFilter'; }
+
+  constructor() {
+    super();
+    this.logger = _package.logger;
+  }
+
+  viewSubs: Unsubscribable[] = [];
+
+  async detach(): Promise<void> {
+    await super.detach();
+    for (const sub of this.viewSubs) sub.unsubscribe();
+  }
+
+  async attach(): Promise<void> {
+    const logPrefix = `${this.viewerToLog()}.init()`;
+    try {
+      const helmHelper = await getHelmHelper();
+      this.helmEditor = helmHelper.createHelmWebEditor();
+      this.logger.warning('TEST: HelmBioFilter.init().sync() waitForElementInDom waiting...');
+      await ui.tools.waitForElementInDom(this._filterPanel);
+      this.logger.warning('TEST: HelmBioFilter.init().sync() waitForElementInDom ready');
+      this.updateFilterPanel();
+      let webEditorHost: HTMLDivElement | null;
+      let webEditorApp: IWebEditorApp | null;
+      // TODO: Unsubscribe 'click' and 'sizeChanged'
+      this.viewSubs.push(fromEvent(this._filterPanel, 'click').subscribe(() => {
+        webEditorHost = ui.div();
+        webEditorApp = helmHelper.createWebEditorApp(webEditorHost, this.props.substructure);
+        const dlg = ui.dialog({showHeader: false, showFooter: true})
+          .add(webEditorHost!)
+          .onOK(() => {
+            try {
+              const webEditorValue = webEditorApp!.canvas.getHelm(true)
+                .replace(/<\/span>/g, '').replace(/<span style='background:#bbf;'>/g, '');
+              this.props = new BioFilterProps(webEditorValue);
+            } catch (err: any) {
+              this.logger.error(err);
+            } finally {
+              $(webEditorHost).empty();
+              webEditorHost = null;
+              webEditorApp = null;
+            }
+          })
+          .onCancel(() => {
+            $(webEditorHost).empty();
+            webEditorHost = null;
+            webEditorApp = null;
+          })
+          .show({modal: true, fullScreen: true});
+        // const onCloseSub = dlg.onClose.subscribe(() => {
+        //   onCloseSub.unsubscribe();
+        //   $(editorDiv).empty();
+        //   editorDiv = undefined;
+        //   webEditor = undefined;
+        // });
+      }));
+      this.viewSubs.push(ui.onSizeChanged(this._filterPanel).subscribe((_) => {
+        try {
+          if (!!webEditorApp) {
+            const helmString = webEditorApp.canvas.getHelm(true)
+              .replace(/<\/span>/g, '').replace(/<span style='background:#bbf;'>/g, '');
+            this.updateFilterPanel(helmString);
+          }
+        } catch (err: any) {
+          const [errMsg, errStack] = errInfo(err);
+          this.logger.error(errMsg, undefined, errStack);
+        }
+      }));
+    } catch (err: any) {
+      const [errMsg, _errStack] = errInfo(err);
+      const fp = this._filterPanel;
+      fp.innerText = 'error';
+      fp.classList.add('d4-error');
+      ui.tooltip.bind(fp, errMsg);
+    }
+  }
+
+  applyProps() {
+    if (!this.helmEditor) return; // helmEditor is not created, the filter is not in dom yet
+    this.helmEditor.editor.setHelm(this.props.substructure);
+  }
+
+  get filterPanel() {
+    return this._filterPanel;
+  }
+
+  updateFilterPanel(helmString?: string) {
+    if (!this.helmEditor) throw new Error('helmEditor is not created, the filter is not in dom yet');
+
+    const width = this._filterPanel.parentElement!.clientWidth < 100 ? 100 :
+      this._filterPanel.parentElement!.clientWidth;
+    const height = width / 2;
+    if (!helmString) {
+      const editDiv = ui.divText('Click to edit', 'helm-substructure-filter');
+      updateDivInnerHTML(this._filterPanel, editDiv);
+    } else {
+      updateDivInnerHTML(this._filterPanel, this.helmEditor.host);
+      this.helmEditor.editor.setHelm(helmString);
+      this.helmEditor.resizeEditor(width, height);
+    }
+  }
+
+  async substructureSearch(column: DG.Column): Promise<DG.BitSet | null> {
+    await delay(10);
+    const res = await helmSubstructureSearch(this.props.substructure, column);
+    return res;
+  }
+
+  // // -- IRenderer --
+  //
+  // private _onRendered = new Subject<void>();
+  //
+  // get onRendered(): Observable<void> { return this._onRendered; }
+  //
+  // invalidate(caller?: string): void {
+  //   const logPrefix = `${this.viewerToLog()}.invalidate(${caller ? ` <- ${caller} ` : ''})`;
+  //   this.viewSyncer.sync(logPrefix, async () => { this._onRendered.next(); });
+  // }
+  //
+  // async awaitRendered(timeout: number = 10000): Promise<void> {
+  //   const callLog = `awaitRendered( ${timeout} )`;
+  //   const logPrefix = `${this.viewerToLog()}.${callLog}`;
+  //   await delay(0);
+  //   await testEvent(this.onRendered, () => {
+  //     this.logger.debug(`${logPrefix}, ` + '_onRendered event caught');
+  //   }, () => {
+  //     this.invalidate(callLog);
+  //   }, timeout, `${logPrefix} ${timeout} timeout`);
+  //
+  //   // Rethrow stored syncer error (for test purposes)
+  //   const viewErrors = this.viewSyncer.resetErrors();
+  //   if (viewErrors.length > 0) throw viewErrors[0];
+  // }
+}
+

package/src/widgets/bio-substructure-filter-types.ts

@@ -0,0 +1,131 @@
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
+import {Observable, Subject, Unsubscribable} from 'rxjs';
+import {_package} from '../package';
+
+export interface IFilterProps {
+  get onChanged(): Observable<void>;
+
+  save(): object;
+  apply(propsObj: object): void;
+}
+
+/** Fasta and Helm */
+export class BioFilterProps implements IFilterProps {
+  private _onChanged: Subject<void> = new Subject<void>();
+
+  get onChanged(): Observable<void> { return this._onChanged; }
+
+  constructor(
+    public substructure: string
+  ) {
+    return new Proxy(this, {
+      set: (target: any, key: string | symbol, value: any) => {
+        _package.logger.debug(`BioFilterProps.set ${key.toString()}( '${value}' )`);
+        target[key] = value;
+        this._onChanged.next();
+        return true;
+      }
+    });
+  }
+
+  save(): object {
+    const propsObj = {};
+    for (const [key, value] of Object.entries(this)) {
+      if (key !== '_onChanged') {
+        // @ts-ignore
+        propsObj[key] = this[key];
+      }
+    }
+    return propsObj;
+  }
+
+  apply(propsObj: object) {
+    for (const [key, value] of Object.entries(this)) {
+      if (key !== '_onChanged') {
+        // @ts-ignore
+        this[key] = propsObj[key];
+      }
+    }
+  }
+}
+
+export interface IBioFilter {
+  get type(): string;
+
+  get props(): IFilterProps;
+  set props(value: IFilterProps);
+
+  get onChanged(): Observable<void>;
+  get filterPanel(): HTMLElement;
+  get filterSummary(): string;
+  get isFiltering(): boolean;
+
+  attach(): Promise<void>;
+  detach(): Promise<void>;
+  resetFilter(): void;
+  substructureSearch(col: DG.Column): Promise<DG.BitSet | null>;
+}
+
+/** Encapsulates input controls handling */
+export abstract class BioFilterBase<TProps extends BioFilterProps> implements IBioFilter {
+  abstract get filterPanel(): HTMLElement;
+
+  abstract get emptyProps(): TProps;
+
+  onChanged: Subject<void> = new Subject<void>();
+
+  private _props: TProps;
+  protected _propsChanging: boolean = false;
+  private _propsOnChangedSub: Unsubscribable | null = null;
+
+  abstract get type(): string;
+
+  get props(): TProps {
+    if (!this._props) this._props = this.emptyProps;
+    return this._props;
+  };
+
+  set props(value: TProps) {
+    this._propsChanging = true;
+    try {
+      if (this._propsOnChangedSub) {
+        this._propsOnChangedSub.unsubscribe();
+        this._propsOnChangedSub = null;
+      }
+      this._props = value;
+      this.applyProps();
+      this.onChanged.next();
+      this._propsOnChangedSub = this._props.onChanged
+        .subscribe(() => {
+          this.onChanged.next();
+        });
+    } finally {
+      this._propsChanging = false;
+    }
+  };
+
+  abstract attach(): Promise<void>;
+
+  async detach(): Promise<void> {
+    if (this._propsOnChangedSub) {
+      this._propsOnChangedSub.unsubscribe();
+      this._propsOnChangedSub = null;
+    }
+  }
+
+  abstract applyProps(): void;
+
+  get filterSummary(): string { return this.props.substructure; };
+
+  get isFiltering(): boolean { return this.props.substructure !== ''; }
+
+  abstract substructureSearch(_column: DG.Column): Promise<DG.BitSet | null>;
+
+  resetFilter(): void {
+    this.props = this.emptyProps;
+    this.onChanged.next();
+  }
+}