arctrl 3.0.0__py3-none-any.whl

arctrl/py/Json/Process/factor.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.list import (choose, of_array, FSharpList)
+from ...fable_modules.fable_library.option import (map, default_arg)
+from ...fable_modules.fable_library.seq import map as map_1
+from ...fable_modules.fable_library.types import Array
+from ...fable_modules.fable_library.util import IEnumerable_1
+from ...fable_modules.thoth_json_core.decode import (object, IOptionalGetter, string, resize_array, IGetters)
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ...Core.comment import Comment
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Process.factor import Factor
+from ..comment import (ISAJson_encoder, ISAJson_decoder)
+from ..encode import (try_include, try_include_seq)
+from ..idtable import encode
+from ..ontology_annotation import (OntologyAnnotation_ROCrate_genID, OntologyAnnotation_ISAJson_encoder, OntologyAnnotation_ISAJson_decoder)
+
+__A_ = TypeVar("__A_")
+
+def gen_id(f: Factor) -> str:
+    match_value: str | None = f.Name
+    if match_value is None:
+        match_value_1: OntologyAnnotation | None = f.FactorType
+        if match_value_1 is None:
+            return "#EmptyFactor"
+
+        else: 
+            return ("#Factor/" + OntologyAnnotation_ROCrate_genID(match_value_1)) + ""
+
+
+    else: 
+        return ("#Factor/" + match_value) + ""
+
+
+
+def encoder(id_map: Any | None, value: Factor) -> IEncodable:
+    def f_1(value_1: Factor, id_map: Any=id_map, value: Any=value) -> IEncodable:
+        def chooser(tupled_arg: tuple[str, IEncodable | None], value_1: Any=value_1) -> tuple[str, IEncodable] | None:
+            def mapping(v_1: IEncodable, tupled_arg: Any=tupled_arg) -> tuple[str, IEncodable]:
+                return (tupled_arg[0], v_1)
+
+            return map(mapping, tupled_arg[1])
+
+        def _arrow2960(value_2: str, value_1: Any=value_1) -> IEncodable:
+            class ObjectExpr2959(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value_2)
+
+            return ObjectExpr2959()
+
+        def _arrow2964(value_4: str, value_1: Any=value_1) -> IEncodable:
+            class ObjectExpr2963(IEncodable):
+                def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers_1.encode_string(value_4)
+
+            return ObjectExpr2963()
+
+        def _arrow2965(oa: OntologyAnnotation, value_1: Any=value_1) -> IEncodable:
+            return OntologyAnnotation_ISAJson_encoder(id_map, oa)
+
+        def _arrow2968(comment: Comment, value_1: Any=value_1) -> IEncodable:
+            return ISAJson_encoder(id_map, comment)
+
+        values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("@id", _arrow2960, gen_id(value_1)), try_include("factorName", _arrow2964, value_1.Name), try_include("factorType", _arrow2965, value_1.FactorType), try_include_seq("comments", _arrow2968, default_arg(value_1.Comments, []))]))
+        class ObjectExpr2971(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any], value_1: Any=value_1) -> Any:
+                def mapping_1(tupled_arg_1: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                    return (tupled_arg_1[0], tupled_arg_1[1].Encode(helpers_2))
+
+                arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+                return helpers_2.encode_object(arg)
+
+        return ObjectExpr2971()
+
+    if id_map is not None:
+        def _arrow2975(f_2: Factor, id_map: Any=id_map, value: Any=value) -> str:
+            return gen_id(f_2)
+
+        return encode(_arrow2975, f_1, value, id_map)
+
+    else: 
+        return f_1(value)
+
+
+
+def _arrow2983(get: IGetters) -> Factor:
+    def _arrow2978(__unit: None=None) -> str | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("factorName", string)
+
+    def _arrow2979(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("factorType", OntologyAnnotation_ISAJson_decoder)
+
+    def _arrow2982(__unit: None=None) -> Array[Comment] | None:
+        arg_5: Decoder_1[Array[Comment]] = resize_array(ISAJson_decoder)
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("comments", arg_5)
+
+    return Factor(_arrow2978(), _arrow2979(), _arrow2982())
+
+
+decoder: Decoder_1[Factor] = object(_arrow2983)
+
+__all__ = ["gen_id", "encoder", "decoder"]
+

arctrl/py/Json/Process/factor_value.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.list import (choose, of_array, FSharpList)
+from ...fable_modules.fable_library.option import map
+from ...fable_modules.fable_library.seq import map as map_1
+from ...fable_modules.fable_library.util import IEnumerable_1
+from ...fable_modules.thoth_json_core.decode import (object, IOptionalGetter, IGetters)
+from ...fable_modules.thoth_json_core.types import (IEncodable, Decoder_1, IEncoderHelpers_1)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Process.factor import Factor
+from ...Core.Process.factor_value import (FactorValue, FactorValue_createAsPV)
+from ...Core.value import Value as Value_1
+from ..decode import Decode_uri
+from ..encode import try_include
+from ..idtable import encode
+from ..ontology_annotation import (OntologyAnnotation_ISAJson_encoder, OntologyAnnotation_ISAJson_decoder)
+from ..property_value import (encoder, decoder, gen_id)
+from .factor import (encoder as encoder_1, decoder as decoder_1)
+from .value import (encoder as encoder_2, decoder as decoder_2)
+
+__A_ = TypeVar("__A_")
+
+ROCrate_encoder: Callable[[FactorValue], IEncodable] = encoder
+
+ROCrate_decoder: Decoder_1[FactorValue] = decoder(FactorValue_createAsPV)
+
+def ISAJson_genID(fv: FactorValue) -> str:
+    return gen_id(fv)
+
+
+def ISAJson_encoder(id_map: Any | None, fv: FactorValue) -> IEncodable:
+    def f(fv_1: FactorValue, id_map: Any=id_map, fv: Any=fv) -> IEncodable:
+        def chooser(tupled_arg: tuple[str, IEncodable | None], fv_1: Any=fv_1) -> tuple[str, IEncodable] | None:
+            def mapping(v_1: IEncodable, tupled_arg: Any=tupled_arg) -> tuple[str, IEncodable]:
+                return (tupled_arg[0], v_1)
+
+            return map(mapping, tupled_arg[1])
+
+        def _arrow3061(value: str, fv_1: Any=fv_1) -> IEncodable:
+            class ObjectExpr3059(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value)
+
+            return ObjectExpr3059()
+
+        def _arrow3062(value_2: Factor, fv_1: Any=fv_1) -> IEncodable:
+            return encoder_1(id_map, value_2)
+
+        def _arrow3063(value_3: Value_1, fv_1: Any=fv_1) -> IEncodable:
+            return encoder_2(id_map, value_3)
+
+        def _arrow3065(oa: OntologyAnnotation, fv_1: Any=fv_1) -> IEncodable:
+            return OntologyAnnotation_ISAJson_encoder(id_map, oa)
+
+        values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("@id", _arrow3061, ISAJson_genID(fv_1)), try_include("category", _arrow3062, fv_1.Category), try_include("value", _arrow3063, fv_1.Value), try_include("unit", _arrow3065, fv_1.Unit)]))
+        class ObjectExpr3068(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any], fv_1: Any=fv_1) -> Any:
+                def mapping_1(tupled_arg_1: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                    return (tupled_arg_1[0], tupled_arg_1[1].Encode(helpers_1))
+
+                arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+                return helpers_1.encode_object(arg)
+
+        return ObjectExpr3068()
+
+    if id_map is not None:
+        def _arrow3070(fv_3: FactorValue, id_map: Any=id_map, fv: Any=fv) -> str:
+            return ISAJson_genID(fv_3)
+
+        return encode(_arrow3070, f, fv, id_map)
+
+    else: 
+        return f(fv)
+
+
+
+def _arrow3076(get: IGetters) -> FactorValue:
+    def _arrow3071(__unit: None=None) -> str | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("@id", Decode_uri)
+
+    def _arrow3072(__unit: None=None) -> Factor | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("category", decoder_1)
+
+    def _arrow3074(__unit: None=None) -> Value_1 | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("value", decoder_2)
+
+    def _arrow3075(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_3: IOptionalGetter = get.Optional
+        return object_arg_3.Field("unit", OntologyAnnotation_ISAJson_decoder)
+
+    return FactorValue(_arrow3071(), _arrow3072(), _arrow3074(), _arrow3075())
+
+
+ISAJson_decoder: Decoder_1[FactorValue] = object(_arrow3076)
+
+__all__ = ["ROCrate_encoder", "ROCrate_decoder", "ISAJson_genID", "ISAJson_encoder", "ISAJson_decoder"]
+

arctrl/py/Json/Process/material.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.list import (choose, singleton, of_array, FSharpList)
+from ...fable_modules.fable_library.option import map
+from ...fable_modules.fable_library.seq import map as map_1
+from ...fable_modules.fable_library.string_ import replace
+from ...fable_modules.fable_library.util import IEnumerable_1
+from ...fable_modules.thoth_json_core.decode import (object, IOptionalGetter, IRequiredGetter, unit, string, list_1 as list_1_2, IGetters)
+from ...fable_modules.thoth_json_core.encode import list_1 as list_1_1
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ...Core.Process.material import Material
+from ...Core.Process.material_attribute_value import MaterialAttributeValue
+from ...Core.Process.material_type import MaterialType
+from ..context.rocrate.isa_material_context import context_jsonvalue
+from ..decode import (Decode_uri, Decode_objectNoAdditionalProperties)
+from ..encode import (try_include, try_include_list_opt)
+from ..idtable import encode
+from .material_attribute_value import (ROCrate_encoder as ROCrate_encoder_2, ROCrate_decoder as ROCrate_decoder_2, ISAJson_encoder as ISAJson_encoder_2, ISAJson_decoder as ISAJson_decoder_2)
+from .material_type import (ROCrate_encoder as ROCrate_encoder_1, ROCrate_decoder as ROCrate_decoder_1, ISAJson_encoder as ISAJson_encoder_1, ISAJson_decoder as ISAJson_decoder_1)
+
+__A_ = TypeVar("__A_")
+
+def ROCrate_genID(m: Material) -> str:
+    match_value: str | None = m.ID
+    if match_value is None:
+        match_value_1: str | None = m.Name
+        if match_value_1 is None:
+            return "#EmptyMaterial"
+
+        else: 
+            return "#Material_" + replace(match_value_1, " ", "_")
+
+
+    else: 
+        return match_value
+
+
+
+def ROCrate_encoder(oa: Material) -> IEncodable:
+    def chooser(tupled_arg: tuple[str, IEncodable | None], oa: Any=oa) -> tuple[str, IEncodable] | None:
+        def mapping(v_1: IEncodable, tupled_arg: Any=tupled_arg) -> tuple[str, IEncodable]:
+            return (tupled_arg[0], v_1)
+
+        return map(mapping, tupled_arg[1])
+
+    def _arrow3224(__unit: None=None, oa: Any=oa) -> IEncodable:
+        value: str = ROCrate_genID(oa)
+        class ObjectExpr3223(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr3223()
+
+    class ObjectExpr3225(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], oa: Any=oa) -> Any:
+            return helpers_1.encode_string("Material")
+
+    class ObjectExpr3226(IEncodable):
+        def Encode(self, helpers_2: IEncoderHelpers_1[Any], oa: Any=oa) -> Any:
+            return helpers_2.encode_string("Material")
+
+    def _arrow3228(value_3: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr3227(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_3.encode_string(value_3)
+
+        return ObjectExpr3227()
+
+    def _arrow3229(value_5: MaterialType, oa: Any=oa) -> IEncodable:
+        return ROCrate_encoder_1(value_5)
+
+    def _arrow3230(oa_1: Material, oa: Any=oa) -> IEncodable:
+        return ROCrate_encoder(oa_1)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([("@id", _arrow3224()), ("@type", list_1_1(singleton(ObjectExpr3225()))), ("additionalType", ObjectExpr3226()), try_include("name", _arrow3228, oa.Name), try_include("type", _arrow3229, oa.MaterialType), try_include_list_opt("characteristics", ROCrate_encoder_2, oa.Characteristics), try_include_list_opt("derivesFrom", _arrow3230, oa.DerivesFrom), ("@context", context_jsonvalue)]))
+    class ObjectExpr3231(IEncodable):
+        def Encode(self, helpers_4: IEncoderHelpers_1[Any], oa: Any=oa) -> Any:
+            def mapping_1(tupled_arg_1: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg_1[0], tupled_arg_1[1].Encode(helpers_4))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+            return helpers_4.encode_object(arg)
+
+    return ObjectExpr3231()
+
+
+def _arrow3238(__unit: None=None) -> Decoder_1[Material]:
+    def decode(__unit: None=None) -> Decoder_1[Material]:
+        def _arrow3237(get: IGetters) -> Material:
+            match_value: str | None
+            object_arg: IOptionalGetter = get.Optional
+            match_value = object_arg.Field("additionalType", Decode_uri)
+            (pattern_matching_result,) = (None,)
+            if match_value is None:
+                pattern_matching_result = 0
+
+            elif match_value == "Material":
+                pattern_matching_result = 0
+
+            else: 
+                pattern_matching_result = 1
+
+            if pattern_matching_result == 1:
+                object_arg_1: IRequiredGetter = get.Required
+                object_arg_1.Field("FailBecauseNotSample", unit)
+
+            def _arrow3232(__unit: None=None) -> str | None:
+                object_arg_2: IOptionalGetter = get.Optional
+                return object_arg_2.Field("@id", Decode_uri)
+
+            def _arrow3233(__unit: None=None) -> str | None:
+                object_arg_3: IOptionalGetter = get.Optional
+                return object_arg_3.Field("name", string)
+
+            def _arrow3234(__unit: None=None) -> MaterialType | None:
+                object_arg_4: IOptionalGetter = get.Optional
+                return object_arg_4.Field("type", ROCrate_decoder_1)
+
+            def _arrow3235(__unit: None=None) -> FSharpList[MaterialAttributeValue] | None:
+                arg_11: Decoder_1[FSharpList[MaterialAttributeValue]] = list_1_2(ROCrate_decoder_2)
+                object_arg_5: IOptionalGetter = get.Optional
+                return object_arg_5.Field("characteristics", arg_11)
+
+            def _arrow3236(__unit: None=None) -> FSharpList[Material] | None:
+                arg_13: Decoder_1[FSharpList[Material]] = list_1_2(decode(None))
+                object_arg_6: IOptionalGetter = get.Optional
+                return object_arg_6.Field("derivesFrom", arg_13)
+
+            return Material(_arrow3232(), _arrow3233(), _arrow3234(), _arrow3235(), _arrow3236())
+
+        return object(_arrow3237)
+
+    return decode(None)
+
+
+ROCrate_decoder: Decoder_1[Material] = _arrow3238()
+
+def ISAJson_encoder(id_map: Any | None, c: Material) -> IEncodable:
+    def f(oa: Material, id_map: Any=id_map, c: Any=c) -> IEncodable:
+        def chooser(tupled_arg: tuple[str, IEncodable | None], oa: Any=oa) -> tuple[str, IEncodable] | None:
+            def mapping(v_1: IEncodable, tupled_arg: Any=tupled_arg) -> tuple[str, IEncodable]:
+                return (tupled_arg[0], v_1)
+
+            return map(mapping, tupled_arg[1])
+
+        def _arrow3242(value: str, oa: Any=oa) -> IEncodable:
+            class ObjectExpr3241(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value)
+
+            return ObjectExpr3241()
+
+        def _arrow3244(value_2: str, oa: Any=oa) -> IEncodable:
+            class ObjectExpr3243(IEncodable):
+                def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers_1.encode_string(value_2)
+
+            return ObjectExpr3243()
+
+        def _arrow3245(oa_1: MaterialAttributeValue, oa: Any=oa) -> IEncodable:
+            return ISAJson_encoder_2(id_map, oa_1)
+
+        def _arrow3246(c_1: Material, oa: Any=oa) -> IEncodable:
+            return ISAJson_encoder(id_map, c_1)
+
+        values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("@id", _arrow3242, ROCrate_genID(oa)), try_include("name", _arrow3244, oa.Name), try_include("type", ISAJson_encoder_1, oa.MaterialType), try_include_list_opt("characteristics", _arrow3245, oa.Characteristics), try_include_list_opt("derivesFrom", _arrow3246, oa.DerivesFrom)]))
+        class ObjectExpr3247(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any], oa: Any=oa) -> Any:
+                def mapping_1(tupled_arg_1: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                    return (tupled_arg_1[0], tupled_arg_1[1].Encode(helpers_2))
+
+                arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+                return helpers_2.encode_object(arg)
+
+        return ObjectExpr3247()
+
+    if id_map is not None:
+        def _arrow3248(m_1: Material, id_map: Any=id_map, c: Any=c) -> str:
+            return ROCrate_genID(m_1)
+
+        return encode(_arrow3248, f, c, id_map)
+
+    else: 
+        return f(c)
+
+
+
+ISAJson_allowedFields: FSharpList[str] = of_array(["@id", "@type", "name", "type", "characteristics", "derivesFrom", "@context"])
+
+def _arrow3255(__unit: None=None) -> Decoder_1[Material]:
+    def decode(__unit: None=None) -> Decoder_1[Material]:
+        def _arrow3254(get: IGetters) -> Material:
+            def _arrow3249(__unit: None=None) -> str | None:
+                object_arg: IOptionalGetter = get.Optional
+                return object_arg.Field("@id", Decode_uri)
+
+            def _arrow3250(__unit: None=None) -> str | None:
+                object_arg_1: IOptionalGetter = get.Optional
+                return object_arg_1.Field("name", string)
+
+            def _arrow3251(__unit: None=None) -> MaterialType | None:
+                object_arg_2: IOptionalGetter = get.Optional
+                return object_arg_2.Field("type", ISAJson_decoder_1)
+
+            def _arrow3252(__unit: None=None) -> FSharpList[MaterialAttributeValue] | None:
+                arg_7: Decoder_1[FSharpList[MaterialAttributeValue]] = list_1_2(ISAJson_decoder_2)
+                object_arg_3: IOptionalGetter = get.Optional
+                return object_arg_3.Field("characteristics", arg_7)
+
+            def _arrow3253(__unit: None=None) -> FSharpList[Material] | None:
+                arg_9: Decoder_1[FSharpList[Material]] = list_1_2(decode(None))
+                object_arg_4: IOptionalGetter = get.Optional
+                return object_arg_4.Field("derivesFrom", arg_9)
+
+            return Material(_arrow3249(), _arrow3250(), _arrow3251(), _arrow3252(), _arrow3253())
+
+        return Decode_objectNoAdditionalProperties(ISAJson_allowedFields, _arrow3254)
+
+    return decode(None)
+
+
+ISAJson_decoder: Decoder_1[Material] = _arrow3255()
+
+__all__ = ["ROCrate_genID", "ROCrate_encoder", "ROCrate_decoder", "ISAJson_encoder", "ISAJson_allowedFields", "ISAJson_decoder"]
+

arctrl/py/Json/Process/material_attribute.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.list import (choose, of_array, FSharpList)
+from ...fable_modules.fable_library.option import map
+from ...fable_modules.fable_library.seq import map as map_1
+from ...fable_modules.fable_library.util import IEnumerable_1
+from ...fable_modules.thoth_json_core.decode import (object, IOptionalGetter, IGetters)
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Process.material_attribute import MaterialAttribute
+from ..encode import try_include
+from ..idtable import encode
+from ..ontology_annotation import (OntologyAnnotation_ROCrate_genID, OntologyAnnotation_ISAJson_encoder, OntologyAnnotation_ISAJson_decoder)
+
+__A_ = TypeVar("__A_")
+
+def gen_id(m: MaterialAttribute) -> str:
+    match_value: OntologyAnnotation | None = m.CharacteristicType
+    if match_value is None:
+        return "#EmptyFactor"
+
+    else: 
+        return ("#MaterialAttribute/" + OntologyAnnotation_ROCrate_genID(match_value)) + ""
+
+
+
+def encoder(id_map: Any | None, value: MaterialAttribute) -> IEncodable:
+    def f(value_1: MaterialAttribute, id_map: Any=id_map, value: Any=value) -> IEncodable:
+        def chooser(tupled_arg: tuple[str, IEncodable | None], value_1: Any=value_1) -> tuple[str, IEncodable] | None:
+            def mapping(v_1: IEncodable, tupled_arg: Any=tupled_arg) -> tuple[str, IEncodable]:
+                return (tupled_arg[0], v_1)
+
+            return map(mapping, tupled_arg[1])
+
+        def _arrow3129(value_2: str, value_1: Any=value_1) -> IEncodable:
+            class ObjectExpr3128(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value_2)
+
+            return ObjectExpr3128()
+
+        def _arrow3130(oa: OntologyAnnotation, value_1: Any=value_1) -> IEncodable:
+            return OntologyAnnotation_ISAJson_encoder(id_map, oa)
+
+        values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("@id", _arrow3129, gen_id(value_1)), try_include("characteristicType", _arrow3130, value_1.CharacteristicType)]))
+        class ObjectExpr3131(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any], value_1: Any=value_1) -> Any:
+                def mapping_1(tupled_arg_1: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                    return (tupled_arg_1[0], tupled_arg_1[1].Encode(helpers_1))
+
+                arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+                return helpers_1.encode_object(arg)
+
+        return ObjectExpr3131()
+
+    if id_map is not None:
+        def _arrow3132(m_1: MaterialAttribute, id_map: Any=id_map, value: Any=value) -> str:
+            return gen_id(m_1)
+
+        return encode(_arrow3132, f, value, id_map)
+
+    else: 
+        return f(value)
+
+
+
+def _arrow3134(get: IGetters) -> MaterialAttribute:
+    def _arrow3133(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("characteristicType", OntologyAnnotation_ISAJson_decoder)
+
+    return MaterialAttribute(None, _arrow3133())
+
+
+decoder: Decoder_1[MaterialAttribute] = object(_arrow3134)
+
+__all__ = ["gen_id", "encoder", "decoder"]
+

arctrl/py/Json/Process/material_attribute_value.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.list import (choose, of_array, FSharpList)
+from ...fable_modules.fable_library.option import map
+from ...fable_modules.fable_library.seq import map as map_1
+from ...fable_modules.fable_library.util import IEnumerable_1
+from ...fable_modules.thoth_json_core.decode import (object, IOptionalGetter, IGetters)
+from ...fable_modules.thoth_json_core.types import (IEncodable, Decoder_1, IEncoderHelpers_1)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Process.material_attribute import MaterialAttribute
+from ...Core.Process.material_attribute_value import (MaterialAttributeValue, MaterialAttributeValue_createAsPV)
+from ...Core.value import Value as Value_1
+from ..decode import Decode_uri
+from ..encode import try_include
+from ..idtable import encode
+from ..ontology_annotation import (OntologyAnnotation_ISAJson_encoder, OntologyAnnotation_ISAJson_decoder)
+from ..property_value import (encoder, decoder, gen_id)
+from .material_attribute import (encoder as encoder_1, decoder as decoder_1)
+from .value import (encoder as encoder_2, decoder as decoder_2)
+
+__A_ = TypeVar("__A_")
+
+ROCrate_encoder: Callable[[MaterialAttributeValue], IEncodable] = encoder
+
+ROCrate_decoder: Decoder_1[MaterialAttributeValue] = decoder(MaterialAttributeValue_createAsPV)
+
+def ISAJson_genID(oa: MaterialAttributeValue) -> str:
+    return gen_id(oa)
+
+
+def ISAJson_encoder(id_map: Any | None, oa: MaterialAttributeValue) -> IEncodable:
+    def f(oa_1: MaterialAttributeValue, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        def chooser(tupled_arg: tuple[str, IEncodable | None], oa_1: Any=oa_1) -> tuple[str, IEncodable] | None:
+            def mapping(v_1: IEncodable, tupled_arg: Any=tupled_arg) -> tuple[str, IEncodable]:
+                return (tupled_arg[0], v_1)
+
+            return map(mapping, tupled_arg[1])
+
+        def _arrow3154(value: str, oa_1: Any=oa_1) -> IEncodable:
+            class ObjectExpr3153(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value)
+
+            return ObjectExpr3153()
+
+        def _arrow3155(value_2: MaterialAttribute, oa_1: Any=oa_1) -> IEncodable:
+            return encoder_1(id_map, value_2)
+
+        def _arrow3156(value_3: Value_1, oa_1: Any=oa_1) -> IEncodable:
+            return encoder_2(id_map, value_3)
+
+        def _arrow3157(oa_3: OntologyAnnotation, oa_1: Any=oa_1) -> IEncodable:
+            return OntologyAnnotation_ISAJson_encoder(id_map, oa_3)
+
+        values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("@id", _arrow3154, ISAJson_genID(oa_1)), try_include("category", _arrow3155, oa_1.Category), try_include("value", _arrow3156, oa_1.Value), try_include("unit", _arrow3157, oa_1.Unit)]))
+        class ObjectExpr3158(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any], oa_1: Any=oa_1) -> Any:
+                def mapping_1(tupled_arg_1: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                    return (tupled_arg_1[0], tupled_arg_1[1].Encode(helpers_1))
+
+                arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+                return helpers_1.encode_object(arg)
+
+        return ObjectExpr3158()
+
+    if id_map is not None:
+        def _arrow3159(oa_4: MaterialAttributeValue, id_map: Any=id_map, oa: Any=oa) -> str:
+            return ISAJson_genID(oa_4)
+
+        return encode(_arrow3159, f, oa, id_map)
+
+    else: 
+        return f(oa)
+
+
+
+def _arrow3164(get: IGetters) -> MaterialAttributeValue:
+    def _arrow3160(__unit: None=None) -> str | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("@id", Decode_uri)
+
+    def _arrow3161(__unit: None=None) -> MaterialAttribute | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("category", decoder_1)
+
+    def _arrow3162(__unit: None=None) -> Value_1 | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("value", decoder_2)
+
+    def _arrow3163(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_3: IOptionalGetter = get.Optional
+        return object_arg_3.Field("unit", OntologyAnnotation_ISAJson_decoder)
+
+    return MaterialAttributeValue(_arrow3160(), _arrow3161(), _arrow3162(), _arrow3163())
+
+
+ISAJson_decoder: Decoder_1[MaterialAttributeValue] = object(_arrow3164)
+
+__all__ = ["ROCrate_encoder", "ROCrate_decoder", "ISAJson_genID", "ISAJson_encoder", "ISAJson_decoder"]
+

arctrl/py/Json/Process/material_type.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.result import FSharpResult_2
+from ...fable_modules.thoth_json_core.decode import string
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1, ErrorReason_1, IDecoderHelpers_1)
+from ...Core.Process.material_type import MaterialType
+
+__A_ = TypeVar("__A_")
+
+def ROCrate_encoder(value: MaterialType) -> IEncodable:
+    if value.tag == 1:
+        class ObjectExpr3123(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_1.encode_string("Labeled Extract Name")
+
+        return ObjectExpr3123()
+
+    else: 
+        class ObjectExpr3124(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers.encode_string("Extract Name")
+
+        return ObjectExpr3124()
+
+
+
+class ObjectExpr3125(Decoder_1[MaterialType]):
+    def Decode(self, s: IDecoderHelpers_1[Any], json: Any) -> FSharpResult_2[MaterialType, tuple[str, ErrorReason_1[__A_]]]:
+        match_value: FSharpResult_2[str, tuple[str, ErrorReason_1[__A_]]] = string.Decode(s, json)
+        if match_value.tag == 1:
+            return FSharpResult_2(1, match_value.fields[0])
+
+        elif match_value.fields[0] == "Extract Name":
+            return FSharpResult_2(0, MaterialType(0))
+
+        elif match_value.fields[0] == "Labeled Extract Name":
+            return FSharpResult_2(0, MaterialType(1))
+
+        else: 
+            s_1: str = match_value.fields[0]
+            return FSharpResult_2(1, (("Could not parse " + s_1) + "No other value than \"Extract Name\" or \"Labeled Extract Name\" allowed for materialtype", ErrorReason_1(0, s_1, json)))
+
+
+
+ROCrate_decoder: Decoder_1[MaterialType] = ObjectExpr3125()
+
+ISAJson_encoder: Callable[[MaterialType], IEncodable] = ROCrate_encoder
+
+ISAJson_decoder: Decoder_1[MaterialType] = ROCrate_decoder
+
+__all__ = ["ROCrate_encoder", "ROCrate_decoder", "ISAJson_encoder", "ISAJson_decoder"]
+