arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/Json/Process/process_parameter_value.py

@@ -0,0 +1,81 @@
+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.process_parameter_value import ProcessParameterValue
+from ...Core.Process.protocol_parameter import ProtocolParameter
+from ...Core.value import Value
+from ..encode import try_include
+from ..ontology_annotation import (OntologyAnnotation_ISAJson_encoder, OntologyAnnotation_ISAJson_decoder)
+from ..property_value import (encoder, decoder)
+from .protocol_parameter 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[[ProcessParameterValue], IEncodable] = encoder
+
+def _arrow2605(alternate_name: str | None=None, measurement_method: str | None=None, description: str | None=None, category: OntologyAnnotation | None=None, value: Value | None=None, unit: OntologyAnnotation | None=None) -> ProcessParameterValue:
+    return ProcessParameterValue.create_as_pv(alternate_name, measurement_method, description, category, value, unit)
+
+
+ROCrate_decoder: Decoder_1[ProcessParameterValue] = decoder(_arrow2605)
+
+def ISAJson_genID(oa: ProcessParameterValue) -> Any:
+    raise Exception("Not implemented")
+
+
+def ISAJson_encoder(id_map: Any | None, oa: ProcessParameterValue) -> 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 _arrow2607(value: ProtocolParameter, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        return encoder_1(id_map, value)
+
+    def _arrow2608(value_1: Value, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        return encoder_2(id_map, value_1)
+
+    def _arrow2609(oa_1: OntologyAnnotation, id_map: Any=id_map, oa: Any=oa) -> IEncodable:
+        return OntologyAnnotation_ISAJson_encoder(id_map, oa_1)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("category", _arrow2607, oa.Category), try_include("value", _arrow2608, oa.Value), try_include("unit", _arrow2609, oa.Unit)]))
+    class ObjectExpr2610(IEncodable):
+        def Encode(self, helpers: 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))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+            return helpers.encode_object(arg)
+
+    return ObjectExpr2610()
+
+
+def _arrow2614(get: IGetters) -> ProcessParameterValue:
+    def _arrow2611(__unit: None=None) -> ProtocolParameter | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("category", decoder_1)
+
+    def _arrow2612(__unit: None=None) -> Value | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("value", decoder_2)
+
+    def _arrow2613(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("unit", OntologyAnnotation_ISAJson_decoder)
+
+    return ProcessParameterValue(_arrow2611(), _arrow2612(), _arrow2613())
+
+
+ISAJson_decoder: Decoder_1[ProcessParameterValue] = object(_arrow2614)
+
+__all__ = ["ROCrate_encoder", "ROCrate_decoder", "ISAJson_genID", "ISAJson_encoder", "ISAJson_decoder"]
+

arctrl/py/Json/Process/protocol.py

@@ -0,0 +1,354 @@
+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, empty, append)
+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.string_ import replace
+from ...fable_modules.fable_library.util import IEnumerable_1
+from ...fable_modules.thoth_json_core.decode import (object, list_1 as list_1_2, IOptionalGetter, string, 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.comment import Comment
+from ...Core.Helper.collections_ import Option_fromValueWithDefault
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Process.component import Component
+from ...Core.Process.protocol import Protocol
+from ...Core.Process.protocol_parameter import ProtocolParameter
+from ..comment 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 ..context.rocrate.isa_protocol_context import context_jsonvalue
+from ..decode import Decode_uri
+from ..encode import (try_include, try_include_list_opt)
+from ..idtable import encode
+from ..ontology_annotation import (OntologyAnnotation_ROCrate_encoderDefinedTerm, OntologyAnnotation_ROCrate_decoderDefinedTerm, OntologyAnnotation_ISAJson_encoder, OntologyAnnotation_ISAJson_decoder)
+from .component 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)
+from .protocol_parameter import (encoder, decoder)
+
+__A_ = TypeVar("__A_")
+
+def ROCrate_genID(study_name: str | None, assay_name: str | None, process_name: str | None, p: Protocol) -> str:
+    match_value: str | None = p.ID
+    (pattern_matching_result, id_1) = (None, None)
+    if match_value is not None:
+        if match_value != "":
+            pattern_matching_result = 0
+            id_1 = match_value
+
+        else: 
+            pattern_matching_result = 1
+
+
+    else: 
+        pattern_matching_result = 1
+
+    if pattern_matching_result == 0:
+        return id_1
+
+    elif pattern_matching_result == 1:
+        match_value_1: str | None = p.Uri
+        if match_value_1 is None:
+            match_value_2: str | None = p.Name
+            if match_value_2 is None:
+                (pattern_matching_result_1, an, pn, sn, pn_1, sn_1, pn_2) = (None, None, None, None, None, None, None)
+                if study_name is None:
+                    if assay_name is None:
+                        if process_name is not None:
+                            pattern_matching_result_1 = 2
+                            pn_2 = process_name
+
+                        else: 
+                            pattern_matching_result_1 = 3
+
+
+                    else: 
+                        pattern_matching_result_1 = 3
+
+
+                elif assay_name is None:
+                    if process_name is not None:
+                        pattern_matching_result_1 = 1
+                        pn_1 = process_name
+                        sn_1 = study_name
+
+                    else: 
+                        pattern_matching_result_1 = 3
+
+
+                elif process_name is not None:
+                    pattern_matching_result_1 = 0
+                    an = assay_name
+                    pn = process_name
+                    sn = study_name
+
+                else: 
+                    pattern_matching_result_1 = 3
+
+                if pattern_matching_result_1 == 0:
+                    return (((("#Protocol_" + replace(sn, " ", "_")) + "_") + replace(an, " ", "_")) + "_") + replace(pn, " ", "_")
+
+                elif pattern_matching_result_1 == 1:
+                    return (("#Protocol_" + replace(sn_1, " ", "_")) + "_") + replace(pn_1, " ", "_")
+
+                elif pattern_matching_result_1 == 2:
+                    return "#Protocol_" + replace(pn_2, " ", "_")
+
+                elif pattern_matching_result_1 == 3:
+                    return "#EmptyProtocol"
+
+
+            else: 
+                return "#Protocol_" + replace(match_value_2, " ", "_")
+
+
+        else: 
+            return match_value_1
+
+
+
+
+def ROCrate_encoder(study_name: str | None, assay_name: str | None, process_name: str | None, oa: Protocol) -> IEncodable:
+    def chooser(tupled_arg: tuple[str, IEncodable | None], study_name: Any=study_name, assay_name: Any=assay_name, process_name: Any=process_name, 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 _arrow2491(__unit: None=None, study_name: Any=study_name, assay_name: Any=assay_name, process_name: Any=process_name, oa: Any=oa) -> IEncodable:
+        value: str = ROCrate_genID(study_name, assay_name, process_name, oa)
+        class ObjectExpr2490(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr2490()
+
+    class ObjectExpr2492(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], study_name: Any=study_name, assay_name: Any=assay_name, process_name: Any=process_name, oa: Any=oa) -> Any:
+            return helpers_1.encode_string("Protocol")
+
+    def _arrow2494(value_2: str, study_name: Any=study_name, assay_name: Any=assay_name, process_name: Any=process_name, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2493(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_2.encode_string(value_2)
+
+        return ObjectExpr2493()
+
+    def _arrow2495(oa_1: OntologyAnnotation, study_name: Any=study_name, assay_name: Any=assay_name, process_name: Any=process_name, oa: Any=oa) -> IEncodable:
+        return OntologyAnnotation_ROCrate_encoderDefinedTerm(oa_1)
+
+    def _arrow2497(value_4: str, study_name: Any=study_name, assay_name: Any=assay_name, process_name: Any=process_name, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2496(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_3.encode_string(value_4)
+
+        return ObjectExpr2496()
+
+    def _arrow2499(value_6: str, study_name: Any=study_name, assay_name: Any=assay_name, process_name: Any=process_name, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2498(IEncodable):
+            def Encode(self, helpers_4: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_4.encode_string(value_6)
+
+        return ObjectExpr2498()
+
+    def _arrow2501(value_8: str, study_name: Any=study_name, assay_name: Any=assay_name, process_name: Any=process_name, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2500(IEncodable):
+            def Encode(self, helpers_5: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_5.encode_string(value_8)
+
+        return ObjectExpr2500()
+
+    def _arrow2502(comment: Comment, study_name: Any=study_name, assay_name: Any=assay_name, process_name: Any=process_name, oa: Any=oa) -> IEncodable:
+        return ROCrate_encoder_2(comment)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([("@id", _arrow2491()), ("@type", list_1_1(singleton(ObjectExpr2492()))), try_include("name", _arrow2494, oa.Name), try_include("protocolType", _arrow2495, oa.ProtocolType), try_include("description", _arrow2497, oa.Description), try_include("uri", _arrow2499, oa.Uri), try_include("version", _arrow2501, oa.Version), try_include_list_opt("components", ROCrate_encoder_1, oa.Components), try_include_list_opt("comments", _arrow2502, oa.Comments), ("@context", context_jsonvalue)]))
+    class ObjectExpr2503(IEncodable):
+        def Encode(self, helpers_6: IEncoderHelpers_1[Any], study_name: Any=study_name, assay_name: Any=assay_name, process_name: Any=process_name, 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_6))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+            return helpers_6.encode_object(arg)
+
+    return ObjectExpr2503()
+
+
+def _arrow2515(get: IGetters) -> Protocol:
+    def _arrow2507(__unit: None=None) -> FSharpList[Component]:
+        list_4: FSharpList[Component]
+        def _arrow2504(__unit: None=None) -> FSharpList[Component] | None:
+            arg_1: Decoder_1[FSharpList[Component]] = list_1_2(ROCrate_decoder_1)
+            object_arg: IOptionalGetter = get.Optional
+            return object_arg.Field("components", arg_1)
+
+        list_2: FSharpList[Component] = default_arg(_arrow2504(), empty())
+        def _arrow2505(__unit: None=None) -> FSharpList[Component] | None:
+            arg_3: Decoder_1[FSharpList[Component]] = list_1_2(ROCrate_decoder_1)
+            object_arg_1: IOptionalGetter = get.Optional
+            return object_arg_1.Field("reagents", arg_3)
+
+        list_4 = append(default_arg(_arrow2505(), empty()), list_2)
+        def _arrow2506(__unit: None=None) -> FSharpList[Component] | None:
+            arg_5: Decoder_1[FSharpList[Component]] = list_1_2(ROCrate_decoder_1)
+            object_arg_2: IOptionalGetter = get.Optional
+            return object_arg_2.Field("computationalTools", arg_5)
+
+        return append(default_arg(_arrow2506(), empty()), list_4)
+
+    components: FSharpList[Component] | None = Option_fromValueWithDefault(empty(), _arrow2507())
+    def _arrow2508(__unit: None=None) -> str | None:
+        object_arg_3: IOptionalGetter = get.Optional
+        return object_arg_3.Field("@id", Decode_uri)
+
+    def _arrow2509(__unit: None=None) -> str | None:
+        object_arg_4: IOptionalGetter = get.Optional
+        return object_arg_4.Field("name", string)
+
+    def _arrow2510(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_5: IOptionalGetter = get.Optional
+        return object_arg_5.Field("protocolType", OntologyAnnotation_ROCrate_decoderDefinedTerm)
+
+    def _arrow2511(__unit: None=None) -> str | None:
+        object_arg_6: IOptionalGetter = get.Optional
+        return object_arg_6.Field("description", string)
+
+    def _arrow2512(__unit: None=None) -> str | None:
+        object_arg_7: IOptionalGetter = get.Optional
+        return object_arg_7.Field("uri", Decode_uri)
+
+    def _arrow2513(__unit: None=None) -> str | None:
+        object_arg_8: IOptionalGetter = get.Optional
+        return object_arg_8.Field("version", string)
+
+    def _arrow2514(__unit: None=None) -> FSharpList[Comment] | None:
+        arg_19: Decoder_1[FSharpList[Comment]] = list_1_2(ROCrate_decoder_2)
+        object_arg_9: IOptionalGetter = get.Optional
+        return object_arg_9.Field("comments", arg_19)
+
+    return Protocol(_arrow2508(), _arrow2509(), _arrow2510(), _arrow2511(), _arrow2512(), _arrow2513(), None, components, _arrow2514())
+
+
+ROCrate_decoder: Decoder_1[Protocol] = object(_arrow2515)
+
+def ISAJson_encoder(study_name: str | None, assay_name: str | None, process_name: str | None, id_map: Any | None, oa: Protocol) -> IEncodable:
+    def f(oa_1: Protocol, study_name: Any=study_name, assay_name: Any=assay_name, process_name: Any=process_name, 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 _arrow2519(value: str, oa_1: Any=oa_1) -> IEncodable:
+            class ObjectExpr2518(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value)
+
+            return ObjectExpr2518()
+
+        def _arrow2521(value_2: str, oa_1: Any=oa_1) -> IEncodable:
+            class ObjectExpr2520(IEncodable):
+                def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers_1.encode_string(value_2)
+
+            return ObjectExpr2520()
+
+        def _arrow2522(oa_2: OntologyAnnotation, oa_1: Any=oa_1) -> IEncodable:
+            return OntologyAnnotation_ISAJson_encoder(id_map, oa_2)
+
+        def _arrow2524(value_4: str, oa_1: Any=oa_1) -> IEncodable:
+            class ObjectExpr2523(IEncodable):
+                def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers_2.encode_string(value_4)
+
+            return ObjectExpr2523()
+
+        def _arrow2526(value_6: str, oa_1: Any=oa_1) -> IEncodable:
+            class ObjectExpr2525(IEncodable):
+                def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers_3.encode_string(value_6)
+
+            return ObjectExpr2525()
+
+        def _arrow2528(value_8: str, oa_1: Any=oa_1) -> IEncodable:
+            class ObjectExpr2527(IEncodable):
+                def Encode(self, helpers_4: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers_4.encode_string(value_8)
+
+            return ObjectExpr2527()
+
+        def _arrow2529(value_10: ProtocolParameter, oa_1: Any=oa_1) -> IEncodable:
+            return encoder(id_map, value_10)
+
+        def _arrow2530(c: Component, oa_1: Any=oa_1) -> IEncodable:
+            return ISAJson_encoder_1(id_map, c)
+
+        def _arrow2531(comment: Comment, oa_1: Any=oa_1) -> IEncodable:
+            return ISAJson_encoder_2(id_map, comment)
+
+        values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("@id", _arrow2519, ROCrate_genID(study_name, assay_name, process_name, oa_1)), try_include("name", _arrow2521, oa_1.Name), try_include("protocolType", _arrow2522, oa_1.ProtocolType), try_include("description", _arrow2524, oa_1.Description), try_include("uri", _arrow2526, oa_1.Uri), try_include("version", _arrow2528, oa_1.Version), try_include_list_opt("parameters", _arrow2529, oa_1.Parameters), try_include_list_opt("components", _arrow2530, oa_1.Components), try_include_list_opt("comments", _arrow2531, oa_1.Comments)]))
+        class ObjectExpr2532(IEncodable):
+            def Encode(self, helpers_5: 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_5))
+
+                arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+                return helpers_5.encode_object(arg)
+
+        return ObjectExpr2532()
+
+    if id_map is not None:
+        def _arrow2533(p_1: Protocol, study_name: Any=study_name, assay_name: Any=assay_name, process_name: Any=process_name, id_map: Any=id_map, oa: Any=oa) -> str:
+            return ROCrate_genID(study_name, assay_name, process_name, p_1)
+
+        return encode(_arrow2533, f, oa, id_map)
+
+    else: 
+        return f(oa)
+
+
+
+def _arrow2543(get: IGetters) -> Protocol:
+    def _arrow2534(__unit: None=None) -> str | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("@id", Decode_uri)
+
+    def _arrow2535(__unit: None=None) -> str | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("name", string)
+
+    def _arrow2536(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("protocolType", OntologyAnnotation_ISAJson_decoder)
+
+    def _arrow2537(__unit: None=None) -> str | None:
+        object_arg_3: IOptionalGetter = get.Optional
+        return object_arg_3.Field("description", string)
+
+    def _arrow2538(__unit: None=None) -> str | None:
+        object_arg_4: IOptionalGetter = get.Optional
+        return object_arg_4.Field("uri", Decode_uri)
+
+    def _arrow2539(__unit: None=None) -> str | None:
+        object_arg_5: IOptionalGetter = get.Optional
+        return object_arg_5.Field("version", string)
+
+    def _arrow2540(__unit: None=None) -> FSharpList[ProtocolParameter] | None:
+        arg_13: Decoder_1[FSharpList[ProtocolParameter]] = list_1_2(decoder)
+        object_arg_6: IOptionalGetter = get.Optional
+        return object_arg_6.Field("parameters", arg_13)
+
+    def _arrow2541(__unit: None=None) -> FSharpList[Component] | None:
+        arg_15: Decoder_1[FSharpList[Component]] = list_1_2(ISAJson_decoder_1)
+        object_arg_7: IOptionalGetter = get.Optional
+        return object_arg_7.Field("components", arg_15)
+
+    def _arrow2542(__unit: None=None) -> FSharpList[Comment] | None:
+        arg_17: Decoder_1[FSharpList[Comment]] = list_1_2(ISAJson_decoder_2)
+        object_arg_8: IOptionalGetter = get.Optional
+        return object_arg_8.Field("comments", arg_17)
+
+    return Protocol(_arrow2534(), _arrow2535(), _arrow2536(), _arrow2537(), _arrow2538(), _arrow2539(), _arrow2540(), _arrow2541(), _arrow2542())
+
+
+ISAJson_decoder: Decoder_1[Protocol] = object(_arrow2543)
+
+__all__ = ["ROCrate_genID", "ROCrate_encoder", "ROCrate_decoder", "ISAJson_encoder", "ISAJson_decoder"]
+

arctrl/py/Json/Process/protocol_parameter.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.protocol_parameter import ProtocolParameter
+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(p: ProtocolParameter) -> str:
+    match_value: OntologyAnnotation | None = p.ParameterName
+    if match_value is None:
+        return "#EmptyProtocolParameter"
+
+    else: 
+        return ("#ProtocolParameter/" + OntologyAnnotation_ROCrate_genID(match_value)) + ""
+
+
+
+def encoder(id_map: Any | None, value: ProtocolParameter) -> IEncodable:
+    def f(value_1: ProtocolParameter, 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 _arrow2370(value_2: str, value_1: Any=value_1) -> IEncodable:
+            class ObjectExpr2369(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value_2)
+
+            return ObjectExpr2369()
+
+        def _arrow2373(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", _arrow2370, gen_id(value_1)), try_include("parameterName", _arrow2373, value_1.ParameterName)]))
+        class ObjectExpr2377(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 ObjectExpr2377()
+
+    if id_map is not None:
+        def _arrow2380(p_1: ProtocolParameter, id_map: Any=id_map, value: Any=value) -> str:
+            return gen_id(p_1)
+
+        return encode(_arrow2380, f, value, id_map)
+
+    else: 
+        return f(value)
+
+
+
+def _arrow2384(get: IGetters) -> ProtocolParameter:
+    def _arrow2383(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("parameterName", OntologyAnnotation_ISAJson_decoder)
+
+    return ProtocolParameter(None, _arrow2383())
+
+
+decoder: Decoder_1[ProtocolParameter] = object(_arrow2384)
+
+__all__ = ["gen_id", "encoder", "decoder"]
+