arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/Json/property_value.py

@@ -0,0 +1,359 @@
+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, string, IGetters)
+from ..fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ..Core.iproperty_value import IPropertyValue
+from ..Core.ontology_annotation import OntologyAnnotation
+from ..Core.value import Value as Value_4
+from .context.rocrate.property_value_context import context_jsonvalue
+from .encode import try_include
+from .ontology_annotation import AnnotationValue_decoder
+
+__A_ = TypeVar("__A_")
+
+_T = TypeVar("_T")
+
+def gen_id(p: IPropertyValue) -> str:
+    match_value: OntologyAnnotation | None = p.GetCategory()
+    match_value_1: Value_4 | None = p.GetValue()
+    match_value_2: OntologyAnnotation | None = p.GetUnit()
+    (pattern_matching_result, t, u, v, t_1, v_1) = (None, None, None, None, None, None)
+    if match_value is not None:
+        if match_value_1 is not None:
+            if match_value_2 is None:
+                pattern_matching_result = 1
+                t_1 = match_value
+                v_1 = match_value_1
+
+            else: 
+                pattern_matching_result = 0
+                t = match_value
+                u = match_value_2
+                v = match_value_1
+
+
+        else: 
+            pattern_matching_result = 2
+
+
+    else: 
+        pattern_matching_result = 2
+
+    if pattern_matching_result == 0:
+        return ((((((("#" + p.GetAdditionalType()) + "/") + t.NameText) + "=") + v.Text) + "") + u.NameText) + ""
+
+    elif pattern_matching_result == 1:
+        return ((((("#" + p.GetAdditionalType()) + "/") + t_1.NameText) + "=") + v_1.Text) + ""
+
+    elif pattern_matching_result == 2:
+        return ("#Empty" + p.GetAdditionalType()) + ""
+
+
+
+def encoder(pv: IPropertyValue) -> IEncodable:
+    pattern_input: tuple[str | None, str | None]
+    match_value: OntologyAnnotation | None = pv.GetCategory()
+    if match_value is None:
+        pattern_input = (None, None)
+
+    else: 
+        oa: OntologyAnnotation = match_value
+        pattern_input = (oa.Name, oa.TermAccessionNumber)
+
+    pattern_input_1: tuple[IEncodable | None, IEncodable | None]
+    match_value_1: Value_4 | None = pv.GetValue()
+    if match_value_1 is None:
+        pattern_input_1 = (None, None)
+
+    else: 
+        v: Value_4 = match_value_1
+        if v.tag == 1:
+            class ObjectExpr2076(IEncodable):
+                def Encode(self, helpers_1: IEncoderHelpers_1[Any], pv: Any=pv) -> Any:
+                    return helpers_1.encode_signed_integral_number(v.fields[0])
+
+            pattern_input_1 = (ObjectExpr2076(), None)
+
+        elif v.tag == 2:
+            class ObjectExpr2077(IEncodable):
+                def Encode(self, helpers_2: IEncoderHelpers_1[Any], pv: Any=pv) -> Any:
+                    return helpers_2.encode_decimal_number(v.fields[0])
+
+            pattern_input_1 = (ObjectExpr2077(), None)
+
+        elif v.tag == 0:
+            oa_1: OntologyAnnotation = v.fields[0]
+            def _arrow2079(value_3: str, pv: Any=pv) -> IEncodable:
+                class ObjectExpr2078(IEncodable):
+                    def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                        return helpers_3.encode_string(value_3)
+
+                return ObjectExpr2078()
+
+            def _arrow2081(value_5: str, pv: Any=pv) -> IEncodable:
+                class ObjectExpr2080(IEncodable):
+                    def Encode(self, helpers_4: IEncoderHelpers_1[Any]) -> Any:
+                        return helpers_4.encode_string(value_5)
+
+                return ObjectExpr2080()
+
+            pattern_input_1 = (map(_arrow2079, oa_1.Name), map(_arrow2081, oa_1.TermAccessionNumber))
+
+        else: 
+            class ObjectExpr2082(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any], pv: Any=pv) -> Any:
+                    return helpers.encode_string(v.fields[0])
+
+            pattern_input_1 = (ObjectExpr2082(), None)
+
+
+    pattern_input_2: tuple[str | None, str | None]
+    match_value_2: OntologyAnnotation | None = pv.GetUnit()
+    if match_value_2 is None:
+        pattern_input_2 = (None, None)
+
+    else: 
+        oa_2: OntologyAnnotation = match_value_2
+        pattern_input_2 = (oa_2.Name, oa_2.TermAccessionNumber)
+
+    def chooser(tupled_arg: tuple[str, IEncodable | None], pv: Any=pv) -> tuple[str, IEncodable] | None:
+        def mapping(v_1_1: IEncodable, tupled_arg: Any=tupled_arg) -> tuple[str, IEncodable]:
+            return (tupled_arg[0], v_1_1)
+
+        return map(mapping, tupled_arg[1])
+
+    def _arrow2086(__unit: None=None, pv: Any=pv) -> IEncodable:
+        value_8: str = gen_id(pv)
+        class ObjectExpr2085(IEncodable):
+            def Encode(self, helpers_5: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_5.encode_string(value_8)
+
+        return ObjectExpr2085()
+
+    class ObjectExpr2087(IEncodable):
+        def Encode(self, helpers_6: IEncoderHelpers_1[Any], pv: Any=pv) -> Any:
+            return helpers_6.encode_string("PropertyValue")
+
+    def _arrow2089(__unit: None=None, pv: Any=pv) -> IEncodable:
+        value_10: str = pv.GetAdditionalType()
+        class ObjectExpr2088(IEncodable):
+            def Encode(self, helpers_7: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_7.encode_string(value_10)
+
+        return ObjectExpr2088()
+
+    def _arrow2091(value_11: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2090(IEncodable):
+            def Encode(self, helpers_8: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_8.encode_string(value_11)
+
+        return ObjectExpr2090()
+
+    def _arrow2093(value_13: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2092(IEncodable):
+            def Encode(self, helpers_9: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_9.encode_string(value_13)
+
+        return ObjectExpr2092()
+
+    def _arrow2095(value_15: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2094(IEncodable):
+            def Encode(self, helpers_10: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_10.encode_string(value_15)
+
+        return ObjectExpr2094()
+
+    def _arrow2097(value_17: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2096(IEncodable):
+            def Encode(self, helpers_11: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_11.encode_string(value_17)
+
+        return ObjectExpr2096()
+
+    def _arrow2099(value_19: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2098(IEncodable):
+            def Encode(self, helpers_12: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_12.encode_string(value_19)
+
+        return ObjectExpr2098()
+
+    def _arrow2100(x: IEncodable, pv: Any=pv) -> IEncodable:
+        return x
+
+    def _arrow2101(x_1: IEncodable, pv: Any=pv) -> IEncodable:
+        return x_1
+
+    def _arrow2103(value_21: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2102(IEncodable):
+            def Encode(self, helpers_13: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_13.encode_string(value_21)
+
+        return ObjectExpr2102()
+
+    def _arrow2106(value_23: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2105(IEncodable):
+            def Encode(self, helpers_14: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_14.encode_string(value_23)
+
+        return ObjectExpr2105()
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([("@id", _arrow2086()), ("@type", ObjectExpr2087()), ("additionalType", _arrow2089()), try_include("alternateName", _arrow2091, pv.AlternateName()), try_include("measurementMethod", _arrow2093, pv.MeasurementMethod()), try_include("description", _arrow2095, pv.Description()), try_include("category", _arrow2097, pattern_input[0]), try_include("categoryCode", _arrow2099, pattern_input[1]), try_include("value", _arrow2100, pattern_input_1[0]), try_include("valueCode", _arrow2101, pattern_input_1[1]), try_include("unit", _arrow2103, pattern_input_2[0]), try_include("unitCode", _arrow2106, pattern_input_2[1]), ("@context", context_jsonvalue)]))
+    class ObjectExpr2109(IEncodable):
+        def Encode(self, helpers_15: IEncoderHelpers_1[Any], pv: Any=pv) -> Any:
+            def mapping_1(tupled_arg_1: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg_1[0], tupled_arg_1[1].Encode(helpers_15))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+            return helpers_15.encode_object(arg)
+
+    return ObjectExpr2109()
+
+
+def decoder(create: Callable[[str | None, str | None, str | None, OntologyAnnotation | None, Value_4 | None, OntologyAnnotation | None], _T]) -> Decoder_1[Any]:
+    def _arrow2112(get: IGetters, create: Any=create) -> _T:
+        alternate_name: str | None
+        object_arg: IOptionalGetter = get.Optional
+        alternate_name = object_arg.Field("alternateName", string)
+        measurement_method: str | None
+        object_arg_1: IOptionalGetter = get.Optional
+        measurement_method = object_arg_1.Field("measurementMethod", string)
+        description: str | None
+        object_arg_2: IOptionalGetter = get.Optional
+        description = object_arg_2.Field("description", string)
+        category: OntologyAnnotation | None
+        name: str | None
+        object_arg_3: IOptionalGetter = get.Optional
+        name = object_arg_3.Field("category", string)
+        code: str | None
+        object_arg_4: IOptionalGetter = get.Optional
+        code = object_arg_4.Field("categoryCode", string)
+        (pattern_matching_result, code_1) = (None, None)
+        if name is None:
+            if code is not None:
+                if code == "":
+                    pattern_matching_result = 0
+
+                else: 
+                    pattern_matching_result = 2
+                    code_1 = code
+
+
+            else: 
+                pattern_matching_result = 0
+
+
+        elif code is not None:
+            if code == "":
+                pattern_matching_result = 1
+
+            else: 
+                pattern_matching_result = 2
+                code_1 = code
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            category = None
+
+        elif pattern_matching_result == 1:
+            try: 
+                category = OntologyAnnotation.create(name)
+
+            except Exception as err:
+                raise Exception(((("Error while decoding category (name:" + str(name)) + "): ") + str(err)) + "")
+
+
+        elif pattern_matching_result == 2:
+            try: 
+                category = OntologyAnnotation.from_term_annotation(code_1, name)
+
+            except Exception as err_1:
+                raise Exception(((((("Error while decoding category (name:" + str(name)) + ", code:") + code_1) + "): ") + str(err_1)) + "")
+
+
+        unit: OntologyAnnotation | None
+        name_1: str | None
+        object_arg_5: IOptionalGetter = get.Optional
+        name_1 = object_arg_5.Field("unit", string)
+        code_2: str | None
+        object_arg_6: IOptionalGetter = get.Optional
+        code_2 = object_arg_6.Field("unitCode", string)
+        (pattern_matching_result_1, code_3) = (None, None)
+        if name_1 is None:
+            if code_2 is not None:
+                if code_2 == "":
+                    pattern_matching_result_1 = 0
+
+                else: 
+                    pattern_matching_result_1 = 2
+                    code_3 = code_2
+
+
+            else: 
+                pattern_matching_result_1 = 0
+
+
+        elif code_2 is not None:
+            if code_2 == "":
+                pattern_matching_result_1 = 1
+
+            else: 
+                pattern_matching_result_1 = 2
+                code_3 = code_2
+
+
+        else: 
+            pattern_matching_result_1 = 1
+
+        if pattern_matching_result_1 == 0:
+            unit = None
+
+        elif pattern_matching_result_1 == 1:
+            try: 
+                unit = OntologyAnnotation.create(name_1)
+
+            except Exception as err_2:
+                raise Exception(((("Error while decoding unit (name:" + str(name_1)) + "): ") + str(err_2)) + "")
+
+
+        elif pattern_matching_result_1 == 2:
+            try: 
+                unit = OntologyAnnotation.from_term_annotation(code_3, name_1)
+
+            except Exception as err_3:
+                raise Exception(((((("Error while decoding unit (name:" + str(name_1)) + ", code:") + code_3) + "): ") + str(err_3)) + "")
+
+
+        def _arrow2111(__unit: None=None) -> Value_4 | None:
+            value: str | None
+            object_arg_7: IOptionalGetter = get.Optional
+            value = object_arg_7.Field("value", AnnotationValue_decoder)
+            code_4: str | None
+            object_arg_8: IOptionalGetter = get.Optional
+            code_4 = object_arg_8.Field("valueCode", string)
+            if (code_4 is None) if (value is None) else False:
+                return None
+
+            else: 
+                try: 
+                    return Value_4.from_options(value, None, code_4)
+
+                except Exception as err_4:
+                    raise Exception(((((("Error while decoding value " + str(value)) + ",") + str(code_4)) + ": ") + str(err_4)) + "")
+
+
+
+        return create(alternate_name, measurement_method, description, category, _arrow2111(), unit)
+
+    return object(_arrow2112)
+
+
+__all__ = ["gen_id", "encoder", "decoder"]
+

arctrl/py/Json/publication.py

@@ -0,0 +1,279 @@
+from __future__ import annotations
+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.string_ import replace
+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.publication import Publication
+from .comment import (encoder as encoder_1, decoder as decoder_2, ROCrate_encoderDisambiguatingDescription, ROCrate_decoderDisambiguatingDescription, ISAJson_encoder as ISAJson_encoder_1)
+from .context.rocrate.isa_publication_context import context_jsonvalue
+from .decode import (Decode_uri, Decode_noAdditionalProperties)
+from .encode import (try_include, try_include_seq)
+from .ontology_annotation import (OntologyAnnotation_encoder, OntologyAnnotation_decoder, OntologyAnnotation_ROCrate_encoderDefinedTerm, OntologyAnnotation_ROCrate_decoderDefinedTerm)
+from .person import (ROCrate_encodeAuthorListString, ROCrate_decodeAuthorListString)
+
+__A_ = TypeVar("__A_")
+
+def encoder(oa: Publication) -> 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 _arrow2243(value: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2242(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr2242()
+
+    def _arrow2245(value_2: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2244(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_1.encode_string(value_2)
+
+        return ObjectExpr2244()
+
+    def _arrow2247(value_4: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2246(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_2.encode_string(value_4)
+
+        return ObjectExpr2246()
+
+    def _arrow2249(value_6: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2248(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_3.encode_string(value_6)
+
+        return ObjectExpr2248()
+
+    def _arrow2250(oa_1: OntologyAnnotation, oa: Any=oa) -> IEncodable:
+        return OntologyAnnotation_encoder(oa_1)
+
+    def _arrow2251(comment: Comment, oa: Any=oa) -> IEncodable:
+        return encoder_1(comment)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("pubMedID", _arrow2243, oa.PubMedID), try_include("doi", _arrow2245, oa.DOI), try_include("authorList", _arrow2247, oa.Authors), try_include("title", _arrow2249, oa.Title), try_include("status", _arrow2250, oa.Status), try_include_seq("comments", _arrow2251, oa.Comments)]))
+    class ObjectExpr2252(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 ObjectExpr2252()
+
+
+def _arrow2259(get: IGetters) -> Publication:
+    def _arrow2253(__unit: None=None) -> str | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("pubMedID", Decode_uri)
+
+    def _arrow2254(__unit: None=None) -> str | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("doi", string)
+
+    def _arrow2255(__unit: None=None) -> str | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("authorList", string)
+
+    def _arrow2256(__unit: None=None) -> str | None:
+        object_arg_3: IOptionalGetter = get.Optional
+        return object_arg_3.Field("title", string)
+
+    def _arrow2257(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_4: IOptionalGetter = get.Optional
+        return object_arg_4.Field("status", OntologyAnnotation_decoder)
+
+    def _arrow2258(__unit: None=None) -> Array[Comment] | None:
+        arg_11: Decoder_1[Array[Comment]] = resize_array(decoder_2)
+        object_arg_5: IOptionalGetter = get.Optional
+        return object_arg_5.Field("comments", arg_11)
+
+    return Publication(_arrow2253(), _arrow2254(), _arrow2255(), _arrow2256(), _arrow2257(), _arrow2258())
+
+
+decoder: Decoder_1[Publication] = object(_arrow2259)
+
+def ROCrate_genID(p: Publication) -> str:
+    match_value: str | None = p.DOI
+    if match_value is None:
+        match_value_1: str | None = p.PubMedID
+        if match_value_1 is None:
+            match_value_2: str | None = p.Title
+            if match_value_2 is None:
+                return "#EmptyPublication"
+
+            else: 
+                return "#Pub_" + replace(match_value_2, " ", "_")
+
+
+        else: 
+            return match_value_1
+
+
+    else: 
+        return match_value
+
+
+
+def ROCrate_encoder(oa: Publication) -> 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 _arrow2263(__unit: None=None, oa: Any=oa) -> IEncodable:
+        value: str = ROCrate_genID(oa)
+        class ObjectExpr2262(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr2262()
+
+    class ObjectExpr2264(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], oa: Any=oa) -> Any:
+            return helpers_1.encode_string("Publication")
+
+    def _arrow2266(value_2: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2265(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_2.encode_string(value_2)
+
+        return ObjectExpr2265()
+
+    def _arrow2268(value_4: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2267(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_3.encode_string(value_4)
+
+        return ObjectExpr2267()
+
+    def _arrow2269(author_list: str, oa: Any=oa) -> IEncodable:
+        return ROCrate_encodeAuthorListString(author_list)
+
+    def _arrow2271(value_6: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2270(IEncodable):
+            def Encode(self, helpers_4: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_4.encode_string(value_6)
+
+        return ObjectExpr2270()
+
+    def _arrow2272(oa_1: OntologyAnnotation, oa: Any=oa) -> IEncodable:
+        return OntologyAnnotation_ROCrate_encoderDefinedTerm(oa_1)
+
+    def _arrow2273(comment: Comment, oa: Any=oa) -> IEncodable:
+        return ROCrate_encoderDisambiguatingDescription(comment)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([("@id", _arrow2263()), ("@type", ObjectExpr2264()), try_include("pubMedID", _arrow2266, oa.PubMedID), try_include("doi", _arrow2268, oa.DOI), try_include("authorList", _arrow2269, oa.Authors), try_include("title", _arrow2271, oa.Title), try_include("status", _arrow2272, oa.Status), try_include_seq("comments", _arrow2273, oa.Comments), ("@context", context_jsonvalue)]))
+    class ObjectExpr2274(IEncodable):
+        def Encode(self, helpers_5: 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_5))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+            return helpers_5.encode_object(arg)
+
+    return ObjectExpr2274()
+
+
+def _arrow2281(get: IGetters) -> Publication:
+    def _arrow2275(__unit: None=None) -> str | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("pubMedID", Decode_uri)
+
+    def _arrow2276(__unit: None=None) -> str | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("doi", string)
+
+    def _arrow2277(__unit: None=None) -> str | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("authorList", ROCrate_decodeAuthorListString)
+
+    def _arrow2278(__unit: None=None) -> str | None:
+        object_arg_3: IOptionalGetter = get.Optional
+        return object_arg_3.Field("title", string)
+
+    def _arrow2279(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_4: IOptionalGetter = get.Optional
+        return object_arg_4.Field("status", OntologyAnnotation_ROCrate_decoderDefinedTerm)
+
+    def _arrow2280(__unit: None=None) -> Array[Comment] | None:
+        arg_11: Decoder_1[Array[Comment]] = resize_array(ROCrate_decoderDisambiguatingDescription)
+        object_arg_5: IOptionalGetter = get.Optional
+        return object_arg_5.Field("comments", arg_11)
+
+    return Publication(_arrow2275(), _arrow2276(), _arrow2277(), _arrow2278(), _arrow2279(), _arrow2280())
+
+
+ROCrate_decoder: Decoder_1[Publication] = object(_arrow2281)
+
+def ISAJson_encoder(id_map: Any | None, oa: Publication) -> IEncodable:
+    def chooser(tupled_arg: tuple[str, IEncodable | None], id_map: Any=id_map, 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 _arrow2285(value: str, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2284(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr2284()
+
+    def _arrow2287(value_2: str, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2286(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_1.encode_string(value_2)
+
+        return ObjectExpr2286()
+
+    def _arrow2289(value_4: str, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2288(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_2.encode_string(value_4)
+
+        return ObjectExpr2288()
+
+    def _arrow2291(value_6: str, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2290(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_3.encode_string(value_6)
+
+        return ObjectExpr2290()
+
+    def _arrow2292(oa_1: OntologyAnnotation, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        return OntologyAnnotation_encoder(oa_1)
+
+    def _arrow2293(comment: Comment, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        return ISAJson_encoder_1(id_map, comment)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("pubMedID", _arrow2285, oa.PubMedID), try_include("doi", _arrow2287, oa.DOI), try_include("authorList", _arrow2289, oa.Authors), try_include("title", _arrow2291, oa.Title), try_include("status", _arrow2292, oa.Status), try_include_seq("comments", _arrow2293, oa.Comments)]))
+    class ObjectExpr2294(IEncodable):
+        def Encode(self, helpers_4: IEncoderHelpers_1[Any], id_map: Any=id_map, 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 ObjectExpr2294()
+
+
+ISAJson_allowedFields: FSharpList[str] = of_array(["pubMedID", "doi", "authorList", "title", "status", "comments"])
+
+ISAJson_decoder: Decoder_1[Publication] = Decode_noAdditionalProperties(ISAJson_allowedFields, decoder)
+
+__all__ = ["encoder", "decoder", "ROCrate_genID", "ROCrate_encoder", "ROCrate_decoder", "ISAJson_encoder", "ISAJson_allowedFields", "ISAJson_decoder"]
+