@datagrok/bio 2.27.3 → 2.27.4

package/package.json

@@ -5,7 +5,7 @@
     "name": "Davit Rizhinashvili",
     "email": "drizhinashvili@datagrok.ai"
   },
-  "version": "2.27.3",
+  "version": "2.27.4",
   "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.7",
+    "@datagrok-libraries/bio": "^5.64.0",
     "@datagrok-libraries/chem-meta": "^1.2.9",
     "@datagrok-libraries/math": "^1.2.6",
     "@datagrok-libraries/ml": "^6.10.11",

package/src/demo/bio01b-hierarchical-clustering-and-activity-cliffs.ts

@@ -13,6 +13,7 @@ import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {getClusterMatrixWorker} from '@datagrok-libraries/math';
 import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
+import {awaitCheck} from '@datagrok-libraries/test/src/test';
 
 const dataFn: string = 'samples/FASTA_PT_activity.csv';
 
@@ -117,25 +118,37 @@ export async function demoActivityCliffsCyclic() {
   ui.setUpdateIndicator(tv.root, true);
   try {
     const seqEncodingFunc = DG.Func.find({name: 'macromoleculePreprocessingFunction', package: 'Bio'})[0];
-    const activityCliffsViewer = (await PackageFunctions.activityCliffs(
+    await PackageFunctions.activityCliffs(
       df, df.getCol('Sequence'), df.getCol('Activity'),
       96, DimReductionMethods.UMAP, MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE,
-      seqEncodingFunc, {}, true)) as DG.ScatterPlotViewer;
-    tv.dockManager.dock(activityCliffsViewer, DG.DOCK_TYPE.RIGHT, null, 'Activity Cliffs', 0.65);
-    await DG.delay(100);
-    const cliffsLink: HTMLButtonElement = $(activityCliffsViewer.root)
-      .find('button.scatter_plot_link,cliffs_grid').get()[0] as HTMLButtonElement;
-    cliffsLink.click();
-    await DG.delay(100);
+      seqEncodingFunc, {}, true);
+
+    let scatterPlot: DG.Viewer | undefined;
+    await awaitCheck(() => {
+      for (const v of tv.viewers) {
+        if (v.type === DG.VIEWER.SCATTER_PLOT) {
+          scatterPlot = v;
+          return true;
+        }
+      }
+      return false;
+    }, '', 10000);
+
+    let link: HTMLCollectionOf<Element> | undefined;
+    await awaitCheck(() => {
+      link = scatterPlot!.root.getElementsByClassName('scatter_plot_link');
+      return link.length > 0;
+    }, '', 5000);
+    (link![0] as HTMLElement).click();
+    await DG.delay(500);
+
     tv.grid.props.rowHeight = 180;
     tv.grid.col('sequence') && (tv.grid.col('sequence')!.width = 300);
     tv.grid.col('structure') && (tv.grid.col('structure')!.width = 300);
     const cliffsGrid = Array.from(tv.viewers).find((v) => v !== tv.grid && v.type === DG.VIEWER.GRID) as DG.Grid;
     if (cliffsGrid) {
       cliffsGrid.props.rowHeight = 40;
-      cliffsGrid.col('seq_diff')!.width = 600;
-      tv.dockManager.dock(cliffsGrid, DG.DOCK_TYPE.DOWN, null, 'Cliffs', 0.35);
-      tv.dockManager.dock(activityCliffsViewer, DG.DOCK_TYPE.RIGHT, null, 'Activity Cliffs', 0.55);
+      cliffsGrid.col('seq_diff') && (cliffsGrid.col('seq_diff')!.width = 600);
     }
   } catch (err: any) {
     handleError(err);

package/src/tests/detectors-tests.ts

@@ -462,8 +462,12 @@ MWRSWY-CKHPMWRSWY-CKHP`;
   // sample_testHelm.csv
   // columns: ID,Test type,HELM string,Valid?,Mol Weight,Mol Formula,SMILES
   test('samplesTestHelmCsv', async () => {
+    // Alphabet size of 8 reflects splitterAsHelm's triplet-splitting of HELM
+    // RNA monomers (each `sugar(base)phosphate` becomes 3 tokens), which can
+    // collapse what used to be N distinct triple-tokens into a smaller union
+    // of {sugar(s), bases, phosphate(s)} symbols.
     await _testDf(readSamples(Samples.testHelmCsv), {
-      'HELM string': new PosCol(NOTATION.HELM, null, null, 9, true),
+      'HELM string': new PosCol(NOTATION.HELM, null, null, 8, true),
     }, seqHelper);
   });
 

package/src/tests/splitters-test.ts

@@ -59,18 +59,22 @@ category('splitters', async () => {
         'D-Tyr_Et', 'D-Dap', 'dV', 'E', 'N', 'pnG', 'Phe_4Me'],
     ],
 
+    // splitterAsHelm triplet-splits HELM RNA monomers `sugar(base)phosphate`
+    // into 3 tokens, and `sugar(base)` (terminal-only) into 2. Standalone
+    // tokens that don't match either form (e.g. lone `P`, or non-terminal
+    // `R(U)` without a phosphate) are kept verbatim.
     testHelm1: [
       'RNA1{R(U)P.R(T)P.R(G)P.R(C)P.R(A)}$$$$',
-      ['R(U)P', 'R(T)P', 'R(G)P', 'R(C)P', 'R(A)'],
+      ['R', 'U', 'P', 'R', 'T', 'P', 'R', 'G', 'P', 'R', 'C', 'P', 'R', 'A'],
     ],
 
     testHelm2: [
       'RNA1{P.R(U)P.R(T)}$$$$',
-      ['P', 'R(U)P', 'R(T)'],
+      ['P', 'R', 'U', 'P', 'R', 'T'],
     ],
     testHelm3: [
-      'RNA1{P.R(U).P.R(T)}$$$$',
-      ['P', 'R(U)', 'P', 'R(T)'],
+      'RNA1{P.R(U).P.R(T)}$$$$', // invalid helm, but oh well,
+      ['P', 'R(U)', 'P', 'R', 'T'],
     ],
   };
 

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

@@ -356,6 +356,150 @@ PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.Thr_PO3H2.Aca.Tyr
   }
 });
 
+/** Tests for the linear HELM-RNA path: must preserve modified sugars,
+ * phosphates, and bases per nucleotide. The non-linear (HELM via POM)
+ * path is the reference; the linear path is expected to match it on
+ * canonical SMILES for these inputs. */
+category('toAtomicLevelHelmRna', async () => {
+  let monomerLibHelper: IMonomerLibHelper;
+  let userLibSettings: UserLibSettings;
+  let seqHelper: ISeqHelper;
+  let monomerLib: IMonomerLib;
+  let rdKitModule: RDModule;
+
+  before(async () => {
+    rdKitModule = await getRdKitModule();
+    seqHelper = await getSeqHelper();
+    monomerLibHelper = await getMonomerLibHelper();
+    userLibSettings = await getUserLibSettings();
+    await monomerLibHelper.loadMonomerLibForTests();
+    monomerLib = monomerLibHelper.getMonomerLib();
+  });
+
+  after(async () => {
+    await setUserLibSettings(userLibSettings);
+    await monomerLibHelper.loadMonomerLib(true);
+  });
+
+  /** Build a single-row HELM RNA dataframe and run the linear converter,
+   * returning the canonical SMILES of the resulting molfile. */
+  async function helmRnaLinearToSmiles(srcHelm: string): Promise<string> {
+    const srcCsv = `seq\n${srcHelm}`;
+    const df = DG.DataFrame.fromCsv(srcCsv);
+    await grok.data.detectSemanticTypes(df);
+    const seqCol = df.getCol('seq');
+    expect(seqCol.semType, DG.SEMTYPE.MACROMOLECULE);
+
+    const res = await _toAtomicLevel(df, seqCol, monomerLib, seqHelper, rdKitModule);
+    if (!res.molCol)
+      throw new Error(`_toAtomicLevel returned no molCol for HELM '${srcHelm}'. ` +
+        `Warnings: ${(res.warnings ?? []).join(' / ')}`);
+
+    const molfile: string | null = res.molCol.get(0);
+    if (!molfile)
+      throw new Error(`_toAtomicLevel produced an empty molfile for HELM '${srcHelm}'`);
+    let smiles: string;
+    try {
+      smiles = grok.chem.convert(molfile, grok.chem.Notation.Unknown, grok.chem.Notation.Smiles);
+    } catch (err: any) {
+      throw new Error(`SMILES conversion threw for HELM '${srcHelm}': ${err?.message ?? err}\n` +
+        `--- MOLFILE START ---\n${molfile}\n--- MOLFILE END ---`);
+    }
+    // RDKit signals a parse failure by returning the literal string
+    // "MALFORMED_INPUT_VALUE" — surface it together with the offending molfile.
+    if (smiles === 'MALFORMED_INPUT_VALUE' || /^MALFORMED/.test(smiles)) {
+      throw new Error(`RDKit could not parse molfile produced for HELM '${srcHelm}'.\n` +
+        `--- MOLFILE START ---\n${molfile}\n--- MOLFILE END ---`);
+    }
+    return smiles;
+  }
+
+  // Unmodified RNA HELM — regression baseline. The linear path must produce
+  // a real RNA backbone (sugar + phosphate + base per nucleotide), not just
+  // a chain of bases.
+  test('rna-canonical', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{r(A)p.r(C)p.r(G)p}$$$$`);
+    // Should at minimum contain phosphate (P), ribose oxygens, and a purine ring.
+    expect(/P/.test(smiles), true, `expected phosphate in SMILES: ${smiles}`);
+    // Purine fragment (any ring closure digit): n<d>cnc<d> or N<d>C=N (case insensitive).
+    expect(/n\dcnc\d/.test(smiles) || /n\dcnc/i.test(smiles), true,
+      `expected purine ring fragment in SMILES: ${smiles}`);
+  });
+
+  // Modified base — 5-methylcytosine. Linear path should preserve the
+  // methyl branch on the cytidine of position 0.
+  test('rna-modified-base', async () => {
+    const smilesPlain = await helmRnaLinearToSmiles(`RNA1{r(C)p.r(A)p}$$$$`);
+    const smilesMod = await helmRnaLinearToSmiles(`RNA1{r([m5C])p.r(A)p}$$$$`);
+    expect(smilesPlain !== smilesMod, true,
+      `m5C must change the SMILES vs. plain C. plain=${smilesPlain} mod=${smilesMod}`);
+  });
+
+  // Modified phosphate — phosphorothioate. The linker between positions 0
+  // and 1 must change (S replaces a non-bridging O).
+  test('rna-modified-phosphate', async () => {
+    const smilesPlain = await helmRnaLinearToSmiles(`RNA1{r(A)p.r(C)p}$$$$`);
+    const smilesMod = await helmRnaLinearToSmiles(`RNA1{r(A)[Rsp].r(C)p}$$$$`);
+    expect(smilesPlain !== smilesMod, true,
+      `Rsp phosphorothioate must change the SMILES vs. plain p. plain=${smilesPlain} mod=${smilesMod}`);
+    expect(/S/.test(smilesMod), true,
+      `expected sulfur in phosphorothioate SMILES: ${smilesMod}`);
+    // HELM explicitly wrote 2 phosphates (one Rsp at position 0, one p at
+    // position 1); both must appear in the molecule, so two P atoms total.
+    const pCountPlain = (smilesPlain.match(/P/g) || []).length;
+    const pCountMod = (smilesMod.match(/P/g) || []).length;
+    expect(pCountPlain, 2, `expected 2 phosphates in plain: ${smilesPlain}`);
+    expect(pCountMod, 2, `expected 2 phosphates in modified: ${smilesMod}`);
+  });
+
+  // Modified sugar — 2'-fluoro ribose. Position 0 sugar gets a fluorine.
+  test('rna-modified-sugar', async () => {
+    const smilesPlain = await helmRnaLinearToSmiles(`RNA1{r(A)p.r(C)p}$$$$`);
+    const smilesMod = await helmRnaLinearToSmiles(`RNA1{[fl2r](A)p.r(C)p}$$$$`);
+    expect(smilesPlain !== smilesMod, true,
+      `fl2r (2'-F ribose) must change the SMILES vs. plain r. plain=${smilesPlain} mod=${smilesMod}`);
+    expect(/F/.test(smilesMod), true,
+      `expected fluorine in 2'-F ribose SMILES: ${smilesMod}`);
+  });
+
+  // HELM omits the trailing phosphate (3'-OH terminus on the sugar). The
+  // splitter must split the partial `r(C)` into [r, C], assembly must skip
+  // the trailing P emit, and counts must agree.
+  test('rna-no-trailing-phosphate', async () => {
+    const smilesWith = await helmRnaLinearToSmiles(`RNA1{r(A)p.r(C)p}$$$$`);
+    const smilesNoTail = await helmRnaLinearToSmiles(`RNA1{r(A)p.r(C)}$$$$`);
+    // Both should produce valid molecules with at least one P (the linker
+    // between the two nucleotides is always present).
+    expect(/P/.test(smilesNoTail), true,
+      `expected the inter-nucleotide phosphate to remain: ${smilesNoTail}`);
+    // The version WITH trailing phosphate should have exactly one more P
+    // atom than the version without.
+    const pCountWith = (smilesWith.match(/P/g) || []).length;
+    const pCountNoTail = (smilesNoTail.match(/P/g) || []).length;
+    expect(pCountWith, pCountNoTail + 1,
+      `expected pCountWith - pCountNoTail === 1, got with=${pCountWith}, noTail=${pCountNoTail}. ` +
+      `with=${smilesWith}, noTail=${smilesNoTail}`);
+  });
+
+  // Missing trailing phosphate combined with modifications.
+  test('rna-no-trailing-phosphate-with-modifications', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{[fl2r]([m5C])[Rsp].r(A)}$$$$`);
+    expect(/F/.test(smiles), true, `expected fluorine: ${smiles}`);
+    expect(/S/.test(smiles), true, `expected sulfur: ${smiles}`);
+    // Exactly one phosphate (the Rsp linker), no trailing P.
+    const pCount = (smiles.match(/P/g) || []).length;
+    expect(pCount, 1, `expected exactly 1 phosphate: ${smiles}`);
+  });
+
+  // All three modifications combined. End-to-end smoke test.
+  test('rna-all-modifications', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{[fl2r]([m5C])[Rsp].r(A)p}$$$$`);
+    expect(/F/.test(smiles), true, `expected fluorine: ${smiles}`);
+    expect(/S/.test(smiles), true, `expected sulfur: ${smiles}`);
+    expect(/P/.test(smiles), true, `expected phosphorus: ${smiles}`);
+  });
+});
+
 
 function polishMolfile(mol: string): string {
   return mol.replaceAll('\r\n', '\n')

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

@@ -11,7 +11,7 @@ import {detectAlphabet, detectHelmAlphabet, splitterAsFastaSimple, StringListSeq
 import {mmDistanceFunctions, MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {mmDistanceFunctionType} from '@datagrok-libraries/ml/src/macromolecule-distance-functions/types';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/types/monomer-library';
-import {HELM_POLYMER_TYPE, HELM_WRAPPERS_REGEXP, PHOSPHATE_SYMBOL} from '@datagrok-libraries/bio/src/utils/const';
+import {DEOXYRIBOSE_SYMBOL, HELM_POLYMER_TYPE, HELM_WRAPPERS_REGEXP, PHOSPHATE_SYMBOL, RIBOSE_SYMBOL} from '@datagrok-libraries/bio/src/utils/const';
 import {GAP_SYMBOL, GapOriginals} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 import {CellRendererBackBase, GridCellRendererTemp} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
 import {HelmTypes} from '@datagrok-libraries/bio/src/helm/consts';
@@ -939,6 +939,11 @@ export class SeqHandler implements ISeqHandler {
 
       if (cm === GAP_SYMBOL)
         om = GapOriginals[NOTATION.FASTA];
+      // For HELM RNA, the splitter triplet-splits each nucleotide into
+      // [sugar, base, phosphate]; FASTA conversion keeps only the base, so
+      // drop standalone sugar/phosphate tokens.
+      else if (isHelm && (cm === PHOSPHATE_SYMBOL || cm === RIBOSE_SYMBOL || cm === DEOXYRIBOSE_SYMBOL))
+        om = '';
       else if (cm === PHOSPHATE_SYMBOL)
         om = '';
       else if (om.length > 1)
@@ -978,7 +983,9 @@ export class SeqHandler implements ISeqHandler {
     return joinToBiln(srcSS);
   }
 
-  /** Splits Helm sequence adjusting nucleotides to single char symbols. (!) Removes lone phosphorus. */
+  /** Splits Helm sequence adjusting nucleotides to single char symbols. (!) Removes lone phosphorus,
+   *  ribose, and deoxyribose tokens (which the underlying splitter emits when triplet-splitting
+   *  each nucleotide of an RNA chain). */
   private splitterAsHelmNucl(src: string): ISeqSplitted {
     const srcMList: ISeqSplitted = this.splitter(src);
     const tgtMList: (string | null)[] = new Array<string>(srcMList.length);
@@ -988,7 +995,8 @@ export class SeqHandler implements ISeqHandler {
       let om: string | null = srcMList.getOriginal(posIdx);
       if (isDna || isRna) {
         om = om.replace(HELM_WRAPPERS_REGEXP, '$1');
-        om = om === PHOSPHATE_SYMBOL ? null : om;
+        if (om === PHOSPHATE_SYMBOL || om === RIBOSE_SYMBOL || om === DEOXYRIBOSE_SYMBOL)
+          om = null;
       }
       tgtMList[posIdx] = om ? om : null;
     }
@@ -1009,18 +1017,26 @@ export class SeqHandler implements ISeqHandler {
 // -- joiners --
 
 function joinToSeparator(seqS: ISeqSplitted, tgtSeparator: string, isHelm: boolean): string {
-  const resMList: string[] = new Array<string>(seqS.length);
+  const resMList: string[] = [];
   for (let posIdx: number = 0; posIdx < seqS.length; ++posIdx) {
     const cm = seqS.getCanonical(posIdx);
     let om = seqS.getOriginal(posIdx);
     if (isHelm)
       om = om.replace(HELM_WRAPPERS_REGEXP, '$1');
 
-    if (cm === GAP_SYMBOL)
-      om = GapOriginals[NOTATION.SEPARATOR];
-    else if (cm === PHOSPHATE_SYMBOL)
-      om = '';
-    resMList[posIdx] = om;
+    if (cm === GAP_SYMBOL) {
+      resMList.push(GapOriginals[NOTATION.SEPARATOR]);
+      continue;
+    }
+    // For HELM RNA, the splitter triplet-splits each nucleotide into
+    // [sugar, base, phosphate]; separator conversion keeps only the base, so
+    // skip standalone sugar/phosphate tokens entirely (rather than emitting
+    // an empty cell that would show up as an extra separator in the output).
+    if (isHelm && (cm === PHOSPHATE_SYMBOL || cm === RIBOSE_SYMBOL || cm === DEOXYRIBOSE_SYMBOL))
+      continue;
+    if (cm === PHOSPHATE_SYMBOL)
+      continue;
+    resMList.push(om);
   }
   return resMList.join(tgtSeparator);
 }