@nfdi4plants/arctrl 1.0.0-alpha10

package/ISA/ISA/JsonTypes/ProcessOutput.js

@@ -0,0 +1,263 @@
+import { Union, toString } from "../../../fable_modules/fable-library.4.1.4/Types.js";
+import { printf, toText } from "../../../fable_modules/fable-library.4.1.4/String.js";
+import { Sample_create_E50ED22, Sample_getUnits_Z29207F1E, Sample_setFactorValues, Sample_get_empty, Sample_$reflection } from "./Sample.js";
+import { Data_create_Z326CF519, Data_$reflection } from "./Data.js";
+import { Material_create_Z31BE6CDD, Material_getUnits_Z42815C11, Material_$reflection } from "./Material.js";
+import { union_type } from "../../../fable_modules/fable-library.4.1.4/Reflection.js";
+import { unwrap, map, defaultArg } from "../../../fable_modules/fable-library.4.1.4/Option.js";
+import { empty, choose } from "../../../fable_modules/fable-library.4.1.4/List.js";
+import { DataFile } from "./DataFile.js";
+
+export class ProcessOutput extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Sample", "Data", "Material"];
+    }
+    Print() {
+        const this$ = this;
+        return toString(this$);
+    }
+    PrintCompact() {
+        const this$ = this;
+        switch (this$.tag) {
+            case 2: {
+                const arg_1 = this$.fields[0].PrintCompact();
+                return toText(printf("Material {%s}"))(arg_1);
+            }
+            case 1: {
+                const arg_2 = this$.fields[0].PrintCompact();
+                return toText(printf("Data {%s}"))(arg_2);
+            }
+            default: {
+                const arg = this$.fields[0].PrintCompact();
+                return toText(printf("Sample {%s}"))(arg);
+            }
+        }
+    }
+}
+
+export function ProcessOutput_$reflection() {
+    return union_type("ARCtrl.ISA.ProcessOutput", [], ProcessOutput, () => [[["Item", Sample_$reflection()]], [["Item", Data_$reflection()]], [["Item", Material_$reflection()]]]);
+}
+
+export function ProcessOutput__get_TryName(this$) {
+    switch (this$.tag) {
+        case 2:
+            return this$.fields[0].Name;
+        case 1:
+            return this$.fields[0].Name;
+        default:
+            return this$.fields[0].Name;
+    }
+}
+
+export function ProcessOutput__get_Name(this$) {
+    return defaultArg(ProcessOutput__get_TryName(this$), "");
+}
+
+export function ProcessOutput_get_Default() {
+    return new ProcessOutput(0, [Sample_get_empty()]);
+}
+
+/**
+ * Returns name of processOutput
+ */
+export function ProcessOutput_tryGetName_11830B70(po) {
+    return ProcessOutput__get_TryName(po);
+}
+
+/**
+ * Returns name of processInput
+ */
+export function ProcessOutput_getName_11830B70(po) {
+    return ProcessOutput__get_Name(po);
+}
+
+/**
+ * Returns true, if given name equals name of processOutput
+ */
+export function ProcessOutput_nameEquals(name, po) {
+    return ProcessOutput__get_Name(po) === name;
+}
+
+/**
+ * Returns true, if Process Output is Sample
+ */
+export function ProcessOutput_isSample_11830B70(po) {
+    if (po.tag === 0) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+/**
+ * Returns true, if Process Output is Data
+ */
+export function ProcessOutput_isData_11830B70(po) {
+    if (po.tag === 1) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+/**
+ * Returns true, if Process Output is Material
+ */
+export function ProcessOutput_isMaterial_11830B70(po) {
+    if (po.tag === 2) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+/**
+ * Returns true, if Process Output is Sample
+ */
+export function ProcessOutput__isSample(this$) {
+    return ProcessOutput_isSample_11830B70(this$);
+}
+
+/**
+ * Returns true, if Process Output is Data
+ */
+export function ProcessOutput__isData(this$) {
+    return ProcessOutput_isData_11830B70(this$);
+}
+
+/**
+ * Returns true, if Process Output is Material
+ */
+export function ProcessOutput__isMaterial(this$) {
+    return ProcessOutput_isMaterial_11830B70(this$);
+}
+
+/**
+ * If given process output is a sample, returns it, else returns None
+ */
+export function ProcessOutput_trySample_11830B70(po) {
+    if (po.tag === 0) {
+        return po.fields[0];
+    }
+    else {
+        return void 0;
+    }
+}
+
+/**
+ * If given process output is a data, returns it, else returns None
+ */
+export function ProcessOutput_tryData_11830B70(po) {
+    if (po.tag === 1) {
+        return po.fields[0];
+    }
+    else {
+        return void 0;
+    }
+}
+
+/**
+ * If given process output is a material, returns it, else returns None
+ */
+export function ProcessOutput_tryMaterial_11830B70(po) {
+    if (po.tag === 2) {
+        return po.fields[0];
+    }
+    else {
+        return void 0;
+    }
+}
+
+/**
+ * If given process output contains characteristics, returns them
+ */
+export function ProcessOutput_tryGetCharacteristicValues_11830B70(po) {
+    switch (po.tag) {
+        case 2:
+            return po.fields[0].Characteristics;
+        case 1:
+            return void 0;
+        default:
+            return po.fields[0].Characteristics;
+    }
+}
+
+/**
+ * If given process output contains characteristics, returns them
+ */
+export function ProcessOutput_tryGetCharacteristics_11830B70(po) {
+    return map((list) => choose((c) => c.Category, list), ProcessOutput_tryGetCharacteristicValues_11830B70(po));
+}
+
+/**
+ * If given process output contains factors, returns them
+ */
+export function ProcessOutput_tryGetFactorValues_11830B70(po) {
+    switch (po.tag) {
+        case 2:
+            return void 0;
+        case 1:
+            return void 0;
+        default:
+            return po.fields[0].FactorValues;
+    }
+}
+
+export function ProcessOutput_setFactorValues(values, po) {
+    switch (po.tag) {
+        case 2:
+            return po;
+        case 1:
+            return po;
+        default:
+            return new ProcessOutput(0, [Sample_setFactorValues(values, po.fields[0])]);
+    }
+}
+
+export function ProcessOutput_getFactorValues_11830B70(po) {
+    return defaultArg(ProcessOutput_tryGetFactorValues_11830B70(po), empty());
+}
+
+/**
+ * If given process output contains units, returns them
+ */
+export function ProcessOutput_getUnits_11830B70(po) {
+    switch (po.tag) {
+        case 2:
+            return Material_getUnits_Z42815C11(po.fields[0]);
+        case 1:
+            return empty();
+        default:
+            return Sample_getUnits_Z29207F1E(po.fields[0]);
+    }
+}
+
+export function ProcessOutput_createSample_Z6DF16D07(name, characteristics, factors, derivesFrom) {
+    return new ProcessOutput(0, [Sample_create_E50ED22(void 0, name, unwrap(characteristics), unwrap(factors), unwrap(derivesFrom))]);
+}
+
+export function ProcessOutput_createMaterial_2363974C(name, characteristics, derivesFrom) {
+    return new ProcessOutput(2, [Material_create_Z31BE6CDD(void 0, name, void 0, unwrap(characteristics), unwrap(derivesFrom))]);
+}
+
+export function ProcessOutput_createImageFile_Z721C83C5(name) {
+    return new ProcessOutput(1, [Data_create_Z326CF519(void 0, name, new DataFile(2, []))]);
+}
+
+export function ProcessOutput_createRawData_Z721C83C5(name) {
+    return new ProcessOutput(1, [Data_create_Z326CF519(void 0, name, new DataFile(0, []))]);
+}
+
+export function ProcessOutput_createDerivedData_Z721C83C5(name) {
+    return new ProcessOutput(1, [Data_create_Z326CF519(void 0, name, new DataFile(1, []))]);
+}
+

package/ISA/ISA/JsonTypes/ProcessParameterValue.js

@@ -0,0 +1,129 @@
+import { Record, toString } from "../../../fable_modules/fable-library.4.1.4/Types.js";
+import { bind, defaultArg, map } from "../../../fable_modules/fable-library.4.1.4/Option.js";
+import { ProtocolParameter__SetCategory_Z4C0FE73C, ProtocolParameter_create_Z6C54B221, ProtocolParameter__MapCategory_Z69DD836A, ProtocolParameter__get_TryNameText, ProtocolParameter_$reflection, ProtocolParameter__get_NameText } from "./ProtocolParameter.js";
+import { record_type, option_type } from "../../../fable_modules/fable-library.4.1.4/Reflection.js";
+import { Value_$reflection } from "./Value.js";
+import { OntologyAnnotation_$reflection } from "./OntologyAnnotation.js";
+import { int32ToString } from "../../../fable_modules/fable-library.4.1.4/Util.js";
+import { printf, toText } from "../../../fable_modules/fable-library.4.1.4/String.js";
+
+export class ProcessParameterValue extends Record {
+    constructor(Category, Value, Unit) {
+        super();
+        this.Category = Category;
+        this.Value = Value;
+        this.Unit = Unit;
+    }
+    Print() {
+        const this$ = this;
+        return toString(this$);
+    }
+    PrintCompact() {
+        let value_2, category_2, category_1, value_1;
+        const this$ = this;
+        const category = map(ProtocolParameter__get_NameText, this$.Category);
+        const unit = map((oa) => oa.NameText, this$.Unit);
+        const value = map((v) => {
+            const s = v.PrintCompact();
+            if (unit == null) {
+                return s;
+            }
+            else {
+                return (s + " ") + unit;
+            }
+        }, this$.Value);
+        return (category == null) ? ((value == null) ? "" : ((value_2 = value, value_2))) : ((value == null) ? ((category_2 = category, (category_2 + ":") + "No Value")) : ((category_1 = category, (value_1 = value, (category_1 + ":") + value_1))));
+    }
+}
+
+export function ProcessParameterValue_$reflection() {
+    return record_type("ARCtrl.ISA.ProcessParameterValue", [], ProcessParameterValue, () => [["Category", option_type(ProtocolParameter_$reflection())], ["Value", option_type(Value_$reflection())], ["Unit", option_type(OntologyAnnotation_$reflection())]]);
+}
+
+export function ProcessParameterValue_make(category, value, unit) {
+    return new ProcessParameterValue(category, value, unit);
+}
+
+export function ProcessParameterValue_create_569825F3(Category, Value, Unit) {
+    return ProcessParameterValue_make(Category, Value, Unit);
+}
+
+export function ProcessParameterValue_get_empty() {
+    return ProcessParameterValue_create_569825F3();
+}
+
+/**
+ * Returns the name of the category as string
+ */
+export function ProcessParameterValue__get_NameText(this$) {
+    return defaultArg(map(ProtocolParameter__get_NameText, this$.Category), "");
+}
+
+/**
+ * Returns the name of the category as string
+ */
+export function ProcessParameterValue__get_TryNameText(this$) {
+    return bind(ProtocolParameter__get_TryNameText, this$.Category);
+}
+
+export function ProcessParameterValue__get_ValueText(this$) {
+    return defaultArg(map((oa) => {
+        switch (oa.tag) {
+            case 2:
+                return oa.fields[0].toString();
+            case 1:
+                return int32ToString(oa.fields[0]);
+            case 3:
+                return oa.fields[0];
+            default:
+                return oa.fields[0].NameText;
+        }
+    }, this$.Value), "");
+}
+
+export function ProcessParameterValue__get_ValueWithUnitText(this$) {
+    const unit = map((oa) => oa.NameText, this$.Unit);
+    const v = ProcessParameterValue__get_ValueText(this$);
+    if (unit == null) {
+        return v;
+    }
+    else {
+        const u = unit;
+        return toText(printf("%s %s"))(v)(u);
+    }
+}
+
+export function ProcessParameterValue__MapCategory_Z69DD836A(this$, f) {
+    return new ProcessParameterValue(map((p) => ProtocolParameter__MapCategory_Z69DD836A(p, f), this$.Category), this$.Value, this$.Unit);
+}
+
+export function ProcessParameterValue__SetCategory_Z4C0FE73C(this$, c) {
+    let matchValue;
+    return new ProcessParameterValue((matchValue = this$.Category, (matchValue == null) ? ProtocolParameter_create_Z6C54B221(void 0, c) : ProtocolParameter__SetCategory_Z4C0FE73C(matchValue, c)), this$.Value, this$.Unit);
+}
+
+/**
+ * Returns the name of the paramater value as string if it exists
+ */
+export function ProcessParameterValue_tryGetNameText_5FD7232D(pv) {
+    return ProcessParameterValue__get_TryNameText(pv);
+}
+
+/**
+ * Returns the name of the paramater value as string
+ */
+export function ProcessParameterValue_getNameText_5FD7232D(pv) {
+    return ProcessParameterValue__get_NameText(pv);
+}
+
+/**
+ * Returns true if the given name matches the name of the parameter value
+ */
+export function ProcessParameterValue_nameEqualsString(name, pv) {
+    return ProcessParameterValue__get_NameText(pv) === name;
+}
+
+export function ProcessParameterValue_getCategory_5FD7232D(pv) {
+    return pv.Category;
+}
+

package/ISA/ISA/JsonTypes/ProcessSequence.js

@@ -0,0 +1,255 @@
+import { List_groupBy, List_distinct } from "../../../fable_modules/fable-library.4.1.4/Seq2.js";
+import { singleton, zip, map, empty, collect, concat, filter, choose } from "../../../fable_modules/fable-library.4.1.4/List.js";
+import { value as value_3, defaultArg, bind } from "../../../fable_modules/fable-library.4.1.4/Option.js";
+import { arrayHash, equalArrays, comparePrimitives, safeHash, equals, stringHash } from "../../../fable_modules/fable-library.4.1.4/Util.js";
+import { Process_updateProtocol, Process_getMaterials_716E708F, Process_getSamples_716E708F, Process_getSources_716E708F, Process_getData_716E708F, Process_getUnits_716E708F, Process_getFactors_716E708F, Process_tryGetOutputsWithFactorBy, Process_tryGetOutputsWithCharacteristicBy, Process_tryGetInputsWithCharacteristicBy, Process_getCharacteristics_716E708F, Process_getParameters_716E708F, Process_tryGetOutputsWithParameterBy, Process_tryGetInputsWithParameterBy } from "./Process.js";
+import { FSharpSet__Contains, ofList } from "../../../fable_modules/fable-library.4.1.4/Set.js";
+import { ProcessOutput__get_Name, ProcessOutput_getName_11830B70 } from "./ProcessOutput.js";
+import { ProcessInput__get_Name, ProcessInput_getName_102B6859 } from "./ProcessInput.js";
+import { FSharpMap__TryFind, ofList as ofList_1 } from "../../../fable_modules/fable-library.4.1.4/Map.js";
+
+/**
+ * Returns the names of the protocols the given processes impelement
+ */
+export function getProtocolNames(processSequence) {
+    return List_distinct(choose((p) => bind((protocol) => protocol.Name, p.ExecutesProtocol), processSequence), {
+        Equals: (x, y) => (x === y),
+        GetHashCode: stringHash,
+    });
+}
+
+/**
+ * Returns the protocols the given processes impelement
+ */
+export function getProtocols(processSequence) {
+    return List_distinct(choose((p) => p.ExecutesProtocol, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+/**
+ * Returns a list of the processes, containing only the ones executing a protocol for which the predicate returns true
+ */
+export function filterByProtocolBy(predicate, processSequence) {
+    return filter((p) => {
+        const matchValue = p.ExecutesProtocol;
+        let matchResult, protocol_1;
+        if (matchValue != null) {
+            if (predicate(matchValue)) {
+                matchResult = 0;
+                protocol_1 = matchValue;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return true;
+            default:
+                return false;
+        }
+    }, processSequence);
+}
+
+/**
+ * Returns a list of the processes, containing only the ones executing a protocol with the given name
+ */
+export function filterByProtocolName(protocolName, processSequence) {
+    return filterByProtocolBy((p) => equals(p.Name, protocolName), processSequence);
+}
+
+/**
+ * If the processes contain a process implementing the given parameter, return the list of input files together with their according parameter values of this parameter
+ */
+export function getInputsWithParameterBy(predicate, processSequence) {
+    return concat(choose((arg_1) => Process_tryGetInputsWithParameterBy(predicate, arg_1), processSequence));
+}
+
+/**
+ * If the processes contain a process implementing the given parameter, return the list of output files together with their according parameter values of this parameter
+ */
+export function getOutputsWithParameterBy(predicate, processSequence) {
+    return concat(choose((arg_1) => Process_tryGetOutputsWithParameterBy(predicate, arg_1), processSequence));
+}
+
+/**
+ * Returns the parameters implemented by the processes contained in these processes
+ */
+export function getParameters(processSequence) {
+    return List_distinct(collect(Process_getParameters_716E708F, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+/**
+ * Returns the characteristics describing the inputs and outputs of the processssequence
+ */
+export function getCharacteristics(processSequence) {
+    return List_distinct(collect(Process_getCharacteristics_716E708F, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+/**
+ * If the processes contain a process implementing the given parameter, return the list of input files together with their according parameter values of this parameter
+ */
+export function getInputsWithCharacteristicBy(predicate, processSequence) {
+    return concat(choose((arg_1) => Process_tryGetInputsWithCharacteristicBy(predicate, arg_1), processSequence));
+}
+
+/**
+ * If the processes contain a process implementing the given parameter, return the list of output files together with their according parameter values of this parameter
+ */
+export function getOutputsWithCharacteristicBy(predicate, processSequence) {
+    return concat(choose((arg_1) => Process_tryGetOutputsWithCharacteristicBy(predicate, arg_1), processSequence));
+}
+
+/**
+ * If the processes contain a process implementing the given factor, return the list of output files together with their according factor values of this factor
+ */
+export function getOutputsWithFactorBy(predicate, processSequence) {
+    return concat(choose((arg_1) => Process_tryGetOutputsWithFactorBy(predicate, arg_1), processSequence));
+}
+
+/**
+ * Returns the factors implemented by the processes contained in these processes
+ */
+export function getFactors(processSequence) {
+    return List_distinct(collect(Process_getFactors_716E708F, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+/**
+ * Returns the initial inputs final outputs of the processSequence, to which no processPoints
+ */
+export function getRootInputs(processSequence) {
+    const inputs = collect((p) => defaultArg(p.Inputs, empty()), processSequence);
+    const outputs = ofList(collect((p_1) => map(ProcessOutput_getName_11830B70, defaultArg(p_1.Outputs, empty())), processSequence), {
+        Compare: comparePrimitives,
+    });
+    return filter((i) => !FSharpSet__Contains(outputs, ProcessInput_getName_102B6859(i)), inputs);
+}
+
+/**
+ * Returns the final outputs of the processSequence, which point to no further nodes
+ */
+export function getFinalOutputs(processSequence) {
+    const inputs = ofList(collect((p) => map(ProcessInput_getName_102B6859, defaultArg(p.Inputs, empty())), processSequence), {
+        Compare: comparePrimitives,
+    });
+    return filter((o) => !FSharpSet__Contains(inputs, ProcessOutput_getName_11830B70(o)), collect((p_1) => defaultArg(p_1.Outputs, empty()), processSequence));
+}
+
+/**
+ * Returns the initial inputs final outputs of the processSequence, to which no processPoints
+ */
+export function getRootInputOf(processSequence, sample) {
+    const mappings = ofList_1(map((tupledArg) => [tupledArg[0], map((tuple_1) => tuple_1[1], tupledArg[1])], List_groupBy((tuple) => tuple[0], collect((p) => List_distinct(zip(map(ProcessOutput__get_Name, value_3(p.Outputs)), map(ProcessInput__get_Name, value_3(p.Inputs))), {
+        Equals: equalArrays,
+        GetHashCode: arrayHash,
+    }), processSequence), {
+        Equals: (x_1, y_1) => (x_1 === y_1),
+        GetHashCode: stringHash,
+    })), {
+        Compare: comparePrimitives,
+    });
+    const loop = (lastState_mut, state_mut) => {
+        loop:
+        while (true) {
+            const lastState = lastState_mut, state = state_mut;
+            if (equals(lastState, state)) {
+                return state;
+            }
+            else {
+                lastState_mut = state;
+                state_mut = collect((s) => defaultArg(FSharpMap__TryFind(mappings, s), singleton(s)), state);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(empty(), singleton(sample));
+}
+
+/**
+ * Returns the final outputs of the processSequence, which point to no further nodes
+ */
+export function getFinalOutputsOf(processSequence, sample) {
+    const mappings = ofList_1(map((tupledArg) => [tupledArg[0], map((tuple_1) => tuple_1[1], tupledArg[1])], List_groupBy((tuple) => tuple[0], collect((p) => List_distinct(zip(map(ProcessInput__get_Name, value_3(p.Inputs)), map(ProcessOutput__get_Name, value_3(p.Outputs))), {
+        Equals: equalArrays,
+        GetHashCode: arrayHash,
+    }), processSequence), {
+        Equals: (x_1, y_1) => (x_1 === y_1),
+        GetHashCode: stringHash,
+    })), {
+        Compare: comparePrimitives,
+    });
+    const loop = (lastState_mut, state_mut) => {
+        loop:
+        while (true) {
+            const lastState = lastState_mut, state = state_mut;
+            if (equals(lastState, state)) {
+                return state;
+            }
+            else {
+                lastState_mut = state;
+                state_mut = collect((s) => defaultArg(FSharpMap__TryFind(mappings, s), singleton(s)), state);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(empty(), singleton(sample));
+}
+
+export function getUnits(processSequence) {
+    return List_distinct(collect(Process_getUnits_716E708F, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+/**
+ * Returns the data the given processes contain
+ */
+export function getData(processSequence) {
+    return List_distinct(collect(Process_getData_716E708F, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+export function getSources(processSequence) {
+    return List_distinct(collect(Process_getSources_716E708F, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+export function getSamples(processSequence) {
+    return List_distinct(collect(Process_getSamples_716E708F, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+export function getMaterials(processSequence) {
+    return List_distinct(collect(Process_getMaterials_716E708F, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+
+export function updateProtocols(protocols, processSequence) {
+    return map((arg_1) => Process_updateProtocol(protocols, arg_1), processSequence);
+}
+