@datagrok/bio 2.11.37 → 2.11.39

package/dockerfiles/Dockerfile

@@ -55,11 +55,62 @@ def distout():\n\
     if distout_output is None:\n\
         raise FileNotFoundError("distance matrix is not found")\n\
 \n\
-    return distout_output\n' >> /opt/PepSeA-main/alignment/api.py;
+    return distout_output\n\
+\n\
+from fastapi import Request, HTTPException\n\
+import sys\n\
+import ujson as json\n\
+from io import StringIO\n\
+from subprocess import CalledProcessError\n\
+\n\
+@api.middleware("http")\n\
+async def error_to_json_middleware(request: Request, call_next):\n\
+    sys.stderr = temp_stderr = StringIO()\n\
+    response = None\n\
+    try:\n\
+        response = await call_next(request)\n\
+    finally:\n\
+        sys.stderr = sys.__stderr__\n\
+        stderr_msg = temp_stderr.getvalue()\n\
+        if len(stderr_msg) > 0 and response and response.headers["content-type"] == "application/json":\n\
+            response_body = [chunk async for chunk in response.body_iterator]\n\
+            response_str = "".join(((s.decode() if isinstance(s, bytes) else str(s)) for s in response_body))\n\
+            response_obj = json.loads(response_str)\n\
+            response_obj.update({"pepsea-stderr": stderr_msg})\n\
+            headers = {}\n\
+            for header_name in response.headers:\n\
+                if header_name != "content-length" and header_name != "content-type":\n\
+                    headers[header_name] = response.headers[header_name]\n\
+            json_response = JSONResponse(status_code=response.status_code, headers=headers, content=response_obj)\n\
+            return json_response\n\
+    return response\n\
+\n\
+\n\
+def pepsea_json_response(err_msg: str):\n\
+    return JSONResponse(status_code=500, content={\n\
+        "pepsea-error": err_msg,\n\
+    })\n\
+\n\
+\n\
+@api.exception_handler(CalledProcessError)\n\
+async def called_process_error_handler(request: Request, ex: CalledProcessError):\n\
+    s = ex.stderr\n\
+    err_msg = s.decode() if isinstance(s, bytes) else str(ex.stderr)\n\
+    sys.__stderr__.write("called_process_error_handler() {0}: {1}\\n".format(type(ex).__name__, err_msg))\n\
+    return pepsea_json_response(err_msg)\n\
+\n\
+\n\
+@api.exception_handler(Exception)\n\
+async def base_exception_handler(request: Request, ex: Exception):\n\
+    err_msg = str(ex)\n\
+    sys.__stderr__.write("base_exception_handler() {0}: {1}\\n".format(type(ex).__name__, err_msg))\n\
+    return pepsea_json_response(err_msg)\n\
+\n' >> /opt/PepSeA-main/alignment/api.py;
 
 # It is important to run docker container as user and not as root
 USER grok:grok
 
+
 # Command source does not work for Docker, cause it will apply only to one layer
 # The PATH works better for Docker
 ARG VIRTUAL_ENV=${HOME_DIR}/venv

package/files/tests/100_3_clustests.csv

@@ -97,4 +97,4 @@ cluster,sequence_id,sequence,activity,is_cliff
 2,c2_seq1052,NQYRREPRGCRSPVWK,-0.18,False
 2,c2_seq1053,GMGWYQHFIDCMPVME, 0.39,False
 2,c2_seq1054,HHEDYSSHGDRHPVAE, 0.34,False
-2,c2_seq1055,WFYIRFWNGCMWPVDH, 0.63,False
+2,c2_seq1055,WFYIRFWNGCMWPVDH, 0.63,False

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.11.37",
+  "version": "2.11.39",
   "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",
@@ -34,7 +34,7 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "5.39.26",
+    "@datagrok-libraries/bio": "5.39.29",
     "@datagrok-libraries/chem-meta": "^1.2.1",
     "@datagrok-libraries/ml": "^6.4.10",
     "@datagrok-libraries/tutorials": "^1.3.11",

package/src/demo/bio01-similarity-diversity.ts

@@ -8,7 +8,7 @@ import {handleError} from './utils';
 import {SequenceDiversityViewer} from '../analysis/sequence-diversity-viewer';
 import {SequenceSimilarityViewer} from '../analysis/sequence-similarity-viewer';
 
-const dataFn: string = 'data/sample_FASTA_PT_activity.csv';
+const dataFn: string = 'samples/FASTA_PT_activity.csv';
 
 export async function demoBio01UI() {
   let view: DG.TableView;

package/src/demo/bio01a-hierarchical-clustering-and-sequence-space.ts

@@ -9,7 +9,7 @@ import {demoSequenceSpace, handleError} from './utils';
 import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
 import {getClusterMatrixWorker} from '@datagrok-libraries/math';
 
-const dataFn = 'data/sample_FASTA_PT_activity.csv';
+const dataFn = 'samples/FASTA_PT_activity.csv';
 const seqColName = 'sequence';
 
 export async function demoBio01aUI() {

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

@@ -14,7 +14,7 @@ import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule
 import {getClusterMatrixWorker} from '@datagrok-libraries/math';
 import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
 
-const dataFn: string = 'data/sample_FASTA_PT_activity.csv';
+const dataFn: string = 'samples/FASTA_PT_activity.csv';
 
 export async function demoBio01bUI() {
   let treeHelper: ITreeHelper;

package/src/package.ts

@@ -912,7 +912,7 @@ export async function webLogoAggApp(): Promise<void> {
   try {
     const urlParams = new URLSearchParams(window.location.search);
     const app = new WebLogoApp(urlParams, 'webLogoAggApp');
-    const df: DG.DataFrame = await _package.files.readCsv('data/sample_FASTA_PT_activity.csv');
+    const df: DG.DataFrame = await _package.files.readCsv('samples/FASTA_PT_activity.csv');
     await grok.data.detectSemanticTypes(df);
     await app.init(df);
   } finally {
@@ -937,7 +937,7 @@ export async function getRegionHelmApp(): Promise<void> {
   const pi = DG.TaskBarProgressIndicator.create('getRegion ...');
   try {
     const urlParams = new URLSearchParams(window.location.search);
-    const df = await _package.files.readCsv('data/sample_HELM_empty_vals.csv');
+    const df = await _package.files.readCsv('samples/HELM_empty_vals.csv');
     const app = new GetRegionApp(urlParams, 'getRegionHelmApp');
     await app.init({df: df, colName: 'HELM'});
   } finally {

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

@@ -72,7 +72,7 @@ category('activityCliffs', async () => {
   });
 
   test('Helm', async () => {
-    const df = await _package.files.readCsv('data/sample_HELM_50.csv');
+    const df = await _package.files.readCsv('samples/HELM_50.csv');
     const _view = grok.shell.addTableView(df);
 
     await _testActivityCliffsOpen(df, DimReductionMethods.UMAP,

package/src/tests/detectors-tests.ts

@@ -155,8 +155,8 @@ MWRSWY-CKHPMWRSWY-CKHP`;
   }
 
   const samples: { [key: string]: string } = {
-    [Samples.fastaFasta]: 'System:AppData/Bio/data/sample_FASTA.fasta',
-    [Samples.fastaPtCsv]: 'System:AppData/Bio/data/sample_FASTA_PT.csv',
+    [Samples.fastaFasta]: 'System:AppData/Bio/samples/FASTA.fasta',
+    [Samples.fastaPtCsv]: 'System:AppData/Bio/samples/FASTA_PT.csv',
     [Samples.msaComplex]: 'System:AppData/Bio/samples/MSA.csv',
     [Samples.fastaCsv]: 'System:AppData/Bio/samples/FASTA.csv',
     [Samples.helmCsv]: 'System:AppData/Bio/samples/HELM.csv',

package/src/tests/msa-tests.ts

@@ -6,7 +6,7 @@ import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src
 import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {runKalign} from '../utils/multiple-sequence-alignment';
 import {multipleSequenceAlignmentUI} from '../utils/multiple-sequence-alignment-ui';
-import {awaitContainerStart} from './utils';
+import {awaitContainerStart} from '../utils/docker';
 
 category('MSA', async () => {
   //table = await grok.data.files.openTable('Demo:Files/bio/peptides.csv');

package/src/tests/pepsea-tests.ts

@@ -1,27 +1,67 @@
 import * as DG from 'datagrok-api/dg';
 
-import {before, category, expect, test} from '@datagrok-libraries/utils/src/test';
+import {before, category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
 import {runPepsea} from '../utils/pepsea';
-import {awaitContainerStart} from './utils';
+import {TestLogger} from './utils/test-logger';
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+import {awaitContainerStart} from '../utils/docker';
 
 category('PepSeA', () => {
   const testCsv = `HELM,MSA
-  "PEPTIDE1{F.L.R.G.W.[MeF].Y.S.N.N.C}$$$$","F.L.R.G.W.MeF.Y..S.N.N.C"
-  "PEPTIDE1{F.L.R.G.Y.[MeF].Y.W.N.C}$$$$","F.L.R.G.Y.MeF.Y.W...N.C"
-  "PEPTIDE1{F.G.Y.[MeF].Y.W.S.D.N.C}$$$$","F...G.Y.MeF.Y.W.S.D.N.C"
-  "PEPTIDE1{F.L.R.G.Y.[MeF].Y.W.S.N.D.C}$$$$","F.L.R.G.Y.MeF.Y.W.S.N.D.C"
-  "PEPTIDE1{F.V.R.G.Y.[MeF].Y.W.S.N.C}$$$$","F.V.R.G.Y.MeF.Y.W.S..N.C"`;
+"PEPTIDE1{F.L.R.G.W.[MeF].Y.S.N.N.C}$$$$","F.L.R.G.W.MeF.Y..S.N.N.C"
+"PEPTIDE1{F.L.R.G.Y.[MeF].Y.W.N.C}$$$$","F.L.R.G.Y.MeF.Y.W...N.C"
+"PEPTIDE1{F.G.Y.[MeF].Y.W.S.D.N.C}$$$$","F...G.Y.MeF.Y.W.S.D.N.C"
+"PEPTIDE1{F.L.R.G.Y.[MeF].Y.W.S.N.D.C}$$$$","F.L.R.G.Y.MeF.Y.W.S.N.D.C"
+"PEPTIDE1{F.V.R.G.Y.[MeF].Y.W.S.N.C}$$$$","F.V.R.G.Y.MeF.Y.W.S..N.C"
+`;
+
+  const pepseaStderrCsv: string = `HELM,MSA
+"PEPTIDE1{F.L.Mis.G.W.[MeF].Y.S.N.N.C}$$$$","F.L.Mis.G.W.MeF.Y..S.N.N.C"
+"PEPTIDE1{F.L.Mis.G.Y.[MeF].Y.W.N.C}$$$$","F.L.Mis.G.Y.MeF.Y...W.N.C"
+"PEPTIDE1{F.G.Y.[MeF].Y.W.S.D.N.C}$$$$","F...G.Y.MeF.Y.W.S.D.N.C"
+`;
+  const pepseaStderrWarningList: string = 'Mis not found in Monomer Map\nMeF not found in Monomer Map\n';
+
+  const pepseaErrorCsv: string = `HELM
+"PEPTIDE1{[NH2].*.A.Q.T.T.Y.K.N.Y.R.R.N.L.L.*.[COOH]}$$$$"
+"PEPTIDE1{[NH2].M.A.N.T.T.Y.K.N.Y.R.N.N.L.L.*.[COOH]}$$$$"
+"PEPTIDE1{[NH2].*.A.N.T.T.Y.K.C.Y.R.R.N.L.L.*.[COOH]}$$$$"
+"PEPTIDE1{[NH2].*.A.N.T.T.Y.K.F.Y.R.R.N.L.L.*.[COOH]}$$$$"
+`;
+  const pepseaErrorError: string = 'PepSeA error: The pair (*,M) couldn\'t be found in the substitution matrix';
 
   before(async () => {
     await awaitContainerStart();
   });
 
   test('Basic alignment', async () => {
-    const table = DG.DataFrame.fromCsv(testCsv);
-    const alignedCol = await runPepsea(table.getCol('HELM'), 'msa(HELM)');
-    expect(alignedCol !== null, true, 'PepSeA container has not started');
-    const alignedTestCol = table.getCol('MSA');
-    for (let i = 0; i < alignedCol!.length; ++i)
-      expect(alignedCol!.get(i) == alignedTestCol.get(i), true);
+    const df = DG.DataFrame.fromCsv(testCsv);
+    const resMsaCol = await runPepsea(df.getCol('HELM'), 'msa(HELM)');
+    const tgtMsaCol = df.getCol('MSA');
+    for (let i = 0; i < resMsaCol!.length; ++i)
+      expect(resMsaCol!.get(i) == tgtMsaCol.get(i), true);
+  }, {timeout: 60000 /* docker */});
+
+  test('stderr', async () => {
+    const logger = new TestLogger();
+    const df = DG.DataFrame.fromCsv(pepseaStderrCsv);
+    const resMsaCol = await runPepsea(df.getCol('HELM'), 'msa(HELM)',
+      undefined, undefined, undefined, undefined, logger);
+    const tgtMsaCol = df.getCol('MSA');
+    expectArray(resMsaCol!.toList(), tgtMsaCol.toList());
+    expect(logger.warningList[0].message, pepseaStderrWarningList);
   }, {timeout: 60000 /* docker */});
+
+  test('error', async () => {
+    const logger = new TestLogger();
+    try {
+      const df = DG.DataFrame.fromCsv(pepseaErrorCsv);
+      const _resMsaCol = await runPepsea(df.getCol('HELM'), 'msa(HELM)',
+        undefined, undefined, undefined, undefined, logger);
+    } catch (err: any) {
+      const [errMsg, errStack] = errInfo(err);
+      logger.error(errMsg, undefined, errStack);
+    }
+    expect(logger.errorList[0].message, pepseaErrorError);
+  });
 });

package/src/tests/renderers-test.ts

@@ -71,7 +71,7 @@ category('renderers', () => {
   }
 
   async function _rendererMacromoleculeSeparator() {
-    const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/data/sample_SEPARATOR_PT.csv');
+    const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/SEPARATOR_PT.csv');
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
 
     const seqCol = df.getCol('sequence');
@@ -113,7 +113,7 @@ category('renderers', () => {
   }
 
   async function _testAfterMsa() {
-    const fastaTxt: string = await grok.dapi.files.readAsText('System:AppData/Bio/data/sample_FASTA.fasta');
+    const fastaTxt: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/FASTA.fasta');
     const df: DG.DataFrame = importFasta(fastaTxt)[0];
 
     const srcSeqCol: DG.Column = df.getCol('sequence');
@@ -153,7 +153,7 @@ category('renderers', () => {
   }
 
   async function _testAfterConvert() {
-    const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/data/sample_FASTA_PT.csv');
+    const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/FASTA_PT.csv');
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
 
     const srcCol: DG.Column = df.col('sequence')!;

package/src/tests/utils/test-logger.ts

@@ -0,0 +1,29 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
+
+
+export class TestLogger implements ILogger {
+  errorList: { message: any, params?: object, stackTrace?: string }[] = [];
+  warningList: { message: string, params?: object }[] = [];
+  infoList: { message: string, params?: object }[] = [];
+  debugList: { message: string, params?: object }[] = [];
+
+  error(message: any, params?: object, stackTrace?: string): void {
+    this.errorList.push({message, params, stackTrace});
+  }
+
+  warning(message: string, params?: object): void {
+    this.warningList.push({message, params});
+  }
+
+  info(message: string, params?: object): void {
+    this.infoList.push({message, params});
+  }
+
+  debug(message: string, params?: object): void {
+    this.debugList.push({message, params});
+  }
+}

package/src/tests/utils.ts

@@ -34,14 +34,6 @@ export function _testTableIsNotEmpty(table: DG.DataFrame): void {
   expect(table.columns.length > 0 && table.rowCount > 0, true);
 }
 
-/** Waits if container is not started
- * @param {number} ms - time to wait in milliseconds */
-export async function awaitContainerStart(ms: number = 30000): Promise<void> {
-  const dc = await grok.dapi.docker.dockerContainers.filter('bio').first();
-  const dcId = dc.id;
-  await startDockerContainer(dcId, ms);
-}
-
 export async function awaitGrid(grid: DG.Grid, timeout: number = 5000): Promise<void> {
   await delay(0);
   await testEvent(grid.onAfterDrawContent, () => {},

package/src/tests/viewers.ts

@@ -10,7 +10,7 @@ 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('data/sample_FASTA_DNA.csv');
+      const df = await readDataframe('samples/FASTA_DNA.csv');
       await testViewer(v, df, {detectSemanticTypes: true});
     }, {
       skipReason: {

package/src/utils/docker.ts

@@ -1,36 +1,52 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
+
 import {delay} from '@datagrok-libraries/utils/src/test';
 
-export async function startDockerContainer(dcId: string, timeout: number = 30000): Promise<void> {
-  // TODO: Use the new dockerContainers API
-  const res = await grok.dapi.docker.dockerContainers.run(dcId /*, true */);
+import {Pepsea} from './pepsea';
+
+/** Waits if container is not started
+ * @param {number} ms - time to wait in milliseconds */
+export async function awaitContainerStart(ms: number = 60000): Promise<void> {
+  const dc = await Pepsea.getDockerContainer();
+  await startDockerContainer(dc, ms);
+}
+
+export async function startDockerContainer(argDc: DG.DockerContainer, timeout: number = 60000): Promise<void> {
+  // argDc contains current container status
+  let dc: DG.DockerContainer | null = argDc;
   let end: boolean = false;
   for (let i = 0; i < timeout / 200; ++i) {
-    const dc = await grok.dapi.docker.dockerContainers.find(dcId);
+    if (dc === null) dc = await grok.dapi.docker.dockerContainers.find(argDc.id);
+
+    if (isStarted(dc)) {
+      end = true;
+      break;
+    }
+
     switch (dc.status) {
-      case 'stopped': {
-        await grok.dapi.docker.dockerContainers.run(dcId);
-        break;
-      }
-      case 'pending change':
-      case 'changing': {
-        // skip to wait
-        break;
-      }
-      case 'checking':
-      case 'started': {
-        end = true;
-        break;
-      }
-      case 'error': {
-        throw new Error('Docker container error state.');
-      }
+    case 'stopped': {
+      // TODO: Use the new dockerContainers API
+      await grok.dapi.docker.dockerContainers.run(dc.id);
+      break;
+    }
+    case 'pending change':
+    case 'changing': {
+      // skip to wait
+      break;
+    }
+    case 'error': {
+      throw new Error('Docker container error state.');
     }
-    if (end) break;
+    }
+    dc = null;
     await delay(200);
   }
-  if (!end) throw new Error('Docker container run timeout.');
+  if (!end) throw new Error('Docker container start timeout.');
   // this.dc = await grok.dapi.docker.dockerContainers.find(dcId);
 }
+
+export function isStarted(dc: DG.DockerContainer): boolean {
+  return dc.status === 'checking' || dc.status === 'started';
+}

package/src/utils/multiple-sequence-alignment-ui.ts

@@ -11,6 +11,7 @@ import {pepseaMethods, runPepsea} from './pepsea';
 import {checkInputColumnUI} from './check-input-column';
 import {multipleSequenceAlginmentUIOptions} from './types';
 import {kalignVersion, msaDefaultOptions} from './constants';
+import {awaitContainerStart} from './docker';
 
 import {_package} from '../package';
 
@@ -58,6 +59,10 @@ export async function multipleSequenceAlignmentUI(
     const msaParamsDiv = ui.inputs([gapOpenInput, gapExtendInput, terminalGapInput]);
     const msaParamsButton = ui.button('Alignment parameters', () => {
       msaParamsDiv.hidden = !msaParamsDiv.hidden;
+      [gapOpenInput, gapExtendInput, terminalGapInput].forEach((input) => {
+        input.root.style.removeProperty('max-width');
+        input.captionLabel.style.removeProperty('max-width');
+      });
     }, 'Adjust alignment parameters such as penalties for opening and extending gaps');
     msaParamsButton.classList.add('msa-params-button');
     msaParamsDiv.hidden = true;
@@ -68,7 +73,7 @@ export async function multipleSequenceAlignmentUI(
     let performAlignment: (() => Promise<DG.Column<string> | null>) | undefined;
 
     //TODO: remove when the new version of datagrok-api is available
-    //TODO: allow only macromolecule colums to be chosen
+    //TODO: allow only macromolecule columns to be chosen
     const colInput = ui.columnInput('Sequence', table, seqCol, async () => {
         performAlignment = await onColInputChange(
           colInput.value, table, pepseaInputRootStyles, kalignInputRootStyles,
@@ -166,8 +171,11 @@ async function onColInputChange(
       gapOpenInput.value ??= msaDefaultOptions.pepsea.gapOpen;
       gapExtendInput.value ??= msaDefaultOptions.pepsea.gapExtend;
 
-      return async () => await runPepsea(col, unusedName, methodInput.value!,
-        gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value);
+      return async () => {
+        await awaitContainerStart();
+        return runPepsea(col, unusedName, methodInput.value!,
+          gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value);
+      };
     } else if (checkInputColumnUI(col, col.name, [NOTATION.SEPARATOR], [ALPHABET.UN], false)) {
       //if the column is separator with unknown alphabet, it might be helm. check if it can be converted to helm
       const potentialColUH = UnitsHandler.getOrCreate(col);
@@ -177,8 +185,11 @@ async function onColInputChange(
       gapExtendInput.value ??= msaDefaultOptions.pepsea.gapExtend;
       // convert to helm and assign alignment function to PepSea
 
-      return async () => await runPepsea(helmCol, unusedName, methodInput.value!,
-        gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value);
+      return async () => {
+        await awaitContainerStart();
+        return runPepsea(helmCol, unusedName, methodInput.value!,
+          gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value);
+      };
     } else {
       gapOpenInput.value = null;
       gapExtendInput.value = null;

package/src/utils/pepsea.ts

@@ -6,6 +6,7 @@ import {Subject} from 'rxjs';
 
 import {testEvent} from '@datagrok-libraries/utils/src/test';
 import {NOTATION, TAGS as bioTAGS, ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
 
 import * as C from './constants';
 
@@ -38,17 +39,15 @@ type PepseaBodyUnit = { ID: string, HELM: string };
  * @param {number} gapOpen - The gap open penalty.
  * @param {number} gapExtend - The gap extension penalty.
  * @param {DG.Column} clustersCol - The column containing the clusters of the sequences.
+ * @param logger {ILogger} Logger
  */
 export async function runPepsea(srcCol: DG.Column<string>, unUsedName: string,
   method: typeof pepseaMethods[number] = 'ginsi', gapOpen: number = 1.53, gapExtend: number = 0.0,
-  clustersCol: DG.Column<string | number> | null = null,
-): Promise<DG.Column<string> | null> {
+  clustersCol: DG.Column<string | number> | null = null, logger?: ILogger
+): Promise<DG.Column<string>> {
   const pepseaContainer = await Pepsea.getDockerContainer();
-  if (pepseaContainer.status !== 'started' && pepseaContainer.status !== 'checking') {
-    grok.log.warning('PepSeA container has not started yet');
-    return null;
-  }
-
+  if (pepseaContainer.status !== 'started' && pepseaContainer.status !== 'checking')
+    throw new Error('PepSeA container has not started yet');
 
   const peptideCount = srcCol.length;
   clustersCol ??= DG.Column.int('Clusters', peptideCount).init(0);
@@ -72,7 +71,7 @@ export async function runPepsea(srcCol: DG.Column<string>, unUsedName: string,
 
   const alignedSequences: string[] = new Array(peptideCount);
   for (const body of bodies) { // getting aligned sequences for each cluster
-    const alignedObject = await requestAlignedObjects(pepseaContainer.id, body, method, gapOpen, gapExtend);
+    const alignedObject = await requestAlignedObjects(pepseaContainer.id, body, method, gapOpen, gapExtend, logger);
     const alignments = alignedObject.Alignment;
 
     for (const alignment of alignments) { // filling alignedSequencesCol
@@ -94,14 +93,62 @@ export async function runPepsea(srcCol: DG.Column<string>, unUsedName: string,
   return alignedSequencesCol;
 }
 
-async function requestAlignedObjects(dockerfileId: string, body: PepseaBodyUnit[], method: string, gapOpen: number,
-  gapExtend: number): Promise<PepseaResponse> {
+async function requestAlignedObjects(
+  dockerfileId: string, body: PepseaBodyUnit[], method: string, gapOpen: number, gapExtend: number, logger?: ILogger
+): Promise<PepseaResponse> {
   const params = {
     method: 'POST',
     headers: {'Accept': 'application/json', 'Content-Type': 'application/json'},
     body: JSON.stringify(body),
   };
   const path = `/align?method=${method}&gap_open=${gapOpen}&gap_extend=${gapExtend}`;
-  const response = await grok.dapi.docker.dockerContainers.request(dockerfileId, path, params);
-  return JSON.parse(response ?? '{}');
+  let responseObj: any;
+  if ('fetchProxy' in grok.dapi.docker.dockerContainers) {
+    // new dockerContainers API
+    const t1: number = window.performance.now();
+    // @ts-ignore
+    const response: Response = await grok.dapi.docker.dockerContainers.fetchProxy(dockerfileId, path, params);
+    const t2: number = window.performance.now();
+    _package.logger.debug(`Bio: requestAlignedObjects() dockerContainers.fetchProxy(), ET: ${(t2 - t1)} ms`);
+    const responseContentType = response.headers.get('content-type');
+    const isJson: boolean = responseContentType === 'application/json';
+    if (!response.ok && isJson) {
+      const responseJson = await response.json();
+      const pepseaErrorMsg = responseJson['pepsea-error'];
+      if (!!pepseaErrorMsg)
+        throw new Error(`PepSeA error: ${pepseaErrorMsg}`);
+
+      const datagrokErrorMsg = responseJson['datagrok-error'];
+      if (!!datagrokErrorMsg)
+        throw new Error(`Datagrok error: ${datagrokErrorMsg}`);
+
+      throw new Error(response.statusText);
+    } else if (!response.ok && !isJson) {
+      const responseStr = await response.text();
+      throw new Error(`Error: ${responseStr}`);
+    } else if (!isJson) {
+      const responseStr = await response.text();
+      throw new Error(`Error: PepSeA expected JSON response, got '${responseStr}'.`);
+    }
+    responseObj = await response.json();
+  } else {
+    const responseStr = await grok.dapi.docker.dockerContainers.request(dockerfileId, path, params)!;
+    if (!responseStr)
+      throw new Error('Empty response');
+    responseObj = JSON.parse(responseStr);
+
+    const pepseaErrorMsg = responseObj['pepsea-error'];
+    if (!!pepseaErrorMsg)
+      throw new Error(`PepSeA error: ${pepseaErrorMsg}`);
+
+    const datagrokErrorMsg = responseObj['datagrok-error'];
+    if (!!datagrokErrorMsg)
+      throw new Error(`Datagrok error: ${datagrokErrorMsg}`);
+  }
+  // Check for pepsea stderr output
+  if ('pepsea-stderr' in responseObj) {
+    const pepseaStdErr: string = responseObj['pepsea-stderr'] as string;
+    logger?.warning(pepseaStdErr);
+  }
+  return responseObj as PepseaResponse;
 }