@mat3ra/wode 2025.10.1-0

package/src/units/execution.js

@@ -0,0 +1,263 @@
+import { Template } from "@exabyte-io/ade.js";
+import ApplicationRegistry from "@exabyte-io/ade.js/dist/js/ApplicationRegistry";
+import { Utils } from "@mat3ra/utils";
+import _ from "underscore";
+
+import { BaseUnit } from "./base";
+
+export class ExecutionUnit extends BaseUnit {
+    // keys to be omitted during toJSON
+    static omitKeys = [
+        "job",
+        "workflow",
+        "material",
+        "materials",
+        "model",
+        "methodData",
+        "hasRelaxation",
+    ];
+
+    /**
+     * @override this method to provide entities from other sources
+     */
+    _initApplication(config) {
+        this._application = ApplicationRegistry.createApplication(config.application);
+        this._executable = ApplicationRegistry.getExecutableByConfig(
+            this._application.name,
+            config.executable,
+        );
+        this._flavor = ApplicationRegistry.getFlavorByConfig(this._executable, config.flavor);
+        this._templates = this._flavor ? this._flavor.inputAsTemplates : [];
+    }
+
+    /**
+     * @override this method to provide default executable from other source
+     */
+    _getDefaultExecutable() {
+        return ApplicationRegistry.getExecutableByName(this.application.name);
+    }
+
+    /**
+     * @override this method to provide default flavor from other source
+     */
+    _getDefaultFlavor() {
+        return ApplicationRegistry.getFlavorByName(this.executable.name);
+    }
+
+    /**
+     * @override this method to provide custom templates
+     */
+    _getTemplatesFromInput() {
+        return this.getInput().map((i) => new Template(i));
+    }
+
+    /**
+     * @override this method to provide custom input from other sources
+     */
+    _getInput() {
+        return (
+            this.input ||
+            ApplicationRegistry.getInputAsRenderedTemplates(
+                this.flavor,
+                this.getCombinedContext(),
+            ) ||
+            []
+        );
+    }
+
+    /**
+     * @override this method to provide custom input as templates
+     */
+    _getInputAsTemplates() {
+        return ApplicationRegistry.getInputAsTemplates(this.flavor);
+    }
+
+    _initRuntimeItems(keys, config) {
+        this._initApplication(config);
+        super._initRuntimeItems(keys);
+    }
+
+    /*
+     * @summary expects an array with elements containing field [{content: "..."}]
+     */
+    get hashFromArrayInputContent() {
+        const objectForHashing = this._getInput().map((i) => {
+            return Utils.str.removeEmptyLinesFromString(
+                Utils.str.removeCommentsFromSourceCode(i.content),
+            );
+        });
+        return Utils.hash.calculateHashFromObject(objectForHashing);
+    }
+
+    get name() {
+        return this.prop("name", this.flavor.name);
+    }
+
+    get application() {
+        return this._application;
+    }
+
+    get executable() {
+        return this._executable;
+    }
+
+    get flavor() {
+        return this._flavor;
+    }
+
+    get templates() {
+        return this._templates;
+    }
+
+    setApplication(application, omitSettingExecutable = false) {
+        this._application = application;
+        this.setProp("application", application.toJSON());
+        if (!omitSettingExecutable) {
+            this.setExecutable(this._getDefaultExecutable());
+        }
+    }
+
+    setExecutable(executable) {
+        this._executable = executable;
+        this.setProp("executable", executable.toJSON());
+        this.setFlavor(this._getDefaultFlavor());
+    }
+
+    setFlavor(flavor) {
+        this._flavor = flavor;
+        this.setRuntimeItemsToDefaultValues();
+        this.setProp("flavor", flavor.toJSON());
+        this.setTemplates(this._getInputAsTemplates());
+    }
+
+    setTemplates(templates) {
+        this._templates = templates;
+        this.render(this.context, true);
+    }
+
+    setInput(input) {
+        this.setProp("input", input);
+    }
+
+    get defaultResults() {
+        return this.flavor.results;
+    }
+
+    get defaultMonitors() {
+        return this.flavor.monitors;
+    }
+
+    get defaultPostProcessors() {
+        return this.flavor.postProcessors;
+    }
+
+    get allowedResults() {
+        return this.executable.results;
+    }
+
+    get allowedMonitors() {
+        return this.executable.monitors;
+    }
+
+    get allowedPostProcessors() {
+        return this.executable.postProcessors;
+    }
+
+    get allContextProviders() {
+        const list = [];
+        // pass context below to keep UI changes
+        this.templates.forEach((i) =>
+            list.push(...i.getContextProvidersAsClassInstances(this.getCombinedContext())),
+        );
+        return list;
+    }
+
+    get contextProviders() {
+        return this.allContextProviders.filter((p) => p.isUnitContextProvider);
+    }
+
+    get input() {
+        return this.prop("input");
+    }
+
+    get renderingContext() {
+        return this._renderingContext || {};
+    }
+
+    set renderingContext(ctx) {
+        this._renderingContext = ctx;
+    }
+
+    // context to persist in toJSON
+    get storedContext() {
+        return _.omit(this.context, ...this.constructor.omitKeys);
+    }
+
+    // context to show to users with some extra keys omitted
+    get visibleRenderingContext() {
+        return _.omit(this.renderingContext, ...this.constructor.omitKeys);
+    }
+
+    static getSubworkflowContext(context) {
+        const { subworkflowContext } = context;
+        return subworkflowContext ? { subworkflowContext } : {};
+    }
+
+    /** Update rendering context and persistent context
+     * Note: this function is sometimes being called without passing a context!
+     * @param context
+     * @param fromTemplates
+     */
+    render(context, fromTemplates = false) {
+        const newInput = [];
+        const newPersistentContext = {};
+        const newRenderingContext = {};
+        const renderingContext = { ...this.context, ...context };
+        this.updateContext(renderingContext); // update in-memory context to properly render templates from input below
+        (fromTemplates ? this.templates : this._getTemplatesFromInput()).forEach((t) => {
+            newInput.push(t.getRenderedJSON(renderingContext));
+            Object.assign(
+                newRenderingContext,
+                t.getDataFromProvidersForRenderingContext(renderingContext),
+                ExecutionUnit.getSubworkflowContext(renderingContext),
+            );
+            Object.assign(
+                newPersistentContext,
+                t.getDataFromProvidersForPersistentContext(renderingContext),
+                ExecutionUnit.getSubworkflowContext(renderingContext),
+            );
+        });
+        this.setInput(newInput);
+        this.renderingContext = newRenderingContext;
+        this.updatePersistentContext(newPersistentContext);
+    }
+
+    /**
+     * @summary Calculates hash on unit-specific fields.
+     * The meaningful fields of processing unit are operation, flavor and input at the moment.
+     */
+    getHashObject() {
+        return {
+            ...super.getHashObject(),
+            application: Utils.specific.removeTimestampableKeysFromConfig(
+                this.application.toJSON(),
+            ),
+            executable: Utils.specific.removeTimestampableKeysFromConfig(this.executable.toJSON()),
+            flavor: Utils.specific.removeTimestampableKeysFromConfig(this.flavor.toJSON()),
+            input: this.hashFromArrayInputContent,
+        };
+    }
+
+    toJSON() {
+        return this.clean({
+            ...super.toJSON(),
+            executable: this.executable.toJSON(),
+            flavor: this.flavor.toJSON(),
+            input: this._getInput(),
+            // keys below are not propagated to the parent class on initialization of a new unit unless explicitly given
+            name: this.name,
+            // TODO: figure out the problem with storing context below
+            // context: this.storedContext,
+        });
+    }
+}

package/src/units/factory.js

@@ -0,0 +1,53 @@
+import { UNIT_TYPES } from "../enums";
+import { AssertionUnit } from "./assertion";
+import { AssignmentUnit } from "./assignment";
+import { BaseUnit } from "./base";
+import { ConditionUnit } from "./condition";
+import { ExecutionUnit } from "./execution";
+import { IOUnit } from "./io";
+import { MapUnit } from "./map";
+import { ProcessingUnit } from "./processing";
+import { SubworkflowUnit } from "./subworkflow";
+
+export class UnitFactory {
+    static AssertionUnit = AssertionUnit;
+
+    static AssignmentUnit = AssignmentUnit;
+
+    static BaseUnit = BaseUnit;
+
+    static ConditionUnit = ConditionUnit;
+
+    static ExecutionUnit = ExecutionUnit;
+
+    static IOUnit = IOUnit;
+
+    static MapUnit = MapUnit;
+
+    static ProcessingUnit = ProcessingUnit;
+
+    static SubworkflowUnit = SubworkflowUnit;
+
+    static create(config) {
+        switch (config.type) {
+            case UNIT_TYPES.execution:
+                return new this.ExecutionUnit(config);
+            case UNIT_TYPES.assignment:
+                return new this.AssignmentUnit(config);
+            case UNIT_TYPES.condition:
+                return new this.ConditionUnit(config);
+            case UNIT_TYPES.io:
+                return new this.IOUnit(config);
+            case UNIT_TYPES.processing:
+                return new this.ProcessingUnit(config);
+            case UNIT_TYPES.map:
+                return new this.MapUnit(config);
+            case UNIT_TYPES.subworkflow:
+                return new this.SubworkflowUnit(config);
+            case UNIT_TYPES.assertion:
+                return new this.AssertionUnit(config);
+            default:
+                return new this.BaseUnit(config);
+        }
+    }
+}

package/src/units/index.js

@@ -0,0 +1,25 @@
+import { AssertionUnit } from "./assertion";
+import { AssignmentUnit } from "./assignment";
+import { BaseUnit } from "./base";
+import { ConditionUnit } from "./condition";
+import { ExecutionUnit } from "./execution";
+import { UnitFactory } from "./factory";
+import { IOUnit } from "./io";
+import { MapUnit } from "./map";
+import { ProcessingUnit } from "./processing";
+import { ReduceUnit } from "./reduce";
+import { SubworkflowUnit } from "./subworkflow";
+
+export {
+    BaseUnit,
+    AssertionUnit,
+    AssignmentUnit,
+    ConditionUnit,
+    ExecutionUnit,
+    IOUnit,
+    MapUnit,
+    ProcessingUnit,
+    ReduceUnit,
+    SubworkflowUnit,
+    UnitFactory,
+};

package/src/units/io.js

@@ -0,0 +1,163 @@
+import lodash from "lodash";
+
+import { IO_ID_COLUMN, UNIT_TYPES } from "../enums";
+import { BaseUnit } from "./base";
+
+export class IOUnit extends BaseUnit {
+    /**
+     * IO Unit Builder for Object Storage sources.
+     *
+     * @param {Object} config - config object with other parameters:
+     * @param {String} config.name - the name of the unit this builder is creating
+     * @param {String} config.subtype - "input", "output", or "dataframe"
+     * @param {Object} config.input - input containing information on the file to download
+     * @param {Boolean} config.enableRender - Whether to use Jinja templating at runtime
+     */
+    constructor(config) {
+        super({ ...IOUnit.getIOConfig(), ...config });
+        this.initialize(config);
+    }
+
+    static getIOConfig() {
+        return {
+            name: UNIT_TYPES.io,
+            type: UNIT_TYPES.io,
+            subtype: "input",
+        };
+    }
+
+    initialize(config) {
+        this._materials = [];
+        this._defaultTargets = ["band_gaps:direct", "band_gaps:indirect"];
+        this._features = lodash.get(config, "input.0.endpoint_options.data.features", []);
+        this._targets = lodash.get(
+            config,
+            "input.0.endpoint_options.data.targets",
+            this._defaultTargets,
+        );
+        this._ids = lodash.get(config, "input.0.endpoint_options.data.ids", []);
+        this._jobId = null;
+    }
+
+    get materials() {
+        return this._materials || [];
+    }
+
+    get defaultTargets() {
+        return this._defaultTargets;
+    }
+
+    get features() {
+        return this._features;
+    }
+
+    get featuresWithoutId() {
+        return this.features.filter((x) => x !== IO_ID_COLUMN);
+    }
+
+    get availableFeatures() {
+        const { materials } = this;
+        return lodash.uniq(
+            lodash
+                .flatten(materials.map((x) => lodash.keys(x.propertiesDict())))
+                .concat(this.features),
+        );
+    }
+
+    get availableFeaturesWithoutId() {
+        return this.availableFeatures.filter((feature) => feature !== IO_ID_COLUMN);
+    }
+
+    get targets() {
+        return this._targets;
+    }
+
+    /**
+     * @summary Checks whether selected features contain only IO_ID_COLUMN ('exabyteId').
+     * Used to identify that no features are selected yet (features set always contains ID_COLUMN)
+     */
+    get onlyIdFeatureSelected() {
+        return lodash.isEmpty(lodash.without(this.features, IO_ID_COLUMN));
+    }
+
+    /**
+     * @summary Returns object with targets as key and arrays of appropriate values.
+     * E.g. {'band_gap:indirect': [0.1, 0.3], 'pressure': [100, undefined]}
+     */
+    get valuesByTarget() {
+        const values = this.dataGridValues;
+        const result = {};
+        this.targets.forEach((target) => {
+            result[target] = values.map((v) => v[target]);
+        });
+        return result;
+    }
+
+    get dataFrameConfig() {
+        return {
+            subtype: "dataFrame",
+            source: "api",
+            input: [
+                {
+                    endpoint: "dataframe",
+                    endpoint_options: {
+                        method: "POST",
+                        data: {
+                            targets: this._targets,
+                            features: this._features,
+                            ids: this._ids,
+                            jobId: this._jobId,
+                        },
+                        headers: {},
+                        params: {},
+                    },
+                },
+            ],
+        };
+    }
+
+    get isDataFrame() {
+        return this.prop("subtype") === "dataFrame";
+    }
+
+    setMaterials(materials) {
+        this._materials = materials;
+        this._ids = materials.map((m) => m.exabyteId);
+    }
+
+    addFeature(feature) {
+        // only add if not already present
+        if (this._features.indexOf(feature) === -1) this._features.push(feature);
+    }
+
+    removeFeature(feature) {
+        if (this.featuresWithoutId.length === 1) {
+            throw new Error("At least one feature is required");
+        }
+        this._features = this._features.filter((x) => feature !== x && x !== IO_ID_COLUMN);
+    }
+
+    addTarget(target) {
+        if (this._targets.indexOf(target) === -1) this._targets.push(target);
+    }
+
+    removeTarget(target) {
+        if (this._targets.length === 1) {
+            throw new Error("At least one target is required");
+        }
+        this._targets = this._targets.filter((x) => target !== x);
+    }
+
+    hasFeature(feature) {
+        return this._features.indexOf(feature) > -1;
+    }
+
+    hasTarget(target) {
+        return this._targets.indexOf(target) > -1;
+    }
+
+    toJSON() {
+        const config = this.isDataFrame ? this.dataFrameConfig : {};
+        return this.clean({ ...super.toJSON(), ...config });
+    }
+}

package/src/units/map.js

@@ -0,0 +1,33 @@
+import { UNIT_TYPES } from "../enums";
+import { BaseUnit } from "./base";
+
+export const defaultMapConfig = {
+    name: UNIT_TYPES.map,
+    type: UNIT_TYPES.map,
+    workflowId: "",
+    input: {
+        target: "MAP_DATA",
+        scope: "global",
+        name: "",
+        values: [],
+        useValues: false,
+    },
+};
+
+export class MapUnit extends BaseUnit {
+    constructor(config) {
+        super({ ...defaultMapConfig, ...config });
+    }
+
+    get input() {
+        return this.prop("input");
+    }
+
+    get workflowId() {
+        return this.prop("workflowId");
+    }
+
+    setWorkflowId(id) {
+        this.setProp("workflowId", id);
+    }
+}

package/src/units/processing.js

@@ -0,0 +1,39 @@
+import { UNIT_TYPES } from "../enums";
+import { BaseUnit } from "./base";
+
+export class ProcessingUnit extends BaseUnit {
+    constructor(config) {
+        super({ ...ProcessingUnit.getProcessingConfig(), ...config });
+    }
+
+    static getProcessingConfig() {
+        return {
+            name: UNIT_TYPES.processing,
+            type: UNIT_TYPES.processing,
+        };
+    }
+
+    setOperation(op) {
+        this.setProp("operation", op);
+    }
+
+    setOperationType(type) {
+        this.setProp("operationType", type);
+    }
+
+    setInput(input) {
+        this.setProp("input", input);
+    }
+
+    get operation() {
+        return this.prop("operation");
+    }
+
+    get operationType() {
+        return this.prop("operationType");
+    }
+
+    get input() {
+        return this.prop("input");
+    }
+}

package/src/units/reduce.js

@@ -0,0 +1,17 @@
+import { UNIT_TYPES } from "../enums";
+import { BaseUnit } from "./base";
+
+export class ReduceUnit extends BaseUnit {
+    constructor(unitName, mapUnit, input) {
+        super({ ...ReduceUnit.getReduceConfig(unitName, mapUnit, input) });
+    }
+
+    static getReduceConfig(unitName, mapUnit, input) {
+        return {
+            type: UNIT_TYPES.reduce,
+            name: unitName,
+            mapFlowchartId: mapUnit,
+            input,
+        };
+    }
+}

package/src/units/subworkflow.js

@@ -0,0 +1,15 @@
+import { UNIT_TYPES } from "../enums";
+import { BaseUnit } from "./base";
+
+export class SubworkflowUnit extends BaseUnit {
+    constructor(config) {
+        super({ ...SubworkflowUnit.getSubworkflowConfig(), ...config });
+    }
+
+    static getSubworkflowConfig() {
+        return {
+            name: "New Subworkflow",
+            type: UNIT_TYPES.subworkflow,
+        };
+    }
+}

package/src/utils.js

@@ -0,0 +1,73 @@
+import lodash from "lodash";
+
+/**
+ * @summary set the head of an array of units
+ * @param units
+ * @returns {Unit[]}
+ */
+export function setUnitsHead(units) {
+    if (units.length > 0) {
+        units[0].head = true;
+        lodash.tail(units).map((x) => (x.head = false));
+    }
+    return units;
+}
+
+// TODO: fix setNextLinks on unit removal and convergence logic.
+/**
+ * @summary Re-establishes the linked `next => flowchartId` logic in an array of units
+ * @params units {Unit[]}
+ * @returns units {Unit[]}
+ */
+export function setNextLinks(units) {
+    const flowchartIds = units.map((u) => u.flowchartId);
+    for (let i = 0; i < units.length - 1; i++) {
+        if (!units[i].next) {
+            // newly added units don't have next set yet => set it
+            units[i].next = units[i + 1].flowchartId;
+            if (i > 0) units[i - 1].next = units[i].flowchartId;
+        } else if (!flowchartIds.includes(units[i].next)) {
+            // newly removed units may create broken next links => fix it
+            units[i].next = units[i + 1].flowchartId;
+        }
+    }
+    return units;
+}
+
+/**
+ * @summary Apply configuration data to an object
+ * @param obj {*} object / class containing methods or attributes to be set
+ * @param config { functions: {}, attributes: {} } functions to call and attributes to set
+ * @param callBuild {boolean} if true; call build between applying functions and attributes
+ * @returns {*} updated object
+ */
+export function applyConfig({ obj, config = {}, callBuild = false }) {
+    const { functions = {}, attributes = {} } = config;
+    // eslint-disable-next-line no-restricted-syntax
+    for (const [func, args] of Object.entries(functions)) {
+        // eslint-disable-next-line no-nested-ternary
+        if (obj[func]) {
+            if (args) obj[func](args);
+            else obj[func]();
+        }
+    }
+    const modified = callBuild ? obj.build() : obj;
+    // eslint-disable-next-line no-restricted-syntax
+    for (const [key, values] of Object.entries(attributes)) {
+        modified[key] = values;
+    }
+    return modified;
+}
+
+/**
+ * @summary Safely extract unit object from subworkflow data
+ * @param subworkflowData {Object} subworkflow data
+ * @param index {number} index of subworkflow unit
+ * @param type {string} type of subworkflow unit
+ * @returns {Object|null} subworkflow unit object (not a unit class instance!)
+ */
+export function findUnit({ subworkflowData, index, type }) {
+    const unit = subworkflowData.units[index];
+    if (unit.type !== type) throw new Error("findUnit() error: unit type does not match!");
+    return unit;
+}