@mat3ra/wode 2026.5.23-0 → 2026.5.29-0

package/src/js/units/builders/UnitConfigBuilder.js

@@ -1,92 +0,0 @@
-import { Utils } from "@mat3ra/utils";
-import _ from "underscore";
-
-export class UnitConfigBuilder {
-    static usePredefinedIds = false;
-
-    constructor({ name, type, flowchartId, cache = [] }) {
-        this.type = type;
-        this._name = name;
-        this._head = false;
-        this._results = [];
-        this._monitors = [];
-        this._preProcessors = [];
-        this._postProcessors = [];
-        this.cache = cache;
-        const countInCache = this.cache.filter((s) => s === name).length;
-        this.cache.push(name);
-        this._flowchartId = flowchartId || this.generateFlowChartId(name, countInCache);
-    }
-
-    name(str) {
-        this._name = str;
-        return this;
-    }
-
-    head(bool) {
-        this._head = bool;
-        return this;
-    }
-
-    generateFlowChartId(seed, countInCache = 0) {
-        const suffix = countInCache > 0 ? `-${countInCache}` : "";
-        const seedWithSuffix = `${seed}${suffix}`;
-        if (this.constructor.usePredefinedIds)
-            return Utils.uuid.getUUIDFromNamespace(seedWithSuffix);
-        return Utils.uuid.getUUID();
-    }
-
-    flowchartId(flowchartId) {
-        this._flowchartId = flowchartId;
-        return this;
-    }
-
-    static _stringArrayToNamedObject(array) {
-        return array.map((name) => (_.isString(name) ? { name } : name));
-    }
-
-    addPreProcessors(preProcessorNames) {
-        this._preProcessors = _.union(
-            this.constructor._stringArrayToNamedObject(preProcessorNames),
-            this._preProcessors,
-        );
-        return this;
-    }
-
-    addPostProcessors(postProcessorNames) {
-        this._postProcessors = _.union(
-            this.constructor._stringArrayToNamedObject(postProcessorNames),
-            this._postProcessors,
-        );
-        return this;
-    }
-
-    addResults(resultNames) {
-        this._results = _.union(
-            this.constructor._stringArrayToNamedObject(resultNames),
-            this._results,
-        );
-        return this;
-    }
-
-    addMonitors(monitorNames) {
-        this._monitors = _.union(
-            this.constructor._stringArrayToNamedObject(monitorNames),
-            this._monitors,
-        );
-        return this;
-    }
-
-    build() {
-        return {
-            type: this.type,
-            name: this._name,
-            head: this._head,
-            results: this._results,
-            monitors: this._monitors,
-            flowchartId: this._flowchartId,
-            preProcessors: this._preProcessors,
-            postProcessors: this._postProcessors,
-        };
-    }
-}

package/src/js/units/builders/index.js

@@ -1,15 +0,0 @@
-import { AssertionUnitConfigBuilder } from "./AssertionUnitConfigBuilder";
-import { AssignmentUnitConfigBuilder } from "./AssignmentUnitConfigBuilder";
-import { ExecutionUnitConfigBuilder } from "./ExecutionUnitConfigBuilder";
-import { IOUnitConfigBuilder } from "./IOUnitConfigBuilder";
-import { UnitConfigBuilder } from "./UnitConfigBuilder";
-
-const builders = {
-    UnitConfigBuilder,
-    AssignmentUnitConfigBuilder,
-    AssertionUnitConfigBuilder,
-    ExecutionUnitConfigBuilder,
-    IOUnitConfigBuilder,
-};
-
-export { builders };

package/src/js/units/condition.js

@@ -1,47 +0,0 @@
-import { UNIT_TYPES } from "../enums";
-import { BaseUnit } from "./base";
-
-export class ConditionUnit extends BaseUnit {
-    constructor(config) {
-        super({ ...ConditionUnit.getConditionConfig(), ...config });
-    }
-
-    static getConditionConfig() {
-        return {
-            name: UNIT_TYPES.condition,
-            type: UNIT_TYPES.condition,
-            input: [],
-            results: [],
-            preProcessors: [],
-            postProcessors: [],
-            then: undefined,
-            else: undefined,
-            statement: "true",
-            maxOccurrences: 100,
-        };
-    }
-
-    get input() {
-        return this.prop("input");
-    }
-
-    get then() {
-        return this.prop("then");
-    }
-
-    get else() {
-        return this.prop("else");
-    }
-
-    get statement() {
-        return this.prop("statement");
-    }
-
-    get maxOccurrences() {
-        return this.prop("maxOccurrences");
-    }
-
-    getHashObject() {
-        return { statement: this.statement, maxOccurrences: this.maxOccurrences };
-    }
-}

package/src/js/units/execution.js

@@ -1,267 +0,0 @@
-import { ApplicationRegistry, Template } from "@mat3ra/ade";
-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() {
-        const json = 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,
-        });
-
-        // Remove results from executable
-        if (json.executable?.results) delete json.executable.results;
-
-        return json;
-    }
-}

package/src/js/units/factory.js

@@ -1,53 +0,0 @@
-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/js/units/index.js

@@ -1,25 +0,0 @@
-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/js/units/io.js

@@ -1,163 +0,0 @@
-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/js/units/map.js

@@ -1,33 +0,0 @@
-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);
-    }
-}