arctrl 3.0.0__py3-none-any.whl

arctrl/py/FileSystem/path.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+from typing import Any
+from ..fable_modules.fable_library.array_ import (filter, map_indexed, append, last)
+from ..fable_modules.fable_library.char import is_letter
+from ..fable_modules.fable_library.list import (of_array, FSharpList)
+from ..fable_modules.fable_library.string_ import (split as split_1, starts_with_exact, substring, ends_with_exact, join, trim_end, trim_start, trim)
+from ..fable_modules.fable_library.types import Array
+
+seperators: Array[str] = ["/", "\\"]
+
+alternative_licensefile_names: FSharpList[str] = of_array(["LICENSE.txt", "LICENSE.md", "LICENSE.rst"])
+
+def split(path: str) -> Array[str]:
+    def predicate(p: str, path: Any=path) -> bool:
+        if p != "":
+            return p != "."
+
+        else: 
+            return False
+
+
+    return filter(predicate, split_1(path, seperators, None, 3))
+
+
+def has_leading_separator(path: str) -> bool:
+    if len(path) > 0:
+        if path[0] == "/":
+            return True
+
+        else: 
+            return path[0] == "\\"
+
+
+    else: 
+        return False
+
+
+
+def is_unc_path(path: str) -> bool:
+    if starts_with_exact(path, "//"):
+        return True
+
+    else: 
+        return starts_with_exact(path, "\\\\")
+
+
+
+def try_get_drive_prefix(path: str) -> str | None:
+    if (True if (path[2] == "/") else (path[2] == "\\")) if ((path[1] == ":") if (is_letter(path[0]) if (len(path) > 2) else False) else False) else False:
+        return substring(path, 0, 2)
+
+    else: 
+        return None
+
+
+
+def split_with_prefix(path: str) -> tuple[str | None, Array[str]]:
+    trimmed: str = path.strip()
+    match_value: str | None = try_get_drive_prefix(trimmed)
+    if match_value is None:
+        if is_unc_path(trimmed):
+            return ("//", split(trimmed))
+
+        elif has_leading_separator(trimmed):
+            return ("/", split(trimmed))
+
+        else: 
+            return (None, split(trimmed))
+
+
+    else: 
+        return (match_value, split(substring(trimmed, 2)))
+
+
+
+def normalize_root_prefix(prefix: str) -> str:
+    if prefix == "//":
+        return "//"
+
+    elif ends_with_exact(prefix, ":"):
+        return ("" + prefix) + "/"
+
+    else: 
+        return "/"
+
+
+
+def build_path_from_prefix_and_segments(prefix_opt: str | None, segments: Array[str]) -> str:
+    if len(segments) == 0:
+        if prefix_opt is None:
+            return ""
+
+        else: 
+            return normalize_root_prefix(prefix_opt)
+
+
+    else: 
+        combined: str = join("/", segments)
+        (pattern_matching_result, prefix_3, prefix_4) = (None, None, None)
+        if prefix_opt is None:
+            pattern_matching_result = 4
+
+        elif prefix_opt == "//":
+            pattern_matching_result = 0
+
+        elif prefix_opt == "/":
+            if ends_with_exact(prefix_opt, ":"):
+                pattern_matching_result = 1
+                prefix_3 = prefix_opt
+
+            else: 
+                pattern_matching_result = 2
+
+
+        elif ends_with_exact(prefix_opt, ":"):
+            pattern_matching_result = 1
+            prefix_3 = prefix_opt
+
+        else: 
+            pattern_matching_result = 3
+            prefix_4 = prefix_opt
+
+        if pattern_matching_result == 0:
+            return ("//" + combined) + ""
+
+        elif pattern_matching_result == 1:
+            return ((("" + prefix_3) + "/") + combined) + ""
+
+        elif pattern_matching_result == 2:
+            return ("/" + combined) + ""
+
+        elif pattern_matching_result == 3:
+            return ((("" + prefix_4) + "/") + combined) + ""
+
+        elif pattern_matching_result == 4:
+            return combined
+
+
+
+
+def combine(path1: str, path2: str) -> str:
+    return (trim_end(path1, *seperators) + "/") + trim_start(path2, *seperators)
+
+
+def combine_many(paths: Array[str]) -> str:
+    def mapping(i: int, p: str, paths: Any=paths) -> str:
+        if i == 0:
+            return trim_end(p, *seperators)
+
+        elif i == (len(paths) - 1):
+            return trim_start(p, *seperators)
+
+        else: 
+            return trim(p, *seperators)
+
+
+    return join("/", map_indexed(mapping, paths, None))
+
+
+def normalize_segments(segments: Array[str]) -> Array[str]:
+    resolved: Array[str] = []
+    for idx in range(0, (len(segments) - 1) + 1, 1):
+        raw_segment: str = segments[idx]
+        segment: str = raw_segment.strip()
+        if True if (segment == "") else (segment == "."):
+            pass
+
+        elif segment == "..":
+            if (resolved[len(resolved) - 1] != "..") if (len(resolved) > 0) else False:
+                resolved.pop(len(resolved) - 1)
+
+            else: 
+                (resolved.append(segment))
+
+
+        else: 
+            (resolved.append(segment))
+
+    return resolved[:]
+
+
+def normalize(path: str) -> str:
+    trimmed_path: str = path.strip()
+    pattern_input: tuple[str | None, Array[str]] = split_with_prefix(trimmed_path)
+    prefix_opt: str | None = pattern_input[0]
+    normalized_segments: Array[str] = normalize_segments(pattern_input[1])
+    if len(normalized_segments) == 0:
+        if prefix_opt is None:
+            return trimmed_path
+
+        else: 
+            return normalize_root_prefix(prefix_opt)
+
+
+    else: 
+        return build_path_from_prefix_and_segments(prefix_opt, normalized_segments)
+
+
+
+def normalize_path_key(path: str) -> str:
+    normalized: str = normalize(path)
+    if normalized == "":
+        return path.strip()
+
+    else: 
+        trimmed_leading_separators: str = trim_start(normalized, *seperators)
+        if trimmed_leading_separators == "":
+            return normalized
+
+        else: 
+            return trimmed_leading_separators
+
+
+
+
+def resolve_path_from_file(file_path: str, path: str) -> str:
+    trimmed_path: str = path.strip()
+    pattern_input: tuple[str | None, Array[str]] = split_with_prefix(trimmed_path)
+    if pattern_input[0] is not None:
+        return normalize(trimmed_path)
+
+    else: 
+        pattern_input_1: tuple[str | None, Array[str]] = split_with_prefix(file_path)
+        file_prefix_opt: str | None = pattern_input_1[0]
+        file_path_segments: Array[str] = pattern_input_1[1]
+        resolved_segments: Array[str] = normalize_segments(append([] if (len(file_path_segments) <= 1) else file_path_segments[0:(len(file_path_segments) - 2) + 1], pattern_input[1], None))
+        if len(resolved_segments) == 0:
+            if file_prefix_opt is None:
+                return trimmed_path
+
+            else: 
+                return normalize_root_prefix(file_prefix_opt)
+
+
+        else: 
+            return build_path_from_prefix_and_segments(file_prefix_opt, resolved_segments)
+
+
+
+
+def get_file_name(path: str) -> str:
+    return last(split(path))
+
+
+def is_file(file_name: str, path: str) -> bool:
+    return get_file_name(path) == file_name
+
+
+def get_assay_folder_path(assay_identifier: str) -> str:
+    return combine("assays", assay_identifier)
+
+
+def get_study_folder_path(study_identifier: str) -> str:
+    return combine("studies", study_identifier)
+
+
+def get_workflow_folder_path(workflow_identifier: str) -> str:
+    return combine("workflows", workflow_identifier)
+
+
+def get_run_folder_path(run_identifier: str) -> str:
+    return combine("runs", run_identifier)
+
+
+__all__ = ["seperators", "alternative_licensefile_names", "split", "has_leading_separator", "is_unc_path", "try_get_drive_prefix", "split_with_prefix", "normalize_root_prefix", "build_path_from_prefix_and_segments", "combine", "combine_many", "normalize_segments", "normalize", "normalize_path_key", "resolve_path_from_file", "get_file_name", "is_file", "get_assay_folder_path", "get_study_folder_path", "get_workflow_folder_path", "get_run_folder_path"]
+

arctrl/py/Json/Datamap/data_context.py

@@ -0,0 +1,101 @@
+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.util import IEnumerable_1
+from ...fable_modules.thoth_json_core.decode import (object, IRequiredGetter, IOptionalGetter, string, IGetters)
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ...Core.data import Data
+from ...Core.data_context import (DataContext__get_Explication, DataContext__get_Unit, DataContext__get_ObjectType, DataContext__get_Description, DataContext__get_GeneratedBy, DataContext__get_Label, DataContext, DataContext__ctor_Z780A8A2A)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ..data import (encoder as encoder_1, decoder as decoder_1)
+from ..encode import try_include
+from ..ontology_annotation import (OntologyAnnotation_encoder, OntologyAnnotation_decoder)
+
+__A_ = TypeVar("__A_")
+
+def encoder(dc: DataContext) -> IEncodable:
+    def chooser(tupled_arg: tuple[str, IEncodable | None], dc: Any=dc) -> 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 _arrow3443(oa: OntologyAnnotation, dc: Any=dc) -> IEncodable:
+        return OntologyAnnotation_encoder(oa)
+
+    def _arrow3444(oa_1: OntologyAnnotation, dc: Any=dc) -> IEncodable:
+        return OntologyAnnotation_encoder(oa_1)
+
+    def _arrow3445(oa_2: OntologyAnnotation, dc: Any=dc) -> IEncodable:
+        return OntologyAnnotation_encoder(oa_2)
+
+    def _arrow3447(value: str, dc: Any=dc) -> IEncodable:
+        class ObjectExpr3446(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr3446()
+
+    def _arrow3449(value_2: str, dc: Any=dc) -> IEncodable:
+        class ObjectExpr3448(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_1.encode_string(value_2)
+
+        return ObjectExpr3448()
+
+    def _arrow3451(value_4: str, dc: Any=dc) -> IEncodable:
+        class ObjectExpr3450(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_2.encode_string(value_4)
+
+        return ObjectExpr3450()
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([("data", encoder_1(dc)), try_include("explication", _arrow3443, DataContext__get_Explication(dc)), try_include("unit", _arrow3444, DataContext__get_Unit(dc)), try_include("objectType", _arrow3445, DataContext__get_ObjectType(dc)), try_include("description", _arrow3447, DataContext__get_Description(dc)), try_include("generatedBy", _arrow3449, DataContext__get_GeneratedBy(dc)), try_include("label", _arrow3451, DataContext__get_Label(dc))]))
+    class ObjectExpr3452(IEncodable):
+        def Encode(self, helpers_3: IEncoderHelpers_1[Any], dc: Any=dc) -> Any:
+            def mapping_1(tupled_arg_1: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg_1[0], tupled_arg_1[1].Encode(helpers_3))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+            return helpers_3.encode_object(arg)
+
+    return ObjectExpr3452()
+
+
+def _arrow3463(get: IGetters) -> DataContext:
+    data: Data
+    object_arg: IRequiredGetter = get.Required
+    data = object_arg.Field("data", decoder_1)
+    def _arrow3453(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("explication", OntologyAnnotation_decoder)
+
+    def _arrow3454(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("unit", OntologyAnnotation_decoder)
+
+    def _arrow3455(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_3: IOptionalGetter = get.Optional
+        return object_arg_3.Field("objectType", OntologyAnnotation_decoder)
+
+    def _arrow3456(__unit: None=None) -> str | None:
+        object_arg_4: IOptionalGetter = get.Optional
+        return object_arg_4.Field("label", string)
+
+    def _arrow3461(__unit: None=None) -> str | None:
+        object_arg_5: IOptionalGetter = get.Optional
+        return object_arg_5.Field("description", string)
+
+    def _arrow3462(__unit: None=None) -> str | None:
+        object_arg_6: IOptionalGetter = get.Optional
+        return object_arg_6.Field("generatedBy", string)
+
+    return DataContext__ctor_Z780A8A2A(data.ID, data.Name, data.DataType, data.Format, data.SelectorFormat, _arrow3453(), _arrow3454(), _arrow3455(), _arrow3456(), _arrow3461(), _arrow3462(), data.Comments)
+
+
+decoder: Decoder_1[DataContext] = object(_arrow3463)
+
+__all__ = ["encoder", "decoder"]
+

arctrl/py/Json/Datamap/datamap.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.seq import map
+from ...fable_modules.fable_library.types import Array
+from ...fable_modules.fable_library.util import (to_enumerable, IEnumerable_1)
+from ...fable_modules.thoth_json_core.decode import (object, resize_array, IRequiredGetter, IGetters)
+from ...fable_modules.thoth_json_core.encode import seq
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ...Core.data_context import DataContext
+from ...Core.datamap import Datamap
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Table.composite_cell import CompositeCell
+from .data_context import (encoder as encoder_1, decoder as decoder_1)
+
+__A_ = TypeVar("__A_")
+
+def encoder(dm: Datamap) -> IEncodable:
+    def mapping(dc: DataContext, dm: Any=dm) -> IEncodable:
+        return encoder_1(dc)
+
+    values_1: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("dataContexts", seq(map(mapping, dm.DataContexts)))])
+    class ObjectExpr3503(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], dm: Any=dm) -> Any:
+            def mapping_1(tupled_arg: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map(mapping_1, values_1)
+            return helpers.encode_object(arg)
+
+    return ObjectExpr3503()
+
+
+def _arrow3507(get: IGetters) -> Datamap:
+    def _arrow3506(__unit: None=None) -> Array[DataContext]:
+        arg_1: Decoder_1[Array[DataContext]] = resize_array(decoder_1)
+        object_arg: IRequiredGetter = get.Required
+        return object_arg.Field("dataContexts", arg_1)
+
+    return Datamap(_arrow3506())
+
+
+decoder: Decoder_1[Datamap] = object(_arrow3507)
+
+def encoder_compressed(string_table: Any, oa_table: Any, cell_table: Any, dm: Datamap) -> IEncodable:
+    return encoder(dm)
+
+
+def decoder_compressed(string_table: Array[str], oa_table: Array[OntologyAnnotation], cell_table: Array[CompositeCell]) -> Decoder_1[Datamap]:
+    return decoder
+
+
+__all__ = ["encoder", "decoder", "encoder_compressed", "decoder_compressed"]
+

arctrl/py/Json/Process/assay_materials.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.list import (FSharpList, choose, of_array)
+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.types import (IEncodable, IEncoderHelpers_1)
+from ...Core.Process.material import Material
+from ...Core.Process.process import Process
+from ...Core.Process.process_sequence import (get_samples, get_materials)
+from ...Core.Process.sample import Sample
+from ..encode import try_include_list
+from .material import ISAJson_encoder as ISAJson_encoder_1
+from .sample import ISAJson_encoder
+
+__A_ = TypeVar("__A_")
+
+def encoder(id_map: Any | None, ps: FSharpList[Process]) -> IEncodable:
+    samples: FSharpList[Sample] = get_samples(ps)
+    materials: FSharpList[Material] = get_materials(ps)
+    def chooser(tupled_arg: tuple[str, IEncodable | None], id_map: Any=id_map, ps: Any=ps) -> 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 _arrow3344(oa: Sample, id_map: Any=id_map, ps: Any=ps) -> IEncodable:
+        return ISAJson_encoder(id_map, oa)
+
+    def _arrow3345(c: Material, id_map: Any=id_map, ps: Any=ps) -> IEncodable:
+        return ISAJson_encoder_1(id_map, c)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include_list("samples", _arrow3344, samples), try_include_list("otherMaterials", _arrow3345, materials)]))
+    class ObjectExpr3346(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], id_map: Any=id_map, ps: Any=ps) -> 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 ObjectExpr3346()
+
+
+__all__ = ["encoder"]
+

arctrl/py/Json/Process/component.py

@@ -0,0 +1,125 @@
+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.component import (Component, Component_createAsPV, Component__get_ComponentName, Component_decomposeName_Z721C83C5)
+from ...Core.value import Value
+from ..decode import Decode_uri
+from ..encode import try_include
+from ..ontology_annotation import (OntologyAnnotation_encoder, OntologyAnnotation_decoder, OntologyAnnotation_ISAJson_encoder, OntologyAnnotation_ISAJson_decoder)
+from ..property_value import (encoder as encoder_2, decoder as decoder_2, gen_id)
+from .value import (encoder as encoder_1, decoder as decoder_1)
+
+__A_ = TypeVar("__A_")
+
+def encoder(value: Component) -> IEncodable:
+    def chooser(tupled_arg: tuple[str, IEncodable | None], value: Any=value) -> 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 _arrow3136(oa: OntologyAnnotation, value: Any=value) -> IEncodable:
+        return OntologyAnnotation_encoder(oa)
+
+    def _arrow3137(value_1: Value, value: Any=value) -> IEncodable:
+        return encoder_1(None, value_1)
+
+    def _arrow3138(oa_1: OntologyAnnotation, value: Any=value) -> IEncodable:
+        return OntologyAnnotation_encoder(oa_1)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("type", _arrow3136, value.ComponentType), try_include("value", _arrow3137, value.ComponentValue), try_include("unit", _arrow3138, value.ComponentUnit)]))
+    class ObjectExpr3139(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], value: Any=value) -> 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 ObjectExpr3139()
+
+
+def _arrow3142(get: IGetters) -> Component:
+    ComponentType: OntologyAnnotation | None
+    object_arg: IOptionalGetter = get.Optional
+    ComponentType = object_arg.Field("type", OntologyAnnotation_decoder)
+    def _arrow3140(__unit: None=None) -> Value | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("value", decoder_1)
+
+    def _arrow3141(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("unit", OntologyAnnotation_decoder)
+
+    return Component(_arrow3140(), _arrow3141(), ComponentType)
+
+
+decoder: Decoder_1[Component] = object(_arrow3142)
+
+ROCrate_encoder: Callable[[Component], IEncodable] = encoder_2
+
+ROCrate_decoder: Decoder_1[Component] = decoder_2(Component_createAsPV)
+
+def ISAJson_genID(c: Component) -> str:
+    return gen_id(c)
+
+
+def ISAJson_encoder(id_map: Any | None, c: Component) -> IEncodable:
+    def chooser(tupled_arg: tuple[str, IEncodable | None], id_map: Any=id_map, c: Any=c) -> 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 _arrow3146(value: str, id_map: Any=id_map, c: Any=c) -> IEncodable:
+        class ObjectExpr3145(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr3145()
+
+    def _arrow3147(oa: OntologyAnnotation, id_map: Any=id_map, c: Any=c) -> IEncodable:
+        return OntologyAnnotation_ISAJson_encoder(id_map, oa)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("componentName", _arrow3146, Component__get_ComponentName(c)), try_include("componentType", _arrow3147, c.ComponentType)]))
+    class ObjectExpr3148(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], id_map: Any=id_map, c: Any=c) -> 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 ObjectExpr3148()
+
+
+def _arrow3150(get: IGetters) -> Component:
+    name: str | None
+    object_arg: IOptionalGetter = get.Optional
+    name = object_arg.Field("componentName", Decode_uri)
+    pattern_input_1: tuple[Value | None, OntologyAnnotation | None]
+    if name is None:
+        pattern_input_1 = (None, None)
+
+    else: 
+        pattern_input: tuple[Value, OntologyAnnotation | None] = Component_decomposeName_Z721C83C5(name)
+        pattern_input_1 = (pattern_input[0], pattern_input[1])
+
+    def _arrow3149(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("componentType", OntologyAnnotation_ISAJson_decoder)
+
+    return Component(pattern_input_1[0], pattern_input_1[1], _arrow3149())
+
+
+ISAJson_decoder: Decoder_1[Component] = object(_arrow3150)
+
+__all__ = ["encoder", "decoder", "ROCrate_encoder", "ROCrate_decoder", "ISAJson_genID", "ISAJson_encoder", "ISAJson_decoder"]
+