@datagrok/bio 2.15.3 → 2.15.6

package/src/package.ts

@@ -4,8 +4,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {Options} from '@datagrok-libraries/utils/src/type-declarations';
-import {DimReductionBaseEditor, PreprocessFunctionReturnType}
-  from '@datagrok-libraries/ml/src/functionEditors/dimensionality-reduction-editor';
+import {DimReductionBaseEditor, PreprocessFunctionReturnType} from '@datagrok-libraries/ml/src/functionEditors/dimensionality-reduction-editor';
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {BitArrayMetrics, KnownMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
@@ -14,50 +13,38 @@ import {SeqHandler, SeqTemps} from '@datagrok-libraries/bio/src/utils/seq-handle
 import {IMonomerLib, IMonomerSet} from '@datagrok-libraries/bio/src/types';
 import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
 import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
-import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
-import {SCORE, calculateScores} from '@datagrok-libraries/bio/src/utils/macromolecule/scoring';
-import {
-  createJsonMonomerLibFromSdf, IMonomerLibHelper
-} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {SCORE} from '@datagrok-libraries/bio/src/utils/macromolecule/scoring';
+import {createJsonMonomerLibFromSdf, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {ActivityCliffsEditor} from '@datagrok-libraries/ml/src/functionEditors/activity-cliffs-function-editor';
 import BitArray from '@datagrok-libraries/utils/src/bit-array';
 import {BYPASS_LARGE_DATA_WARNING} from '@datagrok-libraries/ml/src/functionEditors/consts';
-import {
-  getEmbeddingColsNames, multiColReduceDimensionality
-} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/reduce-dimensionality';
+import {getEmbeddingColsNames, multiColReduceDimensionality} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/reduce-dimensionality';
 import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
-import {
-  ITSNEOptions, IUMAPOptions
-} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/multi-column-dim-reducer';
+import {ITSNEOptions, IUMAPOptions} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/multi-column-dim-reducer';
 import {generateLongSequence, generateLongSequence2} from '@datagrok-libraries/bio/src/utils/generator';
 import {getUserLibSettings, setUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
-import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import {getMacromoleculeColumns} from './utils/ui-utils';
-import {
-  MacromoleculeDifferenceCellRenderer, MacromoleculeSequenceCellRenderer,
-} from './utils/cell-renderer';
+import {MacromoleculeDifferenceCellRenderer, MacromoleculeSequenceCellRenderer,} from './utils/cell-renderer';
+import {MacromoleculeCustomCellRenderer} from './utils/cell-renderer-custom';
 import {VdRegionsViewer} from './viewers/vd-regions-viewer';
 import {SequenceAlignment} from './seq_align';
 import {getEncodedSeqSpaceCol} from './analysis/sequence-space';
-import {
-  createLinesGrid, createPropPanelElement, createTooltipElement,
-} from './analysis/sequence-activity-cliffs';
+import {createLinesGrid, createPropPanelElement, createTooltipElement,} from './analysis/sequence-activity-cliffs';
 import {SequenceSimilarityViewer} from './analysis/sequence-similarity-viewer';
 import {SequenceDiversityViewer} from './analysis/sequence-diversity-viewer';
-import {MONOMERIC_COL_TAGS, SubstructureSearchDialog, invalidateMols} from './substructure-search/substructure-search';
+import {invalidateMols, MONOMERIC_COL_TAGS, SubstructureSearchDialog} from './substructure-search/substructure-search';
 import {convert} from './utils/convert';
 import {getMacromoleculeColumnPropertyPanel} from './widgets/representations';
 import {saveAsFastaUI} from './utils/save-as-fasta';
 import {BioSubstructureFilter} from './widgets/bio-substructure-filter';
 import {WebLogoViewer} from './viewers/web-logo-viewer';
 import {MonomerLibManager} from './utils/monomer-lib/lib-manager';
-import {getMonomerLibraryManagerLink, showManageLibrariesDialog,
-  showManageLibrariesView} from './utils/monomer-lib/library-file-manager/ui';
+import {getMonomerLibraryManagerLink, showManageLibrariesDialog, showManageLibrariesView} from './utils/monomer-lib/library-file-manager/ui';
 import {demoBio01UI} from './demo/bio01-similarity-diversity';
 import {demoBio01aUI} from './demo/bio01a-hierarchical-clustering-and-sequence-space';
 import {demoBio01bUI} from './demo/bio01b-hierarchical-clustering-and-activity-cliffs';
@@ -115,8 +102,17 @@ export class SeqPaletteCustom implements SeqPalette {
 let monomerLib: IMonomerLib | null = null;
 let monomerSets: IMonomerSet | null = null;
 
+let initBioPromise: Promise<void> | null = null;
+
 //tags: init
-export async function initBio() {
+export async function initBio(): Promise<void> {
+  if (initBioPromise === null) {
+    initBioPromise = initBioInt();
+  }
+  await initBioPromise;
+}
+
+async function initBioInt() {
   const logPrefix = 'Bio: _package.initBio()';
   _package.logger.debug(`${logPrefix}, start`);
   let rdKitModule!: RDModule;
@@ -195,7 +191,7 @@ export function getBioLib(): IMonomerLib {
 }
 
 // For sync internal use, on initialized package
-export function getMonomerLib(): IMonomerLib | null {
+export function getMonomerLib(): IMonomerLib {
   return monomerLib!;
 }
 
@@ -326,6 +322,15 @@ export function SeqActivityCliffsEditor(call: DG.FuncCall) {
 
 // -- Cell renderers --
 
+//name: customSequenceCellRenderer
+//tags: cellRenderer
+//meta.cellType: sequence
+//meta.columnTags: quality=Macromolecule, units=custom
+//output: grid_cell_renderer result
+export function customSequenceCellRenderer(): DG.GridCellRenderer {
+  return new MacromoleculeCustomCellRenderer();
+}
+
 //name: fastaSequenceCellRenderer
 //tags: cellRenderer
 //meta.cellType: sequence
@@ -335,6 +340,15 @@ export function fastaSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
   return new MacromoleculeSequenceCellRenderer();
 }
 
+//name: separatorSequenceCellRenderer
+//tags: cellRenderer
+//meta.cellType: sequence
+//meta.columnTags: quality=Macromolecule, units=separator
+//output: grid_cell_renderer result
+export function separatorSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
+  return new MacromoleculeSequenceCellRenderer();
+}
+
 // -- Property panels --
 
 //name:  Bioinformatics | Sequence Renderer
@@ -353,15 +367,6 @@ export function compositionAnalysisWidget(sequence: DG.SemanticValue): DG.Widget
   return getCompositionAnalysisWidget(sequence);
 }
 
-//name: separatorSequenceCellRenderer
-//tags: cellRenderer
-//meta.cellType: sequence
-//meta.columnTags: quality=Macromolecule, units=separator
-//output: grid_cell_renderer result
-export function separatorSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
-  return new MacromoleculeSequenceCellRenderer();
-}
-
 //name: MacromoleculeDifferenceCellRenderer
 //tags: cellRenderer
 //meta.cellType: MacromoleculeDifference
@@ -621,13 +626,17 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, molecules: DG.Co
 //description: Converts sequences to molblocks
 //input: dataframe table [Input data table]
 //input: column seqCol {caption: Sequence; semType: Macromolecule}
-//input: bool nonlinear =false {caption: Non linear; description: Slower mode for cycling/branching HELM structures}
+//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 }
 //output:
-export async function toAtomicLevel(table: DG.DataFrame, seqCol: DG.Column, nonlinear: boolean): Promise<void> {
+export async function toAtomicLevel(
+  table: DG.DataFrame, seqCol: DG.Column, nonlinear: boolean, highlight: boolean = false
+): Promise<void> {
   const pi = DG.TaskBarProgressIndicator.create('Converting to atomic level ...');
   try {
+    await initBioPromise;
     const monomerLib = (await getMonomerLibHelper()).getMonomerLib();
-    await sequenceToMolfile(table, seqCol, nonlinear, monomerLib);
+    await sequenceToMolfile(table, seqCol, nonlinear, highlight, monomerLib, _package.rdKitModule);
   } finally {
     pi.close();
   }
@@ -751,6 +760,31 @@ export function convertDialog() {
   convert(col);
 }
 
+//top-menu: Bio | Convert | TestConvert
+//name: convertSeqNotation
+//description: RDKit-based conversion for SMILES, SMARTS, InChi, Molfile V2000 and Molfile V3000
+//input: string sequence {semType: Macromolecule}
+//input: string targetNotation
+//input: string separator
+//output: string result
+export async function convertSeqNotation(sequence: string, targetNotation: NOTATION, separator?: string): Promise<string | undefined | null> {
+  try {
+    const col = DG.Column.fromStrings('sequence', [sequence]);
+    const df = DG.DataFrame.fromColumns([col]);
+    const semType = await grok.functions.call('Bio:detectMacromolecule', {col: col});
+    if (semType)
+      col.semType = semType;
+    const converterSh = SeqHandler.forColumn(col);
+    const newColumn = converterSh.convert(targetNotation, separator);
+    return newColumn.get(0);
+  } catch (err: any) {
+    const [errMsg, errStack] = errInfo(err);
+    _package.logger.error(errMsg, undefined, errStack);
+    throw err;
+  }
+}
+
+
 //name: monomerCellRenderer
 //tags: cellRenderer
 //meta.cellType: Monomer
@@ -1098,6 +1132,76 @@ export async function sdfToJsonLib(table: DG.DataFrame) {
 
 // -- Utils --
 
+//name: seq2atomic
+//friendlyName: seq2atomic
+//description: Converts a `Macromolecule` sequence to its atomic level `Molecule` representation
+//input: string seq { semType: Macromolecule }
+//input: bool nonlinear
+//output: string molfile { semType: Molecule }
+//meta.role: converter
+export async function seq2atomic(seq: string, nonlinear: boolean): Promise<string | undefined> {
+  if (!(seq.trim())) return '';
+  try {
+    const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, `helm`, [seq]);
+    const df = DG.DataFrame.fromColumns([seqCol]);
+    const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+    if (semType) seqCol.semType = semType;
+
+    const monomerLib = (await getMonomerLibHelper()).getMonomerLib();
+    const res = (await sequenceToMolfile(df, seqCol, nonlinear, false, monomerLib, _package.rdKitModule))?.molCol?.get(0);
+    return res ?? undefined;
+  } catch (err: any) {
+    const [errMsg, errStack] = errInfo(err);
+    _package.logger.error(errMsg, undefined, errStack);
+    throw err;
+  }
+}
+
+// //description: Gets similarity to a reference sequence
+// //input: string seq { semType: Macromolecule }
+// //input: string ref { semType: Macromolecule }
+// //output: double result
+// export async function seqSimilarity(seq: string, ref: string): Promise<number> {
+//   // if (!(seq.trim())) return null;
+//   try {
+//     const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, `seq`, [seq]);
+//     const df = DG.DataFrame.fromColumns([seqCol]);
+//     const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+//     if (semType) seqCol.semType = semType;
+//
+//     const resCol = await calculateScoresWithEmptyValues(df, seqCol, ref, SCORE.SIMILARITY);
+//     return resCol.get(0)!;
+//   } catch (err: any) {
+//     const [errMsg, errStack] = errInfo(err);
+//     _package.logger.error(errMsg, undefined, errStack);
+//     throw err;
+//   }
+// }
+
+//name: seqIdentity
+//friendlyName: seqIdentity
+//description: Gets identity to a reference sequence
+//input: string seq { semType: Macromolecule }
+//input: string ref { semType: Macromolecule }
+//output: double result
+export async function seqIdentity(seq: string, ref: string): Promise<number | null> {
+  if (!(seq.trim())) return null;
+  try {
+    const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, `seq`, [seq]);
+    const df = DG.DataFrame.fromColumns([seqCol]);
+    const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+    if (!semType) throw new Error('Macromolecule required');
+
+    const resCol = await calculateScoresWithEmptyValues(df, seqCol, ref, SCORE.IDENTITY);
+    return resCol.get(0);
+  } catch (err: any) {
+    const [errMsg, errStack] = errInfo(err);
+    _package.logger.error(errMsg, undefined, errStack);
+    throw err;
+  }
+}
+
+
 //name: detectMacromoleculeProbe
 //input: file file
 //input: string colName = ''
@@ -1121,7 +1225,7 @@ export async function getSeqHelper(): Promise<ISeqHelper> {
 export function getMolFromHelm(
   df: DG.DataFrame, helmCol: DG.Column<string>, chiralityEngine: boolean
 ): Promise<DG.Column<string>> {
-  return getMolColumnFromHelm(df, helmCol, chiralityEngine);
+  return getMolColumnFromHelm(df, helmCol, chiralityEngine, getMonomerLib());
 }
 
 // -- Custom notation providers --
@@ -1130,6 +1234,7 @@ export function getMolFromHelm(
 //input: column col
 //input: string separator
 export function applyNotationProviderForCyclized(col: DG.Column<string>, separator: string) {
+  col.meta.units = NOTATION.CUSTOM;
   col.temp[SeqTemps.notationProvider] = new CyclizedNotationProvider(separator);
 }
 
@@ -1137,5 +1242,13 @@ export function applyNotationProviderForCyclized(col: DG.Column<string>, separat
 //input: column col
 //input: string separator
 export function applyNotationProviderForDimerized(col: DG.Column<string>, separator: string) {
+  col.meta.units = NOTATION.CUSTOM;
   col.temp[SeqTemps.notationProvider] = new DimerizedNotationProvider(separator);
 }
+
+//name: test1
+//output: object result
+export function test1(): any {
+  _package.logger.debug('Bio:test1() function');
+  return {value: 'value1'};
+}

package/src/tests/WebLogo-positions-test.ts

@@ -4,7 +4,6 @@ import * as DG from 'datagrok-api/dg';
 import {category, expect, expectArray, test, testEvent} from '@datagrok-libraries/utils/src/test';
 import {ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
-import {GAP_SYMBOL} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 
 import {
   countForMonomerAtPosition,
@@ -12,6 +11,7 @@ import {
   PositionMonomerInfo as PMI,
   WebLogoViewer,
 } from '../viewers/web-logo-viewer';
+import {GAP_SYMBOL} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
 const g: string = GAP_SYMBOL;
 

package/src/tests/activity-cliffs-tests.ts

@@ -10,7 +10,7 @@ import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule
 import {BitArrayMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
-  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
@@ -32,8 +32,7 @@ category('activityCliffs', async () => {
     userLibSettings = await getUserLibSettings();
 
     // Test 'helm' requires default monomer library loaded
-    await setUserLibSettingsForTests();
-    await monomerLibHelper.loadMonomerLib(true); // load default libraries
+    await monomerLibHelper.loadMonomerLibForTests();
   });
 
   after(async () => {

package/src/tests/bio-tests.ts

@@ -10,7 +10,7 @@ import {Nucleotides, NucleotidesPalettes} from '@datagrok-libraries/bio/src/nucl
 import {AminoacidsPalettes} from '@datagrok-libraries/bio/src/aminoacids';
 import {UnknownSeqPalette} from '@datagrok-libraries/bio/src/unknown';
 import {getStatsForCol} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
-import {GAP_SYMBOL} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+import {GAP_SYMBOL} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
 /** GAP_SYMBOL */
 const g: string = GAP_SYMBOL;

package/src/tests/detectors-custom-notation-tests.ts

@@ -0,0 +1,37 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {category, test} from '@datagrok-libraries/utils/src/test';
+import {ALIGNMENT, ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+
+import {_testNeg, _testPos, DetectorTestData, DfReaderFunc, PosCol} from './utils/detectors-utils';
+
+category('detectors: custom', () => {
+  const tests: DetectorTestData = {
+    'cyclized1': {
+      csv: `n,seq
+1,R-F-C(1)-T-G-H-F-Y-G-H-F-Y-G-H-F-Y-P-C(1)-meI
+2,C(1)-T-G-H-F-Y-P-C(1)-meI
+3,R-F-C(1)-T-G-H-F-Y-P-C(1)
+4,C(1)-T-G-H-F-H-P-C(1)
+5,R-F-D(2)-T-G-H-F-Y-P-NH2(2)
+6,R-F-aG(3)-T-G-H-F-Y-P-azG(3)-meI`,
+      pos: {'seq': new PosCol(NOTATION.CUSTOM, ALIGNMENT.SEQ, ALPHABET.UN, 13, true, '-')}
+    },
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}`, async () => {
+      const reader: DfReaderFunc = async (): Promise<DG.DataFrame> => {
+        return DG.DataFrame.fromCsv(testData.csv);
+      };
+      for (const negColName of testData.neg ?? [])
+        await _testNeg(reader, negColName);
+      for (const [posColName, posCol] of Object.entries(testData.pos ?? {})) {
+        await _testPos(reader, posColName, posCol.units, posCol.aligned,
+          posCol.alphabet, posCol.alphabetSize, posCol.alphabetIsMultichar, posCol.separator);
+      }
+    });
+  }
+});

package/src/tests/detectors-tests.ts

@@ -4,10 +4,12 @@ import * as DG from 'datagrok-api/dg';
 
 import {category, test, expect} from '@datagrok-libraries/utils/src/test';
 
-import {importFasta} from '../package';
 import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
+import {_testNeg, _testPos, DetectorTestData, DfReaderFunc, PosCol} from './utils/detectors-utils';
+import {importFasta} from '../package';
+
 /*
 // snippet to list df columns of semType='Macromolecule' (false positive)
 const df = grok.shell.tableByName('SPGI');
@@ -19,20 +21,6 @@ for (let i = 0; i < df.columns.length; i++) {
 }
  */
 
-type DfReaderFunc = () => Promise<DG.DataFrame>;
-
-
-class PosCol {
-  constructor(
-    public readonly units: string,
-    public readonly aligned: string | null,
-    public readonly alphabet: string | null,
-    public readonly alphabetSize: number,
-    public readonly alphabetIsMultichar?: boolean,
-    public readonly separator?: string,
-  ) { };
-}
-
 category('detectors', () => {
   const enum csvTests {
     fastaDna1 = 'csvFastaDna1',
@@ -57,7 +45,7 @@ category('detectors', () => {
     helmSameLength = 'helmSameLength',
   }
 
-  const csvData2: { [testName: string]: { csv: string, neg?: string[], pos?: { [colName: string]: PosCol } } } = {
+  const csvData2: DetectorTestData = {
     'negEmpty': {
       csv: `id,col1
 1,
@@ -147,16 +135,16 @@ YN[Re]VYNR[Ac]WYV
     },
     'sepSameLength': {
       csv: `seq
-Ac(1)-A-A-A-A-A-A-A-A-A-A-A-A-A-C(1)-G-NH2
-Ac(1)-A-A-A-A-A-A-A-A-A-A-A-A-A-C(1)-G-NH2
-Ac(1)-A-A-A-A-A-A-A-A-A-A-A-A-A-C(1)-G-NH2`,
+Aca-A-A-A-A-A-A-A-A-A-A-A-A-A-C-G-NH2
+Aca-A-A-A-A-A-A-A-A-A-A-A-A-A-C-G-NH2
+Aca-A-A-A-A-A-A-A-A-A-A-A-A-A-C-G-NH2`,
       pos: {'seq': new PosCol(NOTATION.SEPARATOR, ALIGNMENT.SEQ_MSA, ALPHABET.UN, 5, true, '-')}
     },
     'sepMsaSameLength': {
       csv: `seq
-Ac(1)-A-A-A-A-A-A-A-A-A-A-A-A-A-C(1)-G-NH2
-Ac(1)-A-A(2)-A-A-A-C(2)-A-A-A-A-C(1)-G-NH2
-Ac(1)-A-A-A-A-A-A-A-A-A-A-A-A-A-C(1)-G-NH2`,
+Aca-A-A-A-A-A-A-A-A-A-A-A-A-A-Aca-G-NH2
+Aca-A-Aca-A-A-A-meI-A-A-A-A-A-Aca-G-NH2
+Aca-A-A-A-A-A-A-A-A-A-A-A-A-A-Aca-G-NH2`,
       pos: {'seq': new PosCol(NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.UN, 5, true, '-')}
     },
     'helmSameLength': {
@@ -166,6 +154,12 @@ PEPTIDE1{Ab(1).Y.V.K.H.P.F.W.R.W.Y.A.A.A.C(1).G.NH2}$$$$
 PEPTIDE1{Ad(1).S.W.Y.C.K.H.P.M.W.A.A.A.A.C(1)-G-NH2}$$$$`,
       pos: {'seq': new PosCol(NOTATION.HELM, null, null, 19, undefined, undefined)}
     },
+    'fastaNonDigitAlphabet': {
+      csv: `flagC
+"NMe-pyridazineH"
+"Pyrrolo[2,3-c]pyridazineH"`,
+      neg: ['flagC']
+    }
   };
 
   const readCsv2: (key: keyof typeof csvData2) => DfReaderFunc = (key: keyof typeof csvData2) => {
@@ -237,9 +231,9 @@ m1-mon2-m3-mon4-mon5-Num--MON8-N9-m1-mon2-m3-mon4-mon5-Num--MON8-N9
 
 mon1-M-mon3-mon4-mon5---MON8-N9-mon1-M-mon3-mon4-mon5---MON8-N9`;
     [csvTests.sepComplex]: string = `seq
-Ac(1)-F-K(AEEA-AEEA-R-Ac)-L-mF-V-Y-mNle-D-W-N-mF-C(1)-G-NH2
-Ac(1)-F-K(AEEA-ARRA-W-Ac)-L-mF-V-Y-mNle-D-W-N-mF-C(1)-G-NH2
-Ac(1)-F-K(AEEA-AEEA-Ac)-L-mF-V-Y-mNle-D-W-N-mF-C(1)-G-NH2`;
+Aca-F-K(AEEA-AEEA-R-Ac)-L-mF-V-Y-mNle-D-W-N-mF-Aca-G-NH2
+Aca-F-K(AEEA-ARRA-W-Ac)-L-mF-V-Y-mNle-D-W-N-mF-Aca-G-NH2
+Aca-F-K(AEEA-AEEA-Ac)-L-mF-V-Y-mNle-D-W-N-mF-Aca-G-NH2`;
     [csvTests.fastaMsaDna1]: string = `seq
 AC-GT-CTAC-GT-CT
 CAC-T-GTCAC-T-GT
@@ -406,7 +400,7 @@ MWRSWY-CKHPMWRSWY-CKHP`;
 
   test('SepComplex', async () => {
     await _testPos(readCsv(csvTests.sepComplex), 'seq',
-      NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.UN, 18, true);
+      NOTATION.SEPARATOR, ALIGNMENT.SEQ, ALPHABET.UN, 17, true);
   });
 
   test('samplesFastaCsv', async () => {
@@ -517,20 +511,6 @@ export async function _testNegList(list: string[]): Promise<void> {
   }
 }
 
-export async function _testNeg(readDf: DfReaderFunc, colName: string) {
-  const df: DG.DataFrame = await readDf();
-  const col: DG.Column = df.getCol(colName)!;
-  const semType: string = await grok.functions
-    .call('Bio:detectMacromolecule', {col: col}) as unknown as string;
-  if (semType)
-    col.semType = semType;
-
-  if (col.semType === DG.SEMTYPE.MACROMOLECULE) {
-    const msg = `Negative test detected semType='${col.semType}', units='${col.meta.units}'.`;
-    throw new Error(msg);
-  }
-}
-
 export async function _testPosList(list: string[], units: NOTATION,
   aligned: ALIGNMENT, alphabet: ALPHABET, alphabetSize: number, alphabetIsMultichar: boolean,
   separator: string | null = null
@@ -556,35 +536,6 @@ export async function _testPosList(list: string[], units: NOTATION,
   }
 }
 
-export async function _testPos(
-  readDf: DfReaderFunc, colName: string, units: string, aligned: string | null,
-  alphabet: string | null, alphabetSize: number, alphabetIsMultichar?: boolean,
-  separator: string | null = null,
-) {
-  const df: DG.DataFrame = await readDf();
-  const col: DG.Column = df.col(colName)!;
-  const semType: string = await grok.functions
-    .call('Bio:detectMacromolecule', {col: col}) as unknown as string;
-  if (semType)
-    col.semType = semType;
-
-  expect(col.semType, DG.SEMTYPE.MACROMOLECULE);
-  expect(col.meta.units, units);
-  expect(col.getTag(bioTAGS.aligned), aligned);
-  expect(col.getTag(bioTAGS.alphabet), alphabet);
-  if (separator)
-    expect(col.getTag(bioTAGS.separator), separator);
-
-  const sh = SeqHandler.forColumn(col);
-  expect(sh.getAlphabetSize(), alphabetSize);
-  expect(sh.getAlphabetIsMultichar(), alphabetIsMultichar);
-  if (!sh.isHelm()) {
-    expect(sh.aligned, aligned);
-    expect(sh.alphabet, alphabet);
-  }
-}
-
-
 export async function _testDf(readDf: DfReaderFunc, posCols: { [colName: string]: PosCol }): Promise<void> {
   const df: DG.DataFrame = await readDf();
   const errList: string[] = [];

package/src/tests/detectors-weak-and-likely-tests.ts

@@ -4,8 +4,8 @@ import * as DG from 'datagrok-api/dg';
 
 import {category, test} from '@datagrok-libraries/utils/src/test';
 import {ALIGNMENT, ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {_testNeg, _testPos} from './detectors-tests';
-import {DfReaderFunc} from './types';
+
+import {_testNeg, _testPos, DfReaderFunc} from './utils/detectors-utils';
 
 
 category('detectors:weak-and-likely', () => {

package/src/tests/monomer-libraries-tests.ts

@@ -2,12 +2,16 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
-import {test, after, before, category, expect} from '@datagrok-libraries/utils/src/test';
+import {test, after, before, category, expect, expectObject} from '@datagrok-libraries/utils/src/test';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
-  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {expectMonomerLib} from '@datagrok-libraries/bio/src/tests/monomer-lib-tests';
+import {MonomerTypes, PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {Monomer} from '@datagrok-libraries/bio/src/types/index';
+
+import {monomerLibForTestsSummary} from '../utils/monomer-lib/consts';
 
 
 category('monomerLibraries', () => {
@@ -27,7 +31,7 @@ category('monomerLibraries', () => {
   test('default', async () => {
     // Clear settings to test default
     await setUserLibSettings({exclude: [], explicit: [], duplicateMonomerPreferences: {}});
-    await monomerLibHelper.loadLibraries(true); // test defaultLib
+    await monomerLibHelper.loadMonomerLib(true); // test defaultLib
 
     // Currently default monomer lib set is of all files at LIB_PATH (at least HELMCoreLibrary.json)
     const currentMonomerLib = monomerLibHelper.getMonomerLib();
@@ -35,13 +39,12 @@ category('monomerLibraries', () => {
   });
 
   test('forTests', async () => {
-    await setUserLibSettingsForTests();
-    await monomerLibHelper.loadMonomerLib(true); // test defaultLib
+    await monomerLibHelper.loadMonomerLibForTests(); // test defaultLib
 
     // Currently default monomer lib set is of all files at LIB_PATH (at least HELMCoreLibrary.json)
     const currentMonomerLib = monomerLibHelper.getMonomerLib();
     // HELMCoreLibrary.json checks
-    expectMonomerLib(currentMonomerLib);
+    expectMonomerLib(currentMonomerLib, monomerLibForTestsSummary);
   });
 
   test('empty', async () => {
@@ -62,4 +65,26 @@ category('monomerLibraries', () => {
     const polymerTypes = currentMonomerLib.getPolymerTypes();
     expect(polymerTypes.length === 0, true);
   });
+
+  test('override', async () => {
+    const overMon: Monomer = {
+      symbol: 'over1',
+      name: 'Test override monomer 1',
+      molfile: '',
+      author: 'Test Author',
+      id: 0,
+      rgroups: [],
+      smiles: '',
+      polymerType: PolymerTypes.PEPTIDE,
+      monomerType: MonomerTypes.BACKBONE,
+      createDate: null,
+    };
+    const monomerLib = monomerLibHelper.getMonomerLib();
+    const absentOverrideMonomer = monomerLib.getMonomer(overMon.polymerType, overMon.symbol);
+    expect(absentOverrideMonomer === null, true, `Unexpectedly found monomer '${overMon.symbol}' `);
+
+    const overriddenMonomerLib = monomerLib.override({[overMon.polymerType]: {[overMon.symbol]: overMon}});
+    const resOverMon = overriddenMonomerLib.getMonomer(overMon.polymerType, overMon.symbol);
+    expectObject(resOverMon as any, overMon);
+  });
 });

package/src/tests/pepsea-tests.ts

@@ -63,5 +63,5 @@ category('PepSeA', () => {
       logger.error(errMsg, undefined, errStack);
     }
     expect(logger.errorList[0].message, pepseaErrorError);
-  },{skipReason: 'GROK-16699'});
+  });
 });

package/src/tests/renderers-monomer-placer-tests.ts

@@ -10,7 +10,7 @@ import {monomerToShort} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
-  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
@@ -24,9 +24,7 @@ category('renderers: monomerPlacer', () => {
     libHelper = await getMonomerLibHelper();
     libSettings = await getUserLibSettings();
 
-    await setUserLibSettingsForTests();
-    await libHelper.awaitLoaded();
-    await libHelper.loadMonomerLib(true);
+    await libHelper.loadMonomerLibForTests();
   });
 
   after(async () => {