@datagrok/bio 2.9.0 → 2.10.2

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

@@ -2,12 +2,14 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
-import {_package} from '../package-test';
+import wu from 'wu';
 import {category, test} from '@datagrok-libraries/utils/src/test';
 import {MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
 import {monomerToShort} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
+import {_package} from '../package-test';
+
 category('renderers: monomerPlacer', () => {
   const tests = {
     splitter: {
@@ -34,21 +36,27 @@ category('renderers: monomerPlacer', () => {
     },
     splitterMsa: {
       /** For charWidth=7 and sepWidth=12, MSA
-       * Array(10) [0, 26, 52, 78, 104, 130, 156, 175, 201, 227]
+       * Array(10) [5, 38, 71, 104, 137, 170, 203, 222, 255, 281]
        */
       csv: 'id,seq\n' +
-        'id1,m1-M-m3-mon4-mon5-N-T-MON8-N9\n' + //Array(10) [0, 26, 52, 78, 104, 130, 156, 175, 201, 227]
-        'id2,m1-mon2-m3-mon4-mon5-Num--MON8-N9\n' + //
-        'id3,mon1-M-mon3-mon4-mon5---MON8-N9\n', //
+        'id1,m1-M-m3-mon4-mon5-N-T-MON8-N9\n' +
+        'id2,m1-mon2-m3-mon4-mon5-Num--MON8-N9\n' +
+        'id3,\n' + // empty
+        'id4,mon1-M-mon3-mon4-mon5---MON8-N9\n',
       testList: [
         {src: {row: 0, x: -1}, tgt: {pos: null}},
         {src: {row: 1, x: 0}, tgt: {pos: null}},
         {src: {row: 1, x: 1}, tgt: {pos: null}},
-        {src: {row: 1, x: 26}, tgt: {pos: 0}},
+        {src: {row: 1, x: 4}, tgt: {pos: null}},
+        {src: {row: 1, x: 5}, tgt: {pos: 0}},
+        {src: {row: 1, x: 37}, tgt: {pos: 0}},
+        {src: {row: 1, x: 38}, tgt: {pos: 1}},
         {src: {row: 1, x: 170}, tgt: {pos: 4}},
         {src: {row: 1, x: 200}, tgt: {pos: 5}},
-        {src: {row: 2, x: 200}, tgt: {pos: 5}},
-        {src: {row: 2, x: 203}, tgt: {pos: 5}},
+        {src: {row: 2, x: 20}, tgt: {pos: null}}, // empty value
+        {src: {row: 3, x: 170}, tgt: {pos: 4}},
+        {src: {row: 3, x: 200}, tgt: {pos: 5}},
+        {src: {row: 3, x: 282}, tgt: {pos: null}},
       ]
     },
     fastaMsa: {
@@ -58,6 +66,7 @@ category('renderers: monomerPlacer', () => {
       csv: `id,seq
 id1,QQYNIYPLT
 id2,QQWSSFPYT
+id3,
 id3,QHIRE--LT
 `,
       testList: [
@@ -67,14 +76,15 @@ id3,QHIRE--LT
         {src: {row: 1, x: 19}, tgt: {pos: 0}},
         {src: {row: 1, x: 170}, tgt: {pos: 8}},
         {src: {row: 1, x: 171}, tgt: {pos: 8}},
-        {src: {row: 2, x: 170}, tgt: {pos: 8}},
-        {src: {row: 2, x: 181}, tgt: {pos: null}},
+        {src: {row: 2, x: 5}, tgt: {pos: null}}, // empty value
+        {src: {row: 3, x: 170}, tgt: {pos: 8}},
+        {src: {row: 3, x: 181}, tgt: {pos: null}},
       ]
     },
   };
 
   for (const [testName, testData] of Object.entries(tests)) {
-    test(`getPosition_${testName}`, async () => {
+    test(`getPosition-${testName}`, async () => {
       const df: DG.DataFrame = DG.DataFrame.fromCsv(testData.csv);
       await grok.data.detectSemanticTypes(df);
       const seqCol: DG.Column = df.getCol('seq');
@@ -94,9 +104,12 @@ id3,QHIRE--LT
       });
 
       const testList = testData.testList;
+      // simulate rendering
+      for (let rowI: number = 0; rowI < seqCol.length; ++rowI)
+        colTemp.getCellMonomerLengths(rowI);
 
       const errorList: string[] = [];
-      for (const test of testList) {
+      for (const [test, _testI] of wu.enumerate(testList)) {
         const res = {pos: colTemp.getPosition(test.src.row, test.src.x)};
         if (test.tgt.pos != res.pos) {
           errorList.push(`Test src ${JSON.stringify(test.src)} expected tgt ${JSON.stringify(test.tgt)},` +

package/src/tests/scoring.ts

@@ -26,13 +26,17 @@ category('Scoring', () => {
 
   test('Identity', async () => {
     const scoresCol = await sequenceIdentityScoring(table, seqCol, reference);
-    for (let i = 0; i < scoresCol.length; i++)
-      expectFloat(scoresCol.get(i)!, table.get(expectedIdentity, i), 0.01, `Wrong identity score for sequence at position ${i}`);
+    for (let i = 0; i < scoresCol.length; i++) {
+      expectFloat(scoresCol.get(i)!, table.get(expectedIdentity, i), 0.01,
+        `Wrong identity score for sequence at position ${i}`);
+    }
   });
 
   test('Similarity', async () => {
     const scoresCol = await sequenceSimilarityScoring(table, seqCol, reference);
-    for (let i = 0; i < scoresCol.length; i++)
-      expectFloat(scoresCol.get(i)!, table.get(expectedSimilarity, i), 0.01, `Wrong similarity score for sequence at position ${i}`);
+    for (let i = 0; i < scoresCol.length; i++) {
+      expectFloat(scoresCol.get(i)!, table.get(expectedSimilarity, i), 0.01,
+        `Wrong similarity score for sequence at position ${i}`);
+    }
   });
 });

package/src/tests/units-handler-get-region.ts

@@ -0,0 +1,116 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {ALPHABET, NOTATION, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+
+category('UnitsHandler: getRegion', () => {
+  const data: {
+    [testName: string]: {
+      srcCsv: string,
+      startIdx: number | null,
+      endIdx: number | null,
+      tgtCsv: string,
+      units: NOTATION,
+      alphabet: ALPHABET | null, /* alphabet is not applicable for units 'helm' */
+
+      positionNames?: { tag: string | null, start: string | null, end: string | null }
+    }
+  } = {
+    'fastaDna': {
+      srcCsv: `seq
+ATTCGT
+ACTGCTC
+ATTCCGTA`,
+      startIdx: 2,
+      endIdx: 4,
+      tgtCsv: `seq
+TCG
+TGC
+TCC`,
+      units: NOTATION.FASTA,
+      alphabet: ALPHABET.DNA,
+
+      positionNames: {tag: 'a, b, c, d, e, f, g, h', start: 'c', end: 'e'},
+    },
+    'separatorPt': {
+      srcCsv: `seq
+M-D-Y-K-E-T-L
+M-I-E-V-F-L-F-G-I
+M-M-`,
+      startIdx: 5,
+      endIdx: null,
+      tgtCsv: `seq
+T-L--
+L-F-G-I
+---`,
+      units: NOTATION.SEPARATOR,
+      alphabet: ALPHABET.PT,
+
+      positionNames: {tag: '1, 1A, 1B, 2, 3, 4, 4A, 4A, 4C', start: '4', end: null},
+    },
+    'helm': {
+      srcCsv: `seq
+PEPTIDE1{[meI].[hHis].[Aca].N.T.[dE].[Thr_PO3H2].[Aca].[D-Tyr_Et].[Tyr_ab-dehydroMe].[dV].E.N.[D-Orn]}$$$$
+PEPTIDE1{[meI].[hHis].[Aca].[Cys_SEt].T.[dK].[Thr_PO3H2].[Aca].[Tyr_PO3H2].[D-Chg].[dV].[Phe_ab-dehydro]}$$$$
+PEPTIDE1{[Lys_Boc].[hHis].[Aca].[Cys_SEt].T}$$$$`,
+      startIdx: 3,
+      endIdx: 6,
+      tgtCsv: `seq
+PEPTIDE1{N.T.[dE].[Thr_PO3H2]}$$$$
+PEPTIDE1{[Cys_SEt].T.[dK].[Thr_PO3H2]}$$$$
+PEPTIDE1{[Cys_SEt].T.*.*}$$$$`,
+      units: NOTATION.HELM,
+      alphabet: null,
+
+      positionNames: {tag: null, start: '4', end: '7'}
+    }
+  };
+
+  for (const [testName, testData] of Object.entries(data)) {
+    test(`${testName}-idx`, async () => {
+      const srcDf = DG.DataFrame.fromCsv(testData.srcCsv);
+      const srcSeqCol = srcDf.getCol('seq');
+
+      const semType: string | null = await grok.functions.call('Bio:detectMacromolecule', {col: srcSeqCol});
+      if (semType) srcSeqCol.semType = semType;
+
+      const srcUh = UnitsHandler.getOrCreate(srcSeqCol);
+      const resSeqCol = srcUh.getRegion(testData.startIdx, testData.endIdx, 'regSeq');
+
+      const tgtDf = DG.DataFrame.fromCsv(testData.tgtCsv);
+      const tgtSeqCol = tgtDf.getCol('seq');
+
+      expect(srcSeqCol.getTag(DG.TAGS.UNITS), testData.units);
+      expect(resSeqCol.getTag(DG.TAGS.UNITS), testData.units);
+      expect(srcSeqCol.getTag(TAGS.alphabet), testData.alphabet);
+      expect(resSeqCol.getTag(TAGS.alphabet), testData.alphabet);
+      expectArray(resSeqCol.toList(), tgtSeqCol.toList());
+    });
+
+    if (testData.positionNames) {
+      test(`${testName}-positionNames`, async () => {
+        const srcDf = DG.DataFrame.fromCsv(testData.srcCsv);
+        const srcSeqCol = srcDf.getCol('seq');
+        if (testData.positionNames!.tag)
+          srcSeqCol.setTag(TAGS.positionNames, testData.positionNames!.tag);
+
+        const semType: string | null = await grok.functions.call('Bio:detectMacromolecule', {col: srcSeqCol});
+        if (semType) srcSeqCol.semType = semType;
+
+        const resSeqCol = await grok.functions.call('Bio:getRegion',
+          {sequence: srcSeqCol, start: testData.positionNames!.start, end: testData.positionNames!.end});
+
+        const tgtDf = DG.DataFrame.fromCsv(testData.tgtCsv);
+        const tgtSeqCol = tgtDf.getCol('seq');
+
+        expect(srcSeqCol.getTag(DG.TAGS.UNITS), testData.units);
+        expect(resSeqCol.getTag(DG.TAGS.UNITS), testData.units);
+        expect(srcSeqCol.getTag(TAGS.alphabet), testData.alphabet);
+        expect(resSeqCol.getTag(TAGS.alphabet), testData.alphabet);
+        expectArray(resSeqCol.toList(), tgtSeqCol.toList());
+      });
+    }
+  }
+});

package/src/utils/cell-renderer.ts

@@ -143,8 +143,11 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     // Cell renderer settings
     const tempMonomerWidth: string | null = tableColTemp[tempTAGS.monomerWidth];
     const monomerWidth: string = (tempMonomerWidth != null) ? tempMonomerWidth : 'short';
-    if (monomerWidth === 'short')
-      maxLengthOfMonomer = tableColTemp[mmcrTemps.maxMonomerLength] ?? _package.properties.MaxMonomerLength;
+    if (monomerWidth === 'short') {
+      // Renderer can start to work before Bio package initialized, in that time _package.properties is null.
+      // TODO: Render function is available but package init method is not completed
+      maxLengthOfMonomer = tableColTemp[mmcrTemps.maxMonomerLength] ?? _package.properties?.MaxMonomerLength ?? 4;
+    }
 
 
     let seqColTemp: MonomerPlacer = tableCol.temp[tempTAGS.bioSeqCol];
@@ -206,36 +209,6 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
         ((tempReferenceSequence != null) && (tempReferenceSequence != '')) ?
           tempReferenceSequence : tempCurrentWord ?? '');
 
-      // let maxLengthWords: { [pos: number]: number } = {};
-      // if (tableCol.getTag(rndrTAGS.calculatedCellRender) !== splitLimit.toString()) {
-      //   let sampleCount = 0;
-      //   while (sampleCount < Math.min(tableCol.length, 100)) {
-      //     const rowIdx: number = sampleCount;
-      //     const column = tableCol.get(rowIdx);
-      //     const subParts: string[] = splitterFunc(column);
-      //     for (const [index, amino] of subParts.entries()) {
-      //       const textSize = monomerToShortFunction(amino, maxLengthOfMonomer).length * 7 + gapRenderer;
-      //       if (textSize > (maxLengthWords[index] ?? 0))
-      //         maxLengthWords[index] = textSize;
-      //       if (index > maxIndex) maxIndex = index;
-      //     }
-      //     sampleCount += 1;
-      //   }
-      //   const minLength = 3 * 7;
-      //   for (let i = 0; i <= maxIndex; i++) {
-      //     if (maxLengthWords[i] < minLength) maxLengthWords[i] = minLength;
-      //     const maxLengthWordSum: { [pos: number]: number } = {};
-      //     maxLengthWordSum[0] = maxLengthWords[0];
-      //     for (let i = 1; i <= maxIndex; i++) maxLengthWordSum[i] = maxLengthWordSum[i - 1] + maxLengthWords[i];
-      //     colTemp[tempTAGS.bioSumMaxLengthWords] = maxLengthWordSum;
-      //     colTemp[tempTAGS.bioMaxIndex] = maxIndex;
-      //     colTemp[tempTAGS.bioMaxLengthWords] = maxLengthWords;
-      //     tableCol.setTag(rndrTAGS.calculatedCellRender, splitLimit.toString());
-      //   }
-      // } else {
-      //   maxLengthWords = colTemp[tempTAGS.bioMaxLengthWords];
-      // }
-
       const subParts: ISeqSplitted = splitterFunc(value);
       /* let x1 = x; */
       let color = undefinedColor;

package/src/utils/context-menu.ts

@@ -4,7 +4,6 @@ import * as ui from 'datagrok-api/ui';
 
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {NotationConverter} from '@datagrok-libraries/bio/src/utils/notation-converter';
 
 import {_package} from '../package';
 
@@ -15,9 +14,9 @@ export function addCopyMenuUI(cell: DG.Cell, menu: DG.Menu): void {
 
   menu.group('Copy')
     .items(tgtNotationList, (tgtNotation) => {
-      const nc = new NotationConverter(cell.column);
+      const ncUH = UnitsHandler.getOrCreate(cell.column);
       const separator = tgtNotation === NOTATION.SEPARATOR ? _package.properties.DefaultSeparator : undefined;
-      const converter = nc.getConverter(tgtNotation as NOTATION, separator);
+      const converter = ncUH.getConverter(tgtNotation as NOTATION, separator);
       const tgtSeq = converter(cell.value);
 
       if (!navigator.clipboard) {

package/src/utils/convert.ts

@@ -5,7 +5,6 @@ import * as grok from 'datagrok-api/grok';
 import $ from 'cash-dom';
 import {Subscription} from 'rxjs';
 import {NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {NotationConverter} from '@datagrok-libraries/bio/src/utils/notation-converter';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {expect} from '@datagrok-libraries/utils/src/test';
 
@@ -22,8 +21,8 @@ export function convert(col?: DG.Column): void {
   let tgtCol = col ?? grok.shell.t.columns.bySemType('Macromolecule')!;
   if (!tgtCol)
     throw new Error('No column with Macromolecule semantic type found');
-  let converter = new NotationConverter(tgtCol);
-  let currentNotation: NOTATION = converter.notation;
+  let converterUH = UnitsHandler.getOrCreate(tgtCol);
+  let currentNotation: NOTATION = converterUH.notation;
   const dialogHeader = ui.divText(
     'Current notation: ' + currentNotation,
     {
@@ -47,8 +46,8 @@ export function convert(col?: DG.Column): void {
     }
 
     tgtCol = newCol;
-    converter = new NotationConverter(tgtCol);
-    currentNotation = converter.notation;
+    converterUH = UnitsHandler.getOrCreate(tgtCol);
+    currentNotation = converterUH.notation;
     if (currentNotation === NOTATION.HELM)
       separatorInput.value = '/'; // helm monomers can have - in the name like D-aThr;
     dialogHeader.textContent = 'Current notation: ' + currentNotation;
@@ -117,8 +116,8 @@ export function convert(col?: DG.Column): void {
  * @param {string | null} separator Separator for SEPARATOR notation
  */
 export async function convertDo(srcCol: DG.Column, targetNotation: NOTATION, separator?: string): Promise<DG.Column> {
-  const converter = new NotationConverter(srcCol);
-  const newColumn = converter.convert(targetNotation, separator);
+  const converterUH = UnitsHandler.getOrCreate(srcCol);
+  const newColumn = converterUH.convert(targetNotation, separator);
   srcCol.dataFrame.columns.add(newColumn);
 
   // Call detector directly to escape some error on detectSemanticTypes

package/src/utils/get-region-func-editor.ts

@@ -0,0 +1,261 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+
+export interface GetRegionParams {
+  table: DG.DataFrame,
+  sequence: DG.Column<string>,
+  start: string | null,
+  end: string | null,
+  /** Name for the column with sequence of the region  */ name: string | null,
+}
+
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {_package} from '../package';
+
+export interface SeqRegion {
+  name: string,
+  description: string,
+  start: string,
+  end: string,
+}
+
+export class GetRegionFuncEditor {
+  inputs = new class {
+    table: DG.InputBase<DG.DataFrame | null>;
+    sequence: DG.InputBase<DG.Column | null>;
+    region: DG.InputBase<SeqRegion>;
+    start: DG.InputBase<string>;
+    end: DG.InputBase<string>;
+    name: DG.InputBase<string>;
+  }();
+
+  constructor(
+    private readonly call: DG.FuncCall
+  ) {
+    const getDesc = (paramName: string) => this.call.inputParams[paramName].property.description;
+
+    this.inputs.table = ui.tableInput('Table',
+      this.call.inputParams['table'].value ?? grok.shell.tv.dataFrame, undefined,
+      () => {});
+
+    const seqColValue = this.call.inputParams['sequence'].value ??
+      this.inputs.table.value!.columns.bySemType(DG.SEMTYPE.MACROMOLECULE);
+    const seqColOptions = {filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE};
+    this.inputs.sequence = ui.columnInput('Sequence', grok.shell.tv.dataFrame, seqColValue,
+      this.sequenceInputChanged.bind(this), seqColOptions);
+    this.inputs.start = ui.choiceInput(
+      'Start', undefined, [], this.startInputChanged.bind(this)) as unknown as DG.InputBase<string>;
+    this.inputs.end = ui.choiceInput(
+      'End', undefined, [], this.endInputChanged.bind(this)) as unknown as DG.InputBase<string>;
+
+    this.inputs.region = ui.choiceInput<SeqRegion>('Region', null as unknown as SeqRegion, [],
+      this.regionInputChanged.bind(this)) as DG.InputBase<SeqRegion>;
+
+    this.inputs.name = ui.stringInput('Column name', this.getDefaultName(),
+      this.nameInputChanged.bind(this), {clearIcon: true});
+    this.inputs.name.onInput(this.nameInputInput.bind(this)); // To catch clear event
+
+    // tooltips
+    for (const paramName in this.call.inputParams) {
+      // @ts-ignore
+      ui.tooltip.bind(this.inputs[paramName].captionLabel, getDesc(paramName));
+    }
+
+    // initial
+    this.sequenceInputChanged();
+  }
+
+  private sequenceInputChanged(): void {
+    const seqCol = this.inputs.sequence.value;
+    const uh = seqCol ? UnitsHandler.getOrCreate(seqCol) : null;
+    this.updateRegionItems();
+    this.updateStartEndInputItems();
+    this.updateRegion(true);
+    this.updateNameInput();
+  }
+
+  private fixRegion: boolean = false;
+
+  private regionInputChanged(): void {
+    this.fixRegion = true;
+    try {
+      const regJsonStr = this.inputs.region.stringValue;
+      const reg: SeqRegion | null = regJsonStr ? JSON.parse(regJsonStr) as SeqRegion : null;
+
+      if (reg !== null) {
+        this.inputs.start.value = reg?.start;
+        this.inputs.end.value = reg?.end;
+      } else {
+        const uh = UnitsHandler.getOrCreate(this.inputs.sequence.value!);
+        this.inputs.start.value = uh.posList[0];
+        this.inputs.end.value = uh.posList[uh.posList.length - 1];
+      }
+    } finally {
+      this.fixRegion = false;
+    }
+  }
+
+  private startInputChanged(): void {
+    this.updateRegion(false);
+    this.updateNameInput();
+  }
+
+  private endInputChanged(): void {
+    this.updateRegion(false);
+    this.updateNameInput();
+  }
+
+  private nameInputChanged(): void {
+    if (!this.defaultNameUpdating)
+      this.defaultName = false;
+  }
+
+  private nameInputInput(): void {
+    if (!this.inputs.name.value) {
+      this.defaultName = true;
+      this.inputs.name.input.focus();
+    }
+  }
+
+  private updateStartEndInputItems(): void {
+    const seqCol = this.inputs.sequence.value;
+    const uh = seqCol ? UnitsHandler.getOrCreate(seqCol) : null;
+
+    const startSE = (this.inputs.start.input as HTMLSelectElement);
+    const endSE = (this.inputs.end.input as HTMLSelectElement);
+    for (let i = startSE.options.length - 1; i >= 0; --i) startSE.options.remove(i);
+    for (let i = endSE.options.length - 1; i >= 0; --i) endSE.options.remove(i);
+    for (const pos of uh?.posList ?? []) {
+      const startPosOE = document.createElement('option');
+      const endPosOE = document.createElement('option');
+      startPosOE.text = endPosOE.text = pos;
+      startPosOE.value = endPosOE.value = pos;
+      startSE.options.add(startPosOE);
+      endSE.options.add(endPosOE);
+    }
+    startSE.value = uh?.posList[0] ?? '';
+    endSE.value = uh?.posList[uh?.posList.length - 1] ?? '';
+  }
+
+  private updateRegionItems(): void {
+    const seqCol = this.inputs.sequence.value;
+    const regionsTagTxt: string | null = seqCol ? seqCol.getTag(bioTAGS.regions) : null;
+    const regionList: SeqRegion[] | null = regionsTagTxt ? JSON.parse(regionsTagTxt) : null;
+
+    const regionSE = (this.inputs.region.input as HTMLSelectElement);
+    for (let i = regionSE.options.length - 1; i >= 0; --i) regionSE.options.remove(i);
+
+    const nullOE = document.createElement('option');
+    nullOE.text = '';
+    nullOE.value = JSON.stringify(null);
+    regionSE.options.add(nullOE);
+
+    if (regionList != null) {
+      this.inputs.region.root.style.removeProperty('display');
+      for (const region of regionList) {
+        const regionOE = document.createElement('option');
+        regionOE.text = `${region.name}: ${region.start}-${region.end}`;
+        regionOE.value = JSON.stringify(region);
+        regionSE.options.add(regionOE);
+      }
+    } else {
+      this.inputs.region.root.style.display = 'none';
+    }
+  }
+
+  private updateRegion(reset: boolean): void {
+    const startPos: string = this.inputs.start.stringValue ?? '';
+    const endPos: string = this.inputs.end.stringValue ?? '';
+
+    if (!this.fixRegion) {
+      const regionSE = (this.inputs.region.input as HTMLSelectElement);
+      regionSE.selectedIndex = -1;
+      for (let i = regionSE.options.length - 1; i >= 0; --i) {
+        const regionOE = regionSE.options[i];
+        const reg: SeqRegion = JSON.parse(regionOE.value);
+        if (reg && startPos === reg.start && endPos === reg.end) regionSE.selectedIndex = i;
+      }
+    }
+  }
+
+  private defaultName: boolean = true;
+  private defaultNameUpdating: boolean = false;
+
+  private updateNameInput(): void {
+    this.defaultNameUpdating = true;
+    try {
+      if (this.defaultName) this.inputs.name.value = this.getDefaultName();
+    } finally {
+      this.defaultNameUpdating = false;
+    }
+  }
+
+  private getDefaultName(): string {
+    const regionJsonStr = this.inputs.region.stringValue;
+    const reg: SeqRegion | null = regionJsonStr ? JSON.parse(regionJsonStr) : null;
+
+    const seqCol: DG.Column<string> = this.inputs.sequence.value!;
+
+    const startPos: string = this.inputs.start.stringValue ?? '';
+    const endPos: string = this.inputs.end.stringValue ?? '';
+
+    return reg != null ? `${seqCol.name}(${reg.name}): ${reg.start}-${reg.end}` :
+      `${seqCol?.name}: (${startPos}-${endPos})`;
+  }
+
+  private getParams(): {} {
+    return {
+      table: this.inputs.table.value!,
+      sequence: this.inputs.sequence.value!,
+      start: this.getStart(),
+      end: this.getEnd(),
+      name: this.getName(),
+    };
+  }
+
+  private getStart(): string | null {
+    return this.inputs.start.stringValue;
+  }
+
+  private getEnd(): string | null {
+    return this.inputs.end.stringValue;
+  }
+
+  private getName(): string | null {
+    const str = this.inputs.name.stringValue;
+    return str == '' ? null : str;
+  }
+
+  // -- UI --
+
+  public dialog(): void {
+    const inputsForm = ui.inputs(Object.values(this.inputs), {style: {minWidth: '320px'}});
+    ui.dialog({title: 'Get Region'})
+      .add(inputsForm)
+      .onOK(async () => {
+        (async () => {
+          const callParams = this.getParams();
+          await this.call.func.prepare(callParams).call(true);
+        })()
+          .catch((err: any) => { _package.handleErrorUI(err); });
+      })
+      .show();
+  }
+
+  public widget(): DG.Widget {
+    const inputsForm = ui.inputs(Object.entries(this.inputs)
+      .filter(([inputName, input]) => !['table', 'sequence'].includes(inputName))
+      .map(([inputName, input]) => input));
+    const doBtn = ui.button('Get Region', () => {
+      (async () => {
+        const callParams = this.getParams();
+        await this.call.func.prepare(callParams).call(true);
+      })()
+        .catch((err: any) => { _package.handleErrorUI(err); });
+    });
+    return DG.Widget.fromRoot(ui.divV([inputsForm, ui.div(doBtn)]));
+  }
+}

package/src/utils/get-region.ts

@@ -0,0 +1,65 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {getRegion} from '../package';
+import {TaskBarProgressIndicator} from 'datagrok-api/dg';
+
+export function getRegionUI(col: DG.Column<string>): void {
+  const uh = UnitsHandler.getOrCreate(col);
+
+  const nameInput = ui.stringInput('Name', '');
+  const startPositionInput = ui.choiceInput('Start Position', uh.posList[0], uh.posList,
+    () => { /* TODO: update name placeholder with getDefaultName() */ });
+  const endPositionInput = ui.choiceInput('End Position', uh.posList[uh.posList.length], uh.posList,
+    () => { /* TODO: update name placeholder with getDefaultName() */ });
+
+  const getDefaultName = (): string => {
+    return `${col.name}:${startPositionInput.value}-${endPositionInput.value}`;
+  };
+
+  ui.dialog({title: 'Get Region'}).add(ui.inputs([
+    nameInput,
+    startPositionInput,
+    endPositionInput,
+  ])).onOK(() => {
+    const pi = TaskBarProgressIndicator.create('Getting region...');
+    try {
+      const name: string = nameInput.value ?? getDefaultName();
+      const regCol = getRegionDo(col, name, startPositionInput.value, endPositionInput.value);
+      col.dataFrame.columns.add(regCol);
+      regCol.setTag(DG.TAGS.CELL_RENDERER, 'sequence');
+    } catch (err: any) {
+      grok.shell.error(err.toString());
+    } finally { pi.close(); }
+  });
+}
+
+/** {@link startPosName} and {@link endPosName} are according positionNames tag (or default ['1', '2',...]) */
+export function getRegionDo(
+  col: DG.Column<string>, startPosName: string | null, endPosName: string | null, name: string | null
+): DG.Column<string> {
+  const uh = UnitsHandler.getOrCreate(col);
+
+  let startPosIdx: number | null = null;
+  let endPosIdx: number | null = null;
+
+  for (let posJ: number = 0; posJ < uh.posList.length; ++posJ) {
+    if (uh.posList[posJ] == startPosName) startPosIdx = posJ;
+    if (uh.posList[posJ] == endPosName) endPosIdx = posJ;
+  }
+  if (startPosIdx === null && startPosName !== null)
+    throw new Error(`Start position ${startPosName} not found.`);
+  if (endPosIdx === null && endPosName !== null)
+    throw new Error(`End position ${endPosName} not found.`);
+
+  if (uh.posList.length < endPosIdx!)
+    throw new Error(`End position ${endPosIdx} exceeds positions length`);
+
+  const regColName: string = !!name ? name : `${col.name}: (${startPosName ?? ''}-${endPosName ?? ''})`;
+
+  const regCol = uh.getRegion(startPosIdx, endPosIdx, regColName);
+  return regCol;
+}