@datagrok/bio 2.1.4 → 2.1.8

package/files/tests/SPGI-derived.csv

@@ -0,0 +1,320 @@
+vals
+"6.3
+
+43.0
+
+
+561.0
+
+
+24.0"
+"80.0
+
+421.0
+
+
+4.3
+6.6"
+"231.0
+
+
+225.0
+
+
+
+
+
+
+43.0
+
+
+
+
+
+
+
+
+
+
+
+
+
+3.9"
+"348.0
+
+
+
+26.0"
+"40.2
+
+
+364.0"
+"25.0
+
+
+
+215.0
+
+
+
+
+69.0
+
+
+3.2
+6.9"
+"12.0
+
+
+
+
+
+1392.0
+
+
+
+
+
+
+
+6.0"
+"367.0
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+284.0"
+"118.0
+79.0
+
+
+
+161.0
+
+
+3.0
+
+
+
+24.0
+
+
+
+8.0"
+"149.0
+
+
+
+
+
+
+
+95.7
+
+
+564.0
+153.0"
+"126.0
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+89.7"
+"294.0
+60.0
+
+
+
+
+
+
+
+
+
+
+594.0
+
+
+
+190.0
+
+
+
+533.0
+
+
+
+
+
+671.0
+304.0"
+"2.0
+
+
+
+
+
+
+
+
+
+
+24.0
+89.0
+
+
+
+
+2443.0
+
+
+
+
+
+108.0
+
+
+
+
+
+
+
+
+
+119.0"
+"240.0
+
+
+
+2.0
+
+
+
+
+
+
+36.0
+
+
+
+
+8.0"
+"223.0
+
+
+
+372.0
+93.0
+
+
+
+
+30.0"
+"30.0
+
+
+
+
+5955.0
+137.0
+
+
+
+2.0
+
+
+
+
+
+
+
+
+
+26.0"
+"37.5
+
+
+
+166.0"
+"135.0
+
+17.0"
+"1173.0
+539.0"
+"2860.0
+
+
+3940.0"
+"763.0
+1547.0"
+"139.0
+
+426.0"
+"307.0
+
+
+86.3"
+865
+605
+226
+8
+231
+"54.0
+
+43.3
+
+
+
+
+
+
+
+
+
+90.9
+
+
+
+687.0"
+"4.0
+
+
+9.0"

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.1.4",
+  "version": "2.1.8",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",
@@ -14,8 +14,8 @@
   },
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.9.15",
-    "@datagrok-libraries/chem-meta": "1.0.1",
+    "@datagrok-libraries/bio": "^5.10.0",
+    "@datagrok-libraries/chem-meta": "^1.0.1",
     "@datagrok-libraries/ml": "^6.2.2",
     "@datagrok-libraries/utils": "^1.15.5",
     "cash-dom": "^8.0.0",

package/scripts/generate_fasta_csv_for_alphabets.R

@@ -4,17 +4,12 @@ library(random)
 alphabetDna <- c('A','C','G','T')
 alphabetRna <- c('A','C','G','U')
 alphabetPt <- c('G', 'L', 'Y', 'S', 'E', 'Q', 'D', 'N', 'F', 'A',
-                'K', 'R', 'H', 'C', 'V', 'P', 'W', 'I', 'M', 'T',)
+                'K', 'R', 'H', 'C', 'V', 'P', 'W', 'I', 'M', 'T')
 
-toAlphabet <- function(v, a;ph){
+toAlphabet <- function(v, alph){
   paste(sapply(v, function(ci){ alph[ci]; }), collapse = '')
 }
 
-mutateString <- function(s, p){
-
-}
-
-seq <- toAlphabet(sample.int(4, 35, replace=TRUE), alphabet);
 seqPt <- toAlphabet(sample.int(20, 35, replace=TRUE), alphabetPt);
 seqDna <- toAlphabet(sample.int(4, 35, replace=TRUE), alphabetDna);
 seqRna <- toAlphabet(sample.int(4, 35, replace=TRUE), alphabetRna);
@@ -60,8 +55,10 @@ seq_mutate <- function(s, p, alphabet){
   res_s;
 }
 
-fastaDna_df <- data.frame(id = 1:100, sequence = sapply(1:100, function(id){ seq_mutate(seqDna, seq_p1, alphabetDna)}));
-write_csv(fastaDna_df, 'D:/HOME/atanas/Datagrok/projs/public/packages/Bio/files/samples/sample_FASTA_DNA.csv');
+for (n in c(100,1000,10000, 100000, 1000000)){
+  fastaDna_df <- data.frame(id = 1:n, sequence = sapply(1:n, function(id){ seq_mutate(seqDna, seq_p1, alphabetDna)}));
+  write_csv(fastaDna_df, sprintf('../files/data/sample_FASTA_DNA-%d.csv', n));
+}
 
 fastaRna_df <- data.frame(id = 1:100, sequence = sapply(1:100, function(id){ seq_mutate(seqRna, seq_p2, alphabetRna)}));
 write_csv(fastaRna_df, 'D:/HOME/atanas/Datagrok/projs/public/packages/Bio/files/samples/sample_FASTA_RNA.csv');

package/src/__jest__/remote.test.ts

@@ -39,33 +39,39 @@ it('TEST', async () => {
   const targetPackage: string = process.env.TARGET_PACKAGE ?? 'Bio';
   console.log(`Testing ${targetPackage} package`);
 
-  const r = await page.evaluate((targetPackage): Promise<object> => {
+  let r = await page.evaluate((targetPackage):Promise<object> => {
     return new Promise<object>((resolve, reject) => {
       (<any>window).grok.functions.eval(targetPackage + ':test()').then((df: any) => {
         const cStatus = df.columns.byName('success');
+        const cSkipped = df.columns.byName('skipped');
         const cMessage = df.columns.byName('result');
         const cCat = df.columns.byName('category');
         const cName = df.columns.byName('name');
         const cTime = df.columns.byName('ms');
         let failed = false;
+        let skipReport = '';
         let passReport = '';
         let failReport = '';
         for (let i = 0; i < df.rowCount; i++) {
           if (cStatus.get(i)) {
-            passReport += `Test result : Success : ${cTime.get(i)} : ` +
-              `${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
+            if (cSkipped.get(i)) {
+              skipReport += `Test result : Skipped : ${cTime.get(i)} : ${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
+            } else {
+              passReport += `Test result : Success : ${cTime.get(i)} : ${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
+            }
           } else {
             failed = true;
-            failReport += `Test result : Failed : ${cTime.get(i)} : ` +
-              `${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
+            failReport += `Test result : Failed : ${cTime.get(i)} : ${targetPackage}.${cCat.get(i)}.${cName.get(i)} : ${cMessage.get(i)}\n`;
           }
         }
-        resolve({failReport, passReport, failed});
+        resolve({failReport, skipReport, passReport, failed});
       }).catch((e: any) => reject(e));
     });
   }, targetPackage);
   // @ts-ignore
   console.log(r.passReport);
   // @ts-ignore
+  console.log(r.skipReport);
+  // @ts-ignore
   expect(r.failed).checkOutput(false, r.failReport);
-}, 3600000);
+}, 7200000);

package/src/package-test.ts

@@ -3,20 +3,21 @@ import * as DG from 'datagrok-api/dg';
 import {runTests, TestContext, tests} from '@datagrok-libraries/utils/src/test';
 
 import './tests/Palettes-test';
-import './tests/detectors-test';
+import './tests/detectors-tests';
+import './tests/detectors-benchmark-tests';
 import './tests/msa-tests';
 import './tests/sequence-space-test';
 import './tests/activity-cliffs-tests';
 import './tests/splitters-test';
 import './tests/renderers-test';
-import './tests/convert-test';
+import './tests/converters-test';
 import './tests/fasta-handler-test';
 import './tests/fasta-export-tests';
 import './tests/bio-tests';
 import './tests/WebLogo-positions-test';
 import './tests/checkInputColumn-tests';
 import './tests/similarity-diversity-tests';
-import './tests/substructure-filter-tests';
+import './tests/substructure-filters-tests';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -11,23 +11,26 @@ import {runKalign, testMSAEnoughMemory} from './utils/multiple-sequence-alignmen
 import {SequenceAlignment, Aligned} from './seq_align';
 import {getEmbeddingColsNames, sequenceSpace, sequenceSpaceByFingerprints} from './analysis/sequence-space';
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
-import {createLinesGrid, createPropPanelElement, createTooltipElement, getChemSimilaritiesMarix, getSimilaritiesMarix} from './analysis/sequence-activity-cliffs';
-import {createJsonMonomerLibFromSdf, encodeMonomers, getMolfilesFromSeq} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {
+  createLinesGrid,
+  createPropPanelElement,
+  createTooltipElement,
+  getChemSimilaritiesMarix,
+  getSimilaritiesMarix
+} from './analysis/sequence-activity-cliffs';
+import {
+  createJsonMonomerLibFromSdf,
+  encodeMonomers,
+  getMolfilesFromSeq
+} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {HELM_CORE_LIB_FILENAME} from '@datagrok-libraries/bio/src/utils/const';
 import {getMacroMol} from './utils/atomic-works';
 import {MacromoleculeSequenceCellRenderer} from './utils/cell-renderer';
 import {convert} from './utils/convert';
 import {getMacroMolColumnPropertyPanel, representationsWidget} from './widgets/representations';
-import {MonomerFreqs, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule'
 import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
 import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
 import {removeEmptyStringRows} from '@datagrok-libraries/utils/src/dataframe-utils';
-import {
-  generateManySequences,
-  generateLongSequence,
-  performanceTest
-} from './tests/test-sequnces-generators';
 
 import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter';
 import * as C from './utils/constants';
@@ -36,11 +39,14 @@ import {SequenceDiversityViewer} from './analysis/sequence-diversity-viewer';
 import {invalidateMols, MONOMERIC_COL_TAGS, substructureSearchDialog} from './substructure-search/substructure-search';
 import {saveAsFastaUI} from './utils/save-as-fasta';
 import {BioSubstructureFilter} from './widgets/bio-substructure-filter';
-import { getMonomericMols } from './calculations/monomerLevelMols';
-import { delay } from '@datagrok-libraries/utils/src/test';
+import {getMonomericMols} from './calculations/monomerLevelMols';
+import {delay} from '@datagrok-libraries/utils/src/test';
 import {from, Observable, Subject} from 'rxjs';
-import {Monomer, IMonomerLib, MonomerWorks, MonomerLib, readLibrary,
-        SeqPalette, UnitsHandler, WebLogoViewer, getStats, splitterAsHelm} from '@datagrok-libraries/bio';
+import {
+  TAGS as bio_TAGS,
+  Monomer, IMonomerLib, MonomerWorks, MonomerLib, readLibrary,
+  SeqPalette, UnitsHandler, WebLogoViewer, getStats, splitterAsHelm
+} from '@datagrok-libraries/bio';
 
 const STORAGE_NAME = 'Libraries';
 const LIB_PATH = 'System:AppData/Bio/libraries';
@@ -51,6 +57,7 @@ export let hydrophobPalette: SeqPaletteCustom | null = null;
 
 export class SeqPaletteCustom implements SeqPalette {
   private readonly _palette: { [m: string]: string };
+
   constructor(palette: { [m: string]: string }) {
     this._palette = palette;
   }
@@ -67,7 +74,7 @@ export async function initBio() {
   let logPs: number[] = [];
   const module = await grok.functions.call('Chem:getRdKitModule');
 
-    
+
   const series = monomerLib!.getMonomerMolsByType('PEPTIDE')!;
   Object.keys(series).forEach(symbol => {
     monomers.push(symbol);
@@ -81,7 +88,7 @@ export async function initBio() {
   const sum = logPs.reduce((a, b) => a + b, 0);
   const avg = (sum / logPs.length) || 0;
 
-  let palette: {[monomer: string]: string} = {};
+  let palette: { [monomer: string]: string } = {};
   for (let i = 0; i < monomers.length; i++) {
     palette[monomers[i]] = logPs[i] < avg ? '#4682B4' : '#DC143C';
   }
@@ -134,7 +141,7 @@ export async function libraryPanel(seqColumn: DG.Column): Promise<DG.Widget> {
   let uploadedLibraries: string[] = Object.values(await grok.dapi.userDataStorage.get(STORAGE_NAME, true));
   for (let i = 0; i < uploadedLibraries.length; ++i) {
     let libraryName: string = uploadedLibraries[i];
-    divInputs.append(ui.boolInput(libraryName, true, async() => {
+    divInputs.append(ui.boolInput(libraryName, true, async () => {
       grok.dapi.userDataStorage.remove(STORAGE_NAME, libraryName, true);
       await loadLibraries();
     }).root);
@@ -283,9 +290,9 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
   };
   const tags = {
     'units': macroMolecule.getTag(DG.TAGS.UNITS),
-    'aligned': macroMolecule.getTag(TAGS.aligned),
-    'separator': macroMolecule.getTag(TAGS.separator),
-    'alphabet': macroMolecule.getTag(TAGS.alphabet),
+    'aligned': macroMolecule.getTag(bio_TAGS.aligned),
+    'separator': macroMolecule.getTag(bio_TAGS.separator),
+    'alphabet': macroMolecule.getTag(bio_TAGS.alphabet),
   };
   const sp = await getActivityCliffs(
     df,
@@ -343,7 +350,8 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
     return grok.shell
       .tableView(table.name)
       .scatterPlot({x: embedColsNames[0], y: embedColsNames[1], title: 'Sequence space'});
-  };
+  }
+  ;
 
   /*   const encodedCol = encodeMonomers(macroMolecule);
   if (!encodedCol)
@@ -580,7 +588,7 @@ export async function testDetectMacromolecule(path: string): Promise<DG.DataFram
 //tags: panel, bio
 //input: column col {semType: Macromolecule}
 export function splitToMonomers(col: DG.Column<string>): void {
-  if (!col.getTag(TAGS.aligned).includes(C.MSA))
+  if (!col.getTag(bio_TAGS.aligned).includes(C.MSA))
     return grok.shell.error('Splitting is applicable only for aligned sequences');
 
   const tempDf = splitAlignedSequences(col);