arctrl 3.0.0__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 ObjectExpr2745(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 = (ObjectExpr2745(), None)
+
+        elif v.tag == 2:
+            class ObjectExpr2746(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 = (ObjectExpr2746(), None)
+
+        elif v.tag == 0:
+            oa_1: OntologyAnnotation = v.fields[0]
+            def _arrow2748(value_3: str, pv: Any=pv) -> IEncodable:
+                class ObjectExpr2747(IEncodable):
+                    def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                        return helpers_3.encode_string(value_3)
+
+                return ObjectExpr2747()
+
+            def _arrow2750(value_5: str, pv: Any=pv) -> IEncodable:
+                class ObjectExpr2749(IEncodable):
+                    def Encode(self, helpers_4: IEncoderHelpers_1[Any]) -> Any:
+                        return helpers_4.encode_string(value_5)
+
+                return ObjectExpr2749()
+
+            pattern_input_1 = (map(_arrow2748, oa_1.Name), map(_arrow2750, oa_1.TermAccessionNumber))
+
+        else: 
+            class ObjectExpr2751(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any], pv: Any=pv) -> Any:
+                    return helpers.encode_string(v.fields[0])
+
+            pattern_input_1 = (ObjectExpr2751(), 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 _arrow2755(__unit: None=None, pv: Any=pv) -> IEncodable:
+        value_8: str = gen_id(pv)
+        class ObjectExpr2754(IEncodable):
+            def Encode(self, helpers_5: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_5.encode_string(value_8)
+
+        return ObjectExpr2754()
+
+    class ObjectExpr2756(IEncodable):
+        def Encode(self, helpers_6: IEncoderHelpers_1[Any], pv: Any=pv) -> Any:
+            return helpers_6.encode_string("PropertyValue")
+
+    def _arrow2758(__unit: None=None, pv: Any=pv) -> IEncodable:
+        value_10: str = pv.GetAdditionalType()
+        class ObjectExpr2757(IEncodable):
+            def Encode(self, helpers_7: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_7.encode_string(value_10)
+
+        return ObjectExpr2757()
+
+    def _arrow2760(value_11: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2759(IEncodable):
+            def Encode(self, helpers_8: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_8.encode_string(value_11)
+
+        return ObjectExpr2759()
+
+    def _arrow2762(value_13: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2761(IEncodable):
+            def Encode(self, helpers_9: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_9.encode_string(value_13)
+
+        return ObjectExpr2761()
+
+    def _arrow2764(value_15: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2763(IEncodable):
+            def Encode(self, helpers_10: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_10.encode_string(value_15)
+
+        return ObjectExpr2763()
+
+    def _arrow2766(value_17: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2765(IEncodable):
+            def Encode(self, helpers_11: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_11.encode_string(value_17)
+
+        return ObjectExpr2765()
+
+    def _arrow2768(value_19: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2767(IEncodable):
+            def Encode(self, helpers_12: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_12.encode_string(value_19)
+
+        return ObjectExpr2767()
+
+    def _arrow2769(x: IEncodable, pv: Any=pv) -> IEncodable:
+        return x
+
+    def _arrow2770(x_1: IEncodable, pv: Any=pv) -> IEncodable:
+        return x_1
+
+    def _arrow2772(value_21: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2771(IEncodable):
+            def Encode(self, helpers_13: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_13.encode_string(value_21)
+
+        return ObjectExpr2771()
+
+    def _arrow2774(value_23: str, pv: Any=pv) -> IEncodable:
+        class ObjectExpr2773(IEncodable):
+            def Encode(self, helpers_14: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_14.encode_string(value_23)
+
+        return ObjectExpr2773()
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([("@id", _arrow2755()), ("@type", ObjectExpr2756()), ("additionalType", _arrow2758()), try_include("alternateName", _arrow2760, pv.AlternateName()), try_include("measurementMethod", _arrow2762, pv.MeasurementMethod()), try_include("description", _arrow2764, pv.Description()), try_include("category", _arrow2766, pattern_input[0]), try_include("categoryCode", _arrow2768, pattern_input[1]), try_include("value", _arrow2769, pattern_input_1[0]), try_include("valueCode", _arrow2770, pattern_input_1[1]), try_include("unit", _arrow2772, pattern_input_2[0]), try_include("unitCode", _arrow2774, pattern_input_2[1]), ("@context", context_jsonvalue)]))
+    class ObjectExpr2775(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 ObjectExpr2775()
+
+
+def decoder(create: Callable[[str | None, str | None, str | None, OntologyAnnotation | None, Value_4 | None, OntologyAnnotation | None], _T]) -> Decoder_1[Any]:
+    def _arrow2778(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 _arrow2777(__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, _arrow2777(), unit)
+
+    return object(_arrow2778)
+
+
+__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 _arrow2912(value: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2911(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr2911()
+
+    def _arrow2914(value_2: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2913(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_1.encode_string(value_2)
+
+        return ObjectExpr2913()
+
+    def _arrow2916(value_4: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2915(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_2.encode_string(value_4)
+
+        return ObjectExpr2915()
+
+    def _arrow2918(value_6: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2917(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_3.encode_string(value_6)
+
+        return ObjectExpr2917()
+
+    def _arrow2919(oa_1: OntologyAnnotation, oa: Any=oa) -> IEncodable:
+        return OntologyAnnotation_encoder(oa_1)
+
+    def _arrow2920(comment: Comment, oa: Any=oa) -> IEncodable:
+        return encoder_1(comment)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("pubMedID", _arrow2912, oa.PubMedID), try_include("doi", _arrow2914, oa.DOI), try_include("authorList", _arrow2916, oa.Authors), try_include("title", _arrow2918, oa.Title), try_include("status", _arrow2919, oa.Status), try_include_seq("comments", _arrow2920, oa.Comments)]))
+    class ObjectExpr2921(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 ObjectExpr2921()
+
+
+def _arrow2928(get: IGetters) -> Publication:
+    def _arrow2922(__unit: None=None) -> str | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("pubMedID", Decode_uri)
+
+    def _arrow2923(__unit: None=None) -> str | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("doi", string)
+
+    def _arrow2924(__unit: None=None) -> str | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("authorList", string)
+
+    def _arrow2925(__unit: None=None) -> str | None:
+        object_arg_3: IOptionalGetter = get.Optional
+        return object_arg_3.Field("title", string)
+
+    def _arrow2926(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_4: IOptionalGetter = get.Optional
+        return object_arg_4.Field("status", OntologyAnnotation_decoder)
+
+    def _arrow2927(__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(_arrow2922(), _arrow2923(), _arrow2924(), _arrow2925(), _arrow2926(), _arrow2927())
+
+
+decoder: Decoder_1[Publication] = object(_arrow2928)
+
+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 _arrow2932(__unit: None=None, oa: Any=oa) -> IEncodable:
+        value: str = ROCrate_genID(oa)
+        class ObjectExpr2931(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr2931()
+
+    class ObjectExpr2933(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], oa: Any=oa) -> Any:
+            return helpers_1.encode_string("Publication")
+
+    def _arrow2935(value_2: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2934(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_2.encode_string(value_2)
+
+        return ObjectExpr2934()
+
+    def _arrow2937(value_4: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2936(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_3.encode_string(value_4)
+
+        return ObjectExpr2936()
+
+    def _arrow2938(author_list: str, oa: Any=oa) -> IEncodable:
+        return ROCrate_encodeAuthorListString(author_list)
+
+    def _arrow2940(value_6: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2939(IEncodable):
+            def Encode(self, helpers_4: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_4.encode_string(value_6)
+
+        return ObjectExpr2939()
+
+    def _arrow2941(oa_1: OntologyAnnotation, oa: Any=oa) -> IEncodable:
+        return OntologyAnnotation_ROCrate_encoderDefinedTerm(oa_1)
+
+    def _arrow2942(comment: Comment, oa: Any=oa) -> IEncodable:
+        return ROCrate_encoderDisambiguatingDescription(comment)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([("@id", _arrow2932()), ("@type", ObjectExpr2933()), try_include("pubMedID", _arrow2935, oa.PubMedID), try_include("doi", _arrow2937, oa.DOI), try_include("authorList", _arrow2938, oa.Authors), try_include("title", _arrow2940, oa.Title), try_include("status", _arrow2941, oa.Status), try_include_seq("comments", _arrow2942, oa.Comments), ("@context", context_jsonvalue)]))
+    class ObjectExpr2943(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 ObjectExpr2943()
+
+
+def _arrow2950(get: IGetters) -> Publication:
+    def _arrow2944(__unit: None=None) -> str | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("pubMedID", Decode_uri)
+
+    def _arrow2945(__unit: None=None) -> str | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("doi", string)
+
+    def _arrow2946(__unit: None=None) -> str | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("authorList", ROCrate_decodeAuthorListString)
+
+    def _arrow2947(__unit: None=None) -> str | None:
+        object_arg_3: IOptionalGetter = get.Optional
+        return object_arg_3.Field("title", string)
+
+    def _arrow2948(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_4: IOptionalGetter = get.Optional
+        return object_arg_4.Field("status", OntologyAnnotation_ROCrate_decoderDefinedTerm)
+
+    def _arrow2949(__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(_arrow2944(), _arrow2945(), _arrow2946(), _arrow2947(), _arrow2948(), _arrow2949())
+
+
+ROCrate_decoder: Decoder_1[Publication] = object(_arrow2950)
+
+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 _arrow2954(value: str, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2953(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr2953()
+
+    def _arrow2958(value_2: str, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2957(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_1.encode_string(value_2)
+
+        return ObjectExpr2957()
+
+    def _arrow2962(value_4: str, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2961(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_2.encode_string(value_4)
+
+        return ObjectExpr2961()
+
+    def _arrow2967(value_6: str, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2966(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_3.encode_string(value_6)
+
+        return ObjectExpr2966()
+
+    def _arrow2969(oa_1: OntologyAnnotation, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        return OntologyAnnotation_encoder(oa_1)
+
+    def _arrow2970(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", _arrow2954, oa.PubMedID), try_include("doi", _arrow2958, oa.DOI), try_include("authorList", _arrow2962, oa.Authors), try_include("title", _arrow2967, oa.Title), try_include("status", _arrow2969, oa.Status), try_include_seq("comments", _arrow2970, oa.Comments)]))
+    class ObjectExpr2974(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 ObjectExpr2974()
+
+
+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"]
+