From 26b8adaec473d2ce9f37be0b5b6caebfc2978fac Mon Sep 17 00:00:00 2001
From: David Sehnal <david.sehnal@gmail.com>
Date: Tue, 21 Apr 2020 02:43:09 +0200
Subject: [PATCH] extensions/cellpack: use plugin.runTask instead of Task.run
---
src/extensions/cellpack/model.ts | 63 ++++++++++++++++----------------
src/extensions/cellpack/state.ts | 2 +-
src/extensions/cellpack/util.ts | 35 +++++++++---------
3 files changed, 51 insertions(+), 49 deletions(-)
diff --git a/src/extensions/cellpack/model.ts b/src/extensions/cellpack/model.ts
index 3736ba627..372b18d10 100644
--- a/src/extensions/cellpack/model.ts
+++ b/src/extensions/cellpack/model.ts
@@ -26,70 +26,71 @@ import { mmCIF_Schema } from '../../mol-io/reader/cif/schema/mmcif';
import { Column } from '../../mol-data/db';
import { createModels } from '../../mol-model-formats/structure/basic/parser';
import { CellpackPackingPreset, CellpackMembranePreset } from './preset';
-import { Asset, AssetManager } from '../../mol-util/assets';
+import { Asset } from '../../mol-util/assets';
function getCellPackModelUrl(fileName: string, baseUrl: string) {
return `${baseUrl}/results/${fileName}`;
}
-async function getModel(assetManager: AssetManager, id: string, ingredient: Ingredient, baseUrl: string, file?: Asset.File) {
+async function getModel(plugin: PluginContext, id: string, ingredient: Ingredient, baseUrl: string, file?: Asset.File) {
+ const assetManager = plugin.managers.asset;
const model_id = (ingredient.source.model) ? parseInt(ingredient.source.model) : 0;
const surface = (ingredient.ingtype) ? (ingredient.ingtype === 'transmembrane') : false;
let model: Model;
let assets: Asset.Wrapper[] = [];
if (file) {
if (file.name.endsWith('.cif')) {
- const text = await assetManager.resolve(file, 'string').run();
+ const text = await plugin.runTask(assetManager.resolve(file, 'string'));
assets.push(text);
- const cif = (await parseCif(text.data)).blocks[0];
- model = (await trajectoryFromMmCIF(cif).run())[model_id];
+ const cif = (await parseCif(plugin, text.data)).blocks[0];
+ model = (await plugin.runTask(trajectoryFromMmCIF(cif)))[model_id];
} else if (file.name.endsWith('.bcif')) {
- const binary = await assetManager.resolve(file, 'binary').run();
+ const binary = await plugin.runTask(assetManager.resolve(file, 'binary'));
assets.push(binary);
- const cif = (await parseCif(binary.data)).blocks[0];
- model = (await trajectoryFromMmCIF(cif).run())[model_id];
+ const cif = (await parseCif(plugin, binary.data)).blocks[0];
+ model = (await plugin.runTask(trajectoryFromMmCIF(cif)))[model_id];
} else if (file.name.endsWith('.pdb')) {
- const text = await assetManager.resolve(file, 'string').run();
+ const text = await plugin.runTask(assetManager.resolve(file, 'string'));
assets.push(text);
- const pdb = await parsePDBfile(text.data, id);
- model = (await trajectoryFromPDB(pdb).run())[model_id];
+ const pdb = await parsePDBfile(plugin, text.data, id);
+ model = (await plugin.runTask(trajectoryFromPDB(pdb)))[model_id];
} else {
throw new Error(`unsupported file type '${file.name}'`);
}
} else if (id.match(/^[1-9][a-zA-Z0-9]{3,3}$/i)) {
if (surface){
- const data = await getFromOPM(id, assetManager);
+ const data = await getFromOPM(plugin, id, assetManager);
if (data.asset){
assets.push(data.asset);
- model = (await trajectoryFromPDB(data.pdb).run())[model_id];
+ model = (await plugin.runTask(trajectoryFromPDB(data.pdb)))[model_id];
} else {
- const { mmcif, asset } = await getFromPdb(id, assetManager);
+ const { mmcif, asset } = await getFromPdb(plugin, id, assetManager);
assets.push(asset);
- model = (await trajectoryFromMmCIF(mmcif).run())[model_id];
+ model = (await plugin.runTask(trajectoryFromMmCIF(mmcif)))[model_id];
}
} else {
- const { mmcif, asset } = await getFromPdb(id, assetManager);
+ const { mmcif, asset } = await getFromPdb(plugin, id, assetManager);
assets.push(asset);
- model = (await trajectoryFromMmCIF(mmcif).run())[model_id];
+ model = (await plugin.runTask(trajectoryFromMmCIF(mmcif)))[model_id];
}
} else {
- const data = await getFromCellPackDB(id, baseUrl, assetManager);
+ const data = await getFromCellPackDB(plugin, id, baseUrl, assetManager);
assets.push(data.asset);
if ('pdb' in data) {
- model = (await trajectoryFromPDB(data.pdb).run())[model_id];
+ model = (await plugin.runTask(trajectoryFromPDB(data.pdb)))[model_id];
} else {
- model = (await trajectoryFromMmCIF(data.mmcif).run())[model_id];
+ model = (await plugin.runTask(trajectoryFromMmCIF(data.mmcif)))[model_id];
}
}
return { model, assets };
}
-async function getStructure(model: Model, source: IngredientSource, props: { assembly?: string } = {}) {
+async function getStructure(plugin: PluginContext, model: Model, source: IngredientSource, props: { assembly?: string } = {}) {
let structure = Structure.ofModel(model);
const { assembly } = props;
if (assembly) {
- structure = await StructureSymmetry.buildAssembly(structure, assembly).run();
+ structure = await plugin.runTask(StructureSymmetry.buildAssembly(structure, assembly));
}
let query;
if (source.selection){
@@ -274,7 +275,7 @@ function getCifCurve(name: string, transforms: Mat4[], model: Model) {
};
}
-async function getCurve(name: string, ingredient: Ingredient, transforms: Mat4[], model: Model) {
+async function getCurve(plugin: PluginContext, name: string, ingredient: Ingredient, transforms: Mat4[], model: Model) {
const cif = getCifCurve(name, transforms, model);
const curveModelTask = Task.create('Curve Model', async ctx => {
@@ -283,11 +284,11 @@ async function getCurve(name: string, ingredient: Ingredient, transforms: Mat4[]
return models[0];
});
- const curveModel = await curveModelTask.run();
- return getStructure(curveModel, ingredient.source);
+ const curveModel = await plugin.runTask(curveModelTask);
+ return getStructure(plugin, curveModel, ingredient.source);
}
-async function getIngredientStructure(assetManager: AssetManager, ingredient: Ingredient, baseUrl: string, ingredientFiles: IngredientFiles) {
+async function getIngredientStructure(plugin: PluginContext, ingredient: Ingredient, baseUrl: string, ingredientFiles: IngredientFiles) {
const { name, source, results, nbCurve } = ingredient;
if (source.pdb === 'None') return;
@@ -302,12 +303,12 @@ async function getIngredientStructure(assetManager: AssetManager, ingredient: In
}
// model id in case structure is NMR
- const { model, assets } = await getModel(assetManager, source.pdb || name, ingredient, baseUrl, file);
+ const { model, assets } = await getModel(plugin, source.pdb || name, ingredient, baseUrl, file);
if (!model) return;
let structure: Structure;
if (nbCurve) {
- structure = await getCurve(name, ingredient, getCurveTransforms(ingredient), model);
+ structure = await getCurve(plugin, name, ingredient, getCurveTransforms(ingredient), model);
} else {
let bu: string|undefined = source.bu ? source.bu : undefined;
if (bu){
@@ -317,7 +318,7 @@ async function getIngredientStructure(assetManager: AssetManager, ingredient: In
bu = bu.slice(2);
}
}
- structure = await getStructure(model, source, { assembly: bu });
+ structure = await getStructure(plugin, model, source, { assembly: bu });
// transform with offset and pcp
let legacy: boolean = true;
if (ingredient.offset || ingredient.principalAxis){
@@ -349,14 +350,14 @@ async function getIngredientStructure(assetManager: AssetManager, ingredient: In
return { structure, assets };
}
-export function createStructureFromCellPack(assetManager: AssetManager, packing: CellPacking, baseUrl: string, ingredientFiles: IngredientFiles) {
+export function createStructureFromCellPack(plugin: PluginContext, packing: CellPacking, baseUrl: string, ingredientFiles: IngredientFiles) {
return Task.create('Create Packing Structure', async ctx => {
const { ingredients, name } = packing;
const assets: Asset.Wrapper[] = [];
const structures: Structure[] = [];
for (const iName in ingredients) {
if (ctx.shouldUpdate) await ctx.update(iName);
- const ingredientStructure = await getIngredientStructure(assetManager, ingredients[iName], baseUrl, ingredientFiles);
+ const ingredientStructure = await getIngredientStructure(plugin, ingredients[iName], baseUrl, ingredientFiles);
if (ingredientStructure) {
structures.push(ingredientStructure.structure);
assets.push(...ingredientStructure.assets);
diff --git a/src/extensions/cellpack/state.ts b/src/extensions/cellpack/state.ts
index 361a2b2b5..8ae16116d 100644
--- a/src/extensions/cellpack/state.ts
+++ b/src/extensions/cellpack/state.ts
@@ -71,7 +71,7 @@ const StructureFromCellpack = PluginStateTransform.BuiltIn({
ingredientFiles[file.name] = file;
}
}
- const { structure, assets } = await createStructureFromCellPack(plugin.managers.asset, packing, params.baseUrl, ingredientFiles).runInContext(ctx);
+ const { structure, assets } = await createStructureFromCellPack(plugin, packing, params.baseUrl, ingredientFiles).runInContext(ctx);
await CellPackInfoProvider.attach({ runtime: ctx, assetManager: plugin.managers.asset }, structure, {
info: { packingsCount: a.data.packings.length, packingIndex: params.packing }
diff --git a/src/extensions/cellpack/util.ts b/src/extensions/cellpack/util.ts
index 52b45db19..0d790ad1b 100644
--- a/src/extensions/cellpack/util.ts
+++ b/src/extensions/cellpack/util.ts
@@ -9,50 +9,51 @@ import { parsePDB } from '../../mol-io/reader/pdb/parser';
import { AssetManager, Asset } from '../../mol-util/assets';
import { Structure } from '../../mol-model/structure';
import { Vec3 } from '../../mol-math/linear-algebra';
+import { PluginContext } from '../../mol-plugin/context';
-export async function parseCif(data: string|Uint8Array) {
+export async function parseCif(plugin: PluginContext, data: string | Uint8Array) {
const comp = CIF.parse(data);
- const parsed = await comp.run();
+ const parsed = await plugin.runTask(comp);
if (parsed.isError) throw parsed;
return parsed.result;
}
-export async function parsePDBfile(data: string, id: string) {
+export async function parsePDBfile(plugin: PluginContext, data: string, id: string) {
const comp = parsePDB(data, id);
- const parsed = await comp.run();
+ const parsed = await plugin.runTask(comp);
if (parsed.isError) throw parsed;
return parsed.result;
}
-async function downloadCif(url: string, isBinary: boolean, assetManager: AssetManager) {
+async function downloadCif(plugin: PluginContext, url: string, isBinary: boolean, assetManager: AssetManager) {
const type = isBinary ? 'binary' : 'string';
- const asset = await assetManager.resolve(Asset.getUrlAsset(assetManager, url), type).run();
- return { cif: await parseCif(asset.data), asset };
+ const asset = await plugin.runTask(assetManager.resolve(Asset.getUrlAsset(assetManager, url), type));
+ return { cif: await parseCif(plugin, asset.data), asset };
}
-async function downloadPDB(url: string, id: string, assetManager: AssetManager) {
+async function downloadPDB(plugin: PluginContext, url: string, id: string, assetManager: AssetManager) {
const asset = await assetManager.resolve(Asset.getUrlAsset(assetManager, url), 'string').run();
- return { pdb: await parsePDBfile(asset.data, id), asset };
+ return { pdb: await parsePDBfile(plugin, asset.data, id), asset };
}
-export async function getFromPdb(pdbId: string, assetManager: AssetManager) {
- const { cif, asset } = await downloadCif(`https://models.rcsb.org/${pdbId.toUpperCase()}.bcif`, true, assetManager);
+export async function getFromPdb(plugin: PluginContext, pdbId: string, assetManager: AssetManager) {
+ const { cif, asset } = await downloadCif(plugin, `https://models.rcsb.org/${pdbId.toUpperCase()}.bcif`, true, assetManager);
return { mmcif: cif.blocks[0], asset };
}
-export async function getFromOPM(pdbId: string, assetManager: AssetManager){
- const asset = await assetManager.resolve(Asset.getUrlAsset(assetManager, `https://opm-assets.storage.googleapis.com/pdb/${pdbId.toLowerCase()}.pdb`), 'string').run();
- return { pdb: await parsePDBfile(asset.data, pdbId), asset };
+export async function getFromOPM(plugin: PluginContext, pdbId: string, assetManager: AssetManager){
+ const asset = await plugin.runTask(assetManager.resolve(Asset.getUrlAsset(assetManager, `https://opm-assets.storage.googleapis.com/pdb/${pdbId.toLowerCase()}.pdb`), 'string'));
+ return { pdb: await parsePDBfile(plugin, asset.data, pdbId), asset };
}
-export async function getFromCellPackDB(id: string, baseUrl: string, assetManager: AssetManager) {
+export async function getFromCellPackDB(plugin: PluginContext, id: string, baseUrl: string, assetManager: AssetManager) {
if (id.toLowerCase().endsWith('.cif') || id.toLowerCase().endsWith('.bcif')) {
const isBinary = id.toLowerCase().endsWith('.bcif');
- const { cif, asset } = await downloadCif(`${baseUrl}/other/${id}`, isBinary, assetManager);
+ const { cif, asset } = await downloadCif(plugin, `${baseUrl}/other/${id}`, isBinary, assetManager);
return { mmcif: cif.blocks[0], asset };
} else {
const name = id.endsWith('.pdb') ? id.substring(0, id.length - 4) : id;
- return await downloadPDB(`${baseUrl}/other/${name}.pdb`, name, assetManager);
+ return await downloadPDB(plugin, `${baseUrl}/other/${name}.pdb`, name, assetManager);
}
}
--
GitLab