@datagrok/bio 2.22.11 → 2.22.12

package/dockerfiles/container.json

@@ -1,6 +1,6 @@
 {
   "cpu": 1,
   "memory": 1024,
-  "on_demand": true,
+  "on_demand": true, 
   "shutdown_timeout": 30
-}
+}

package/package.json

@@ -5,7 +5,7 @@
     "name": "Davit Rizhinashvili",
     "email": "drizhinashvili@datagrok.ai"
   },
-  "version": "2.22.11",
+  "version": "2.22.12",
   "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",
@@ -49,7 +49,7 @@
     "@datagrok-libraries/math": "^1.2.4",
     "@datagrok-libraries/ml": "^6.10.4",
     "@datagrok-libraries/tutorials": "^1.6.1",
-    "@datagrok-libraries/utils": "^4.6.3",
+    "@datagrok-libraries/utils": "^4.6.5",
     "@webgpu/types": "^0.1.40",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0",
@@ -73,7 +73,7 @@
     "@types/wu": "^2.1.44",
     "@typescript-eslint/eslint-plugin": "^8.8.1",
     "@typescript-eslint/parser": "^8.8.1",
-    "datagrok-tools": "^4.14.48",
+    "datagrok-tools": "^4.14.57",
     "eslint": "^8.57.1",
     "eslint-config-google": "^0.14.0",
     "eslint-plugin-rxjs": "^5.0.3",

package/src/package-api.ts

@@ -40,6 +40,10 @@ export namespace funcs {
     return await grok.functions.call('Bio:SequenceTooltip', { col });
   }
 
+  export async function standardiseMonomerLibrary(library: string ): Promise<string> {
+    return await grok.functions.call('Bio:StandardiseMonomerLibrary', { library });
+  }
+
   export async function getBioLib(): Promise<any> {
     return await grok.functions.call('Bio:GetBioLib', {});
   }

package/src/package.g.ts

@@ -25,6 +25,15 @@ export async function standardiseMonomerLibrary(library: string) : Promise<strin
   return await PackageFunctions.standardiseMonomerLibrary(library);
 }
 
+//description: Matches molecules in a column with monomers from the selected library(s)
+//input: dataframe table 
+//input: column molecules { semType: Molecule }
+//input: string polymerType = 'PEPTIDE' { choices: ["PEPTIDE","RNA","CHEM"]; caption: Polymer Type }
+//top-menu: Bio | Manage | Match with Monomer Library...
+export async function matchWithMonomerLibrary(table: DG.DataFrame, molecules: DG.Column, polymerType: any) : Promise<void> {
+  await PackageFunctions.matchWithMonomerLibrary(table, molecules, polymerType);
+}
+
 //output: object monomerLib
 export function getBioLib() : any {
   return PackageFunctions.getBioLib();
@@ -126,8 +135,8 @@ export function macromoleculeDifferenceCellRenderer() : any {
   return PackageFunctions.macromoleculeDifferenceCellRenderer();
 }
 
-//input: string alignType { choices: ['Local alignment','Global alignment'] }
-//input: string alignTable { choices: ['AUTO','NUCLEOTIDES','BLOSUM45','BLOSUM50','BLOSUM62','BLOSUM80','BLOSUM90','PAM30','PAM70','PAM250','SCHNEIDER','TRANS'] }
+//input: string alignType { choices: ["Local alignment","Global alignment"] }
+//input: string alignTable { choices: ["AUTO","NUCLEOTIDES","BLOSUM45","BLOSUM50","BLOSUM62","BLOSUM80","BLOSUM90","PAM30","PAM70","PAM250","SCHNEIDER","TRANS"] }
 //input: double gap 
 //input: string seq1 
 //input: string seq2 
@@ -182,9 +191,9 @@ export async function getRegionTopMenu(table: DG.DataFrame, sequence: DG.Column,
 //input: dataframe table { description: Input data table }
 //input: string molecules { semType: Macromolecule; description: Input data table }
 //input: column activities 
-//input: double similarity { default: 80; description: Similarity cutoff }
-//input: string methodName { choices: ['UMAP','t-SNE'] }
-//input: string similarityMetric { choices: ['Hamming','Levenshtein','Monomer chemical distance'] }
+//input: double similarity = 80 { description: Similarity cutoff }
+//input: string methodName { choices: ["UMAP","t-SNE"] }
+//input: string similarityMetric { choices: ["Hamming","Levenshtein","Monomer chemical distance"] }
 //input: func preprocessingFunction 
 //input: object options { optional: true }
 //input: bool demo { optional: true }
@@ -198,9 +207,9 @@ export async function activityCliffs(table: DG.DataFrame, molecules: DG.Column<a
 //tags: dim-red-preprocessing-function
 //input: column col { semType: Macromolecule }
 //input: string metric 
-//input: double gapOpen { default: 1; caption: Gap open penalty; optional: true }
-//input: double gapExtend { default: 0.6; caption: Gap extension penalty; optional: true }
-//input: string fingerprintType { caption: Fingerprint type; default: Morgan; choices: ['Morgan','RDKit','Pattern','AtomPair','MACCS','TopologicalTorsion']; optional: true }
+//input: double gapOpen = 1 { caption: Gap open penalty; optional: true }
+//input: double gapExtend = 0.6 { caption: Gap extension penalty; optional: true }
+//input: string fingerprintType = 'Morgan' { caption: Fingerprint type; choices: ["Morgan","RDKit","Pattern","AtomPair","MACCS","TopologicalTorsion"]; optional: true }
 //output: object result
 //meta.supportedSemTypes: Macromolecule
 //meta.supportedTypes: string
@@ -225,12 +234,12 @@ export async function helmPreprocessingFunction(col: DG.Column<any>, _metric: an
 //description: Creates 2D sequence space with projected sequences by pairwise distance
 //input: dataframe table 
 //input: column molecules { semType: Macromolecule }
-//input: string methodName { choices: ['UMAP','t-SNE'] }
-//input: string similarityMetric { choices: ['Hamming','Levenshtein','Monomer chemical distance'] }
-//input: bool plotEmbeddings { default: true }
+//input: string methodName { choices: ["UMAP","t-SNE"] }
+//input: string similarityMetric { choices: ["Hamming","Levenshtein","Monomer chemical distance"] }
+//input: bool plotEmbeddings = true 
 //input: func preprocessingFunction { optional: true }
 //input: object options { optional: true }
-//input: bool clusterEmbeddings { optional: true; default: true }
+//input: bool clusterEmbeddings = true { optional: true }
 //input: bool isDemo { optional: true }
 //top-menu: Bio | Analyze | Sequence Space...
 //editor: Bio:SequenceSpaceEditor
@@ -242,8 +251,8 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, molecules: DG.Co
 //description: Converts sequences to molblocks
 //input: dataframe table { description: Input data table }
 //input: column seqCol { semType: Macromolecule; caption: Sequence }
-//input: bool nonlinear { default: false; caption: Non-linear; description: Slower mode for cycling/branching HELM structures }
-//input: bool highlight { default: false; caption: Highlight monomers; description: Highlight monomers' substructures of the molecule }
+//input: bool nonlinear = false { caption: Non-linear; description: Slower mode for cycling/branching HELM structures }
+//input: bool highlight = false { caption: Highlight monomers; description: Highlight monomers' substructures of the molecule }
 //top-menu: Bio | Transform | To Atomic Level...
 export async function toAtomicLevel(table: DG.DataFrame, seqCol: DG.Column, nonlinear: boolean, highlight: boolean) : Promise<void> {
   await PackageFunctions.toAtomicLevel(table, seqCol, nonlinear, highlight);
@@ -338,7 +347,7 @@ export function monomerCellRenderer() : any {
   return PackageFunctions.monomerCellRenderer();
 }
 
-//input: string path { choices: ['Demo:Files/','System:AppData/'] }
+//input: string path { choices: ["Demo:Files/","System:AppData/"] }
 //output: dataframe result
 export async function testDetectMacromolecule(path: string) : Promise<any> {
   return await PackageFunctions.testDetectMacromolecule(path);
@@ -408,7 +417,7 @@ export function SubsequenceSearchTopMenu(macromolecules: DG.Column) : void {
   PackageFunctions.SubsequenceSearchTopMenu(macromolecules);
 }
 
-//name: Identity Scoring
+//name: Identity
 //description: Adds a column with fraction of matching monomers
 //input: dataframe table { description: Table containing Macromolecule column }
 //input: column macromolecule { semType: Macromolecule; description: Sequences to score }
@@ -419,7 +428,7 @@ export async function sequenceIdentityScoring(table: DG.DataFrame, macromolecule
   return await PackageFunctions.sequenceIdentityScoring(table, macromolecule, reference);
 }
 
-//name: Similarity Scoring
+//name: Similarity
 //description: Adds a column with similarity scores, calculated as sum of monomer fingerprint similarities
 //input: dataframe table { description: Table containing Macromolecule column }
 //input: column macromolecule { semType: Macromolecule; description: Sequences to score }
@@ -486,30 +495,37 @@ export function bioSubstructureFilterTest() : any {
   return PackageFunctions.bioSubstructureFilterTest();
 }
 
+//name: webLogoLargeApp
 export async function webLogoLargeApp() : Promise<void> {
   await PackageFunctions.webLogoLargeApp();
 }
 
+//name: webLogoAggApp
 export async function webLogoAggApp() : Promise<void> {
   await PackageFunctions.webLogoAggApp();
 }
 
+//name: getRegionApp
 export async function getRegionApp() : Promise<void> {
   await PackageFunctions.getRegionApp();
 }
 
+//name: getRegionHelmApp
 export async function getRegionHelmApp() : Promise<void> {
   await PackageFunctions.getRegionHelmApp();
 }
 
+//name: longSeqTableSeparator
 export function longSeqTableSeparator() : void {
   PackageFunctions.longSeqTableSeparator();
 }
 
+//name: longSeqTableFasta
 export function longSeqTableFasta() : void {
   PackageFunctions.longSeqTableFasta();
 }
 
+//name: longSeqTableHelm
 export function longSeqTableHelm() : void {
   PackageFunctions.longSeqTableHelm();
 }
@@ -523,15 +539,14 @@ export function addCopyMenu(cell: any, menu: any) : void {
 //description: Sequence similarity tracking and evaluation dataset diversity
 //meta.demoPath: Bioinformatics | Similarity, Diversity
 //meta.path: /apps/Tutorials/Demo/Bioinformatics/Similarity,%20Diversity
-//meta.demoSkip: GROK-14320
 export async function demoBioSimilarityDiversity() : Promise<void> {
   await PackageFunctions.demoBioSimilarityDiversity();
 }
 
 //description: Exploring sequence space of Macromolecules, comparison with hierarchical clustering results
+//meta.isDemoDashboard: true
 //meta.demoPath: Bioinformatics | Sequence Space
 //meta.path: /apps/Tutorials/Demo/Bioinformatics/Sequence%20Space
-//meta.demoSkip: GROK-14320
 export async function demoBioSequenceSpace() : Promise<void> {
   await PackageFunctions.demoBioSequenceSpace();
 }
@@ -539,7 +554,6 @@ export async function demoBioSequenceSpace() : Promise<void> {
 //description: Activity Cliffs analysis on Macromolecules data
 //meta.demoPath: Bioinformatics | Activity Cliffs
 //meta.path: /apps/Tutorials/Demo/Bioinformatics/Activity%20Cliffs
-//meta.demoSkip: GROK-14320
 export async function demoBioActivityCliffs() : Promise<void> {
   await PackageFunctions.demoBioActivityCliffs();
 }
@@ -547,7 +561,6 @@ export async function demoBioActivityCliffs() : Promise<void> {
 //description: Atomic level structure of Macromolecules
 //meta.demoPath: Bioinformatics | Atomic Level
 //meta.path: /apps/Tutorials/Demo/Bioinformatics/Atomic%20Level
-//meta.demoSkip: GROK-14320
 export async function demoBioAtomicLevel() : Promise<void> {
   await PackageFunctions.demoBioAtomicLevel();
 }
@@ -578,7 +591,7 @@ export async function seqIdentity(seq: string, ref: string) : Promise<any> {
 
 //input: file file 
 //input: string colName 
-//input: double probeCount { default: 100 }
+//input: double probeCount = 100 
 export async function detectMacromoleculeProbe(file: DG.FileInfo, colName: string, probeCount: number) : Promise<void> {
   await PackageFunctions.detectMacromoleculeProbe(file, colName, probeCount);
 }
@@ -590,7 +603,7 @@ export async function getSeqHelper() : Promise<any> {
 
 //input: dataframe df 
 //input: column helmCol 
-//input: bool chiralityEngine { default: true }
+//input: bool chiralityEngine = true 
 //output: column result
 export async function getMolFromHelm(df: DG.DataFrame, helmCol: DG.Column<any>, chiralityEngine: boolean) : Promise<any> {
   return await PackageFunctions.getMolFromHelm(df, helmCol, chiralityEngine);

package/src/package.ts

@@ -70,12 +70,13 @@ import {GetRegionFuncEditor} from './utils/get-region-func-editor';
 import {sequenceToMolfile} from './utils/sequence-to-mol';
 import {detectMacromoleculeProbeDo} from './utils/detect-macromolecule-probe';
 import {getMolColumnFromHelm} from './utils/helm-to-molfile/utils';
-import {MonomerManager, standardizeMonomerLibrary} from './utils/monomer-lib/monomer-manager/monomer-manager';
+import {matchMoleculesWithMonomers, MonomerManager, standardizeMonomerLibrary} from './utils/monomer-lib/monomer-manager/monomer-manager';
 import {calculateScoresWithEmptyValues} from './utils/calculate-scores';
 import {SeqHelper} from './utils/seq-helper/seq-helper';
 import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
 import {molecular3DStructureWidget, toAtomicLevelWidget} from './widgets/to-atomic-level-widget';
 import {handleSequenceHeaderRendering} from './widgets/sequence-scrolling-widget';
+import {PolymerType} from '@datagrok-libraries/js-draw-lite/src/types/org';
 export const _package = new BioPackage(/*{debug: true}/**/);
 export * from './package.g';
 
@@ -143,6 +144,14 @@ export class PackageFunctions {
     return await standardizeMonomerLibrary(library);
   }
 
+  @grok.decorators.func({'top-menu': 'Bio | Manage | Match with Monomer Library...', description: 'Matches molecules in a column with monomers from the selected library(s)',})
+  static async matchWithMonomerLibrary(table: DG.DataFrame,
+      @grok.decorators.param({type: 'column', options: {semType: 'Molecule'}})molecules: DG.Column,
+      @grok.decorators.param({type: 'string', options: {choices: ['PEPTIDE', 'RNA', 'CHEM'], initialValue: 'PEPTIDE', caption: 'Polymer Type'}})polymerType: PolymerType = 'PEPTIDE') {
+    const matchDF = await matchMoleculesWithMonomers(table, molecules.name, _package.monomerLib, polymerType);
+    grok.shell.addTableView(matchDF);
+  }
+
   // Keep for backward compatibility
   @grok.decorators.func({outputs: [{type: 'object', name: 'monomerLib'}]})
   static getBioLib(): IMonomerLib {
@@ -939,14 +948,14 @@ export class PackageFunctions {
   }
 
   @grok.decorators.func({
-    name: 'Identity Scoring',
+    name: 'Identity',
     description: 'Adds a column with fraction of matching monomers',
     'top-menu': 'Bio | Calculate | Identity...',
   })
   static async sequenceIdentityScoring(
-    @grok.decorators.param({options: {description: 'Table containing Macromolecule column'}})table: DG.DataFrame,
+    @grok.decorators.param({options: {description: 'Table containing Macromolecule column'}}) table: DG.DataFrame,
     @grok.decorators.param({options: {semType: 'Macromolecule', description: 'Sequences to score'}}) macromolecule: DG.Column,
-    @grok.decorators.param({options: {description: 'Sequence,matching column format'}})reference: string
+    @grok.decorators.param({options: {description: 'Sequence,matching column format'}}) reference: string
   ): Promise<DG.Column<number>> {
     const seqHelper = _package.seqHelper;
     const scores = calculateScoresWithEmptyValues(table, macromolecule, reference, SCORE.IDENTITY, seqHelper);
@@ -954,14 +963,14 @@ export class PackageFunctions {
   }
 
   @grok.decorators.func({
-    name: 'Similarity Scoring',
+    name: 'Similarity',
     description: 'Adds a column with similarity scores, calculated as sum of monomer fingerprint similarities',
     'top-menu': 'Bio | Calculate | Similarity...',
   })
   static async sequenceSimilarityScoring(
-    @grok.decorators.param({options: {description: 'Table containing Macromolecule column'}})table: DG.DataFrame,
+    @grok.decorators.param({options: {description: 'Table containing Macromolecule column'}}) table: DG.DataFrame,
     @grok.decorators.param({options: {semType: 'Macromolecule', description: 'Sequences to score'}}) macromolecule: DG.Column,
-    @grok.decorators.param({options: {description: 'Sequence,matching column format'}})reference: string
+    @grok.decorators.param({options: {description: 'Sequence,matching column format'}}) reference: string
   ): Promise<DG.Column<number>> {
     const seqHelper = _package.seqHelper;
     const scores = calculateScoresWithEmptyValues(table, macromolecule, reference, SCORE.SIMILARITY, seqHelper);
@@ -1137,7 +1146,6 @@ export class PackageFunctions {
     description: 'Sequence similarity tracking and evaluation dataset diversity',
     demoPath: 'Bioinformatics | Similarity, Diversity',
     path: '/apps/Tutorials/Demo/Bioinformatics/Similarity,%20Diversity',
-    demoSkip: 'GROK-14320'
   })
   static async demoBioSimilarityDiversity(): Promise<void> {
     await demoBioSimDiv();
@@ -1147,7 +1155,9 @@ export class PackageFunctions {
     description: 'Exploring sequence space of Macromolecules, comparison with hierarchical clustering results',
     demoPath: 'Bioinformatics | Sequence Space',
     path: '/apps/Tutorials/Demo/Bioinformatics/Sequence%20Space',
-    demoSkip: 'GROK-14320'
+    meta: {
+      isDemoDashboard: 'true'
+    }
   })
   static async demoBioSequenceSpace(): Promise<void> {
     await demoSeqSpace();
@@ -1157,7 +1167,6 @@ export class PackageFunctions {
     description: 'Activity Cliffs analysis on Macromolecules data',
     demoPath: 'Bioinformatics | Activity Cliffs',
     path: '/apps/Tutorials/Demo/Bioinformatics/Activity%20Cliffs',
-    demoSkip: 'GROK-14320'
   })
   static async demoBioActivityCliffs(): Promise<void> {
     await demoActivityCliffsCyclic();
@@ -1167,7 +1176,6 @@ export class PackageFunctions {
     description: 'Atomic level structure of Macromolecules',
     demoPath: 'Bioinformatics | Atomic Level',
     path: '/apps/Tutorials/Demo/Bioinformatics/Atomic%20Level',
-    demoSkip: 'GROK-14320'
   })
   static async demoBioAtomicLevel(): Promise<void> {
     await demoToAtomicLevel();

package/src/tests/renderers-test.ts

@@ -65,7 +65,7 @@ category('renderers', () => {
 
   test('scatterPlotTooltip', async () => {
     await _testScatterPlotTooltip();
-  }, {skipReason: 'GROK-17450'});
+  });
 
   async function _rendererMacromoleculeFasta() {
     const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/FASTA.csv');

package/src/tests/viewers.ts

@@ -6,19 +6,14 @@ import {category, test, testViewer} from '@datagrok-libraries/utils/src/test';
 import {readDataframe} from './utils';
 
 
-category('viewers', () => {
-  const viewers = DG.Func.find({package: 'Bio', tags: ['viewer']}).map((f) => f.friendlyName);
-  for (const v of viewers) {
-    test(v, async () => {
-      const df = await readDataframe('samples/FASTA_DNA.csv');
-      await testViewer(v, df, {detectSemanticTypes: true});
-    }, {
-      skipReason: {
-        'Sequence Similarity Search': 'GROK-13162',
-        'Sequence Diversity Search': 'GROK-13162',
-        'WebLogo': 'GROK-13162',
-        'VdRegions': 'GROK-13162',
-      }[v],
-    });
-  }
-});
+// category('viewers', () => {
+//   const viewers = DG.Func.find({package: 'Bio', tags: ['viewer']}).map((f) => f.friendlyName);
+//   for (const v of viewers) {
+//     test(v, async () => {
+//       const df = await readDataframe('samples/FASTA_DNA.csv');
+//       await df.meta.detectSemanticTypes();
+//       await grok.data.detectSemanticTypes(df);
+//       await testViewer(v, df, {detectSemanticTypes: true});
+//     });
+//   }
+// });

package/src/utils/monomer-lib/monomer-manager/monomer-manager.ts

@@ -57,6 +57,53 @@ export async function standardiseMonomers(monomers: Monomer[]) {
   return fixedMonomers;
 }
 
+/// matches molecules in the dataframe with monomers in the library by canonical smiles
+export async function matchMoleculesWithMonomers(molDf: DG.DataFrame, molColName: string, monomerLib: IMonomerLib, polymerType: PolymerType = 'PEPTIDE'): Promise<DG.DataFrame> {
+  const converterFunc = DG.Func.find({package: 'Chem', name: 'convertMoleculeNotation'})[0];
+  if (!converterFunc)
+    throw new Error('Function convertMoleculeNotation not found, please install Chem package');
+  // first: stamdardize monomers
+  const monomers = monomerLib.getMonomerSymbolsByType(polymerType).map((s) => monomerLib.getMonomer(polymerType, s)!).filter((m) => m && (m.smiles || m.molfile));
+  const fixedMonomers = await standardiseMonomers(monomers);
+  const cappedSmilse = fixedMonomers.map((m, i) => ({sym: m.symbol, smiles: capSmiles(m.smiles ?? '', m.rgroups ?? []), original: m.smiles, source: monomers[i]?.lib?.source})).filter((s) => !!s?.smiles && !s.smiles.includes('[*:'));
+  // canonicalize all monomer smiles
+  const monomerSmilesCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'MonomerSmiles', cappedSmilse.map((m) => m.smiles!));
+  monomerSmilesCol.semType = DG.SEMTYPE.MOLECULE;
+  const canonicalizedMonomersSmilesCol: DG.Column = await converterFunc.apply({molecule: monomerSmilesCol, targetNotation: DG.chem.Notation.Smiles});
+  if (!canonicalizedMonomersSmilesCol || canonicalizedMonomersSmilesCol.length !== monomerSmilesCol.length)
+    throw new Error('Error canonicalizing monomer smiles');
+  canonicalizedMonomersSmilesCol.toList().forEach((s, i) => cappedSmilse[i].smiles = s);
+
+  const molecules = molDf.col(molColName)!;
+  const canonicalizedMoleculesCol: DG.Column = await converterFunc.apply({molecule: molecules, targetNotation: DG.chem.Notation.Smiles});
+  if (!canonicalizedMoleculesCol || canonicalizedMoleculesCol.length !== molecules.length)
+    throw new Error('Error canonicalizing molecules');
+
+  const canonicalizedMolecules = canonicalizedMoleculesCol.toList();
+
+  const resultDf = molDf.clone();
+  const matchingMonomerSmilesCol = resultDf.columns.addNewString(resultDf.columns.getUnusedName('Matched monomer smiles'));
+  matchingMonomerSmilesCol.semType = DG.SEMTYPE.MOLECULE;
+  const matchingMonomerSymbolCol = resultDf.columns.addNewString(resultDf.columns.getUnusedName('Matched monomer symbol'));
+  matchingMonomerSymbolCol.semType = 'Monomer';
+  const sourceLibCol = resultDf.columns.addNewString(resultDf.columns.getUnusedName('Matched monomer source'));
+  resultDf.columns.setOrder([molColName, matchingMonomerSymbolCol.name, matchingMonomerSmilesCol.name, sourceLibCol.name]);
+
+  for (let i = 0; i < canonicalizedMolecules.length; i++) {
+    const mol = canonicalizedMolecules[i];
+    if (!mol) continue;
+    for (let j = 0; j < cappedSmilse.length; j++) {
+      if (cappedSmilse[j].smiles === mol) {
+        matchingMonomerSmilesCol.set(i, cappedSmilse[j].original!, false);
+        matchingMonomerSymbolCol.set(i, cappedSmilse[j].sym, false);
+        sourceLibCol.set(i, cappedSmilse[j].source ?? '', false);
+        break;
+      }
+    }
+  }
+  return resultDf;
+}
+
 /** Standardizes the monomer library
  * warning: throws error if the library is not valid or has invalid monomers
  */
@@ -127,7 +174,7 @@ export function getMonomersDataFrame(monomers: Monomer[]) {
           monomers[i].id,
           JSON.stringify(monomers[i].meta ?? {}),
           monomers[i].lib?.source ?? '',
-        ]);
+        ], false);
         // something is wrong with setting dates, so setting it manually for now
         try {
           if (date)

package/src/utils/save-as-fasta.ts

@@ -15,23 +15,21 @@ const FASTA_LINE_WIDTH = 60;
 export function saveAsFastaUI(): void {
   // Use grid for column order adjusted by user
   const grid: DG.Grid = grok.shell.tv.grid;
+  const dataFrame: DG.DataFrame = grid.dataFrame;
 
-  const idGColList: DG.GridColumn[] = wu.count(0).take(grid.columns.length)
-    .map((colI: number) => grid.columns.byIndex(colI)!)
-    .filter((gcol: DG.GridColumn) => gcol.column ? gcol.column.semType !== DG.SEMTYPE.MACROMOLECULE : false).toArray();
-  const defaultIdGCol: DG.GridColumn | undefined = idGColList
-    .find((gcol: DG.GridColumn) => gcol.name.toLowerCase().indexOf('id') !== -1);
-  const idDefaultValue = defaultIdGCol ? [defaultIdGCol.name] : [];
+  const idGColList: DG.Column[] = wu.count(0).take(dataFrame.columns.length)
+    .map((colI: number) => dataFrame.columns.byIndex(colI)!)
+    .filter((col: DG.Column) => col.semType !== DG.SEMTYPE.MACROMOLECULE).toArray();
+  const defaultIdGCol: DG.Column | undefined = idGColList
+    .find((col: DG.Column) => col.name.toLowerCase().indexOf('id') !== -1);
+  const idDefaultValue = defaultIdGCol ? [defaultIdGCol] : [];
 
-  const idGColListInput = ui.input.multiChoice('Seq id columns', {
-    value: idDefaultValue,
-    items: idGColList.map((gcol: DG.GridColumn) => gcol.name)
-  });
+  const idGColListInput = ui.input.columns('Seq id columns', {table: dataFrame, value: idDefaultValue,
+    filter: (col: DG.Column) => col.semType !== DG.SEMTYPE.MACROMOLECULE});
 
-  const seqGColList: DG.GridColumn[] = wu.count(0).take(grid.columns.length)/* range rom 0 to grid.columns.length */
-    .map((colI: number) => grid.columns.byIndex(colI)!)
-    .filter((gc: DG.GridColumn) => {
-      const col: DG.Column | null = gc.column;
+  const seqGColList: DG.Column[] = wu.count(0).take(dataFrame.columns.length)/* range rom 0 to grid.columns.length */
+    .map((colI: number) => dataFrame.columns.byIndex(colI)!)
+    .filter((col: DG.Column) => {
       if (col && col.semType === DG.SEMTYPE.MACROMOLECULE) {
         const sh = _package.seqHelper.getSeqHandler(col);
         return sh.isFasta();
@@ -39,10 +37,17 @@ export function saveAsFastaUI(): void {
       return false;
     }).toArray();
 
-  const seqDefaultValue = seqGColList.length > 0 ? seqGColList[0].name : [];
-  const seqColInput = ui.input.choice('Seq column', {
-    value: seqDefaultValue,
-    items: seqGColList.map((gCol: DG.GridColumn) => gCol.name)
+  const seqDefaultValue = seqGColList.length > 0 ? seqGColList[0] : null;
+  const seqColInput = ui.input.column('Seq column', {
+    table: dataFrame,
+    value: seqDefaultValue!,
+    filter: (col) => {
+      if (col && col.semType === DG.SEMTYPE.MACROMOLECULE) {
+        const sh = _package.seqHelper.getSeqHandler(col);
+        return sh.isFasta();
+      }
+      return false;
+    }
   });
 
   const lineWidthInput = ui.input.int('FASTA line width', {value: FASTA_LINE_WIDTH});
@@ -54,10 +59,8 @@ export function saveAsFastaUI(): void {
       lineWidthInput,
     ]))
     .onOK(() => {
-      const valueIdColList: DG.Column[] = idGColListInput.value ?
-        idGColListInput.value.map((colName: string) => grid.columns.byName(colName)!.column!) : [];
-      const valueSeqCol: DG.Column | null = seqColInput.value ?
-        grid.columns.byName(seqColInput.value as string)!.column : null;
+      const valueIdColList: DG.Column[] = idGColListInput.value ?? [];
+      const valueSeqCol: DG.Column | null = seqColInput.value ?? null;
       const valueLineWidth = lineWidthInput.value ?? FASTA_LINE_WIDTH;
 
       if (!valueSeqCol)