arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/JsonIO/Process/process_sequence.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...Core.Process.process import Process
+from ...Json.encode import default_spaces
+from ...Json.Process.process import (ISAJson_decoder, ISAJson_encoder, ROCrate_decoder, ROCrate_encoder)
+from ...fable_modules.fable_library.list import (FSharpList, map)
+from ...fable_modules.fable_library.option import default_arg
+from ...fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ...fable_modules.fable_library.result import FSharpResult_2
+from ...fable_modules.fable_library.string_ import (to_text, printf)
+from ...fable_modules.thoth_json_core.decode import list_1 as list_1_1
+from ...fable_modules.thoth_json_core.encode import list_1 as list_1_2
+from ...fable_modules.thoth_json_core.types import IEncodable
+from ...fable_modules.thoth_json_python.decode import Decode_fromString
+from ...fable_modules.thoth_json_python.encode import to_string
+
+def _expr3532() -> TypeInfo:
+    return class_type("ARCtrl.Json.ProcessSequence", None, ProcessSequence)
+
+
+class ProcessSequence:
+    ...
+
+ProcessSequence_reflection = _expr3532
+
+def ProcessSequence_fromISAJsonString_Z721C83C5(s: str) -> FSharpList[Process]:
+    match_value: FSharpResult_2[FSharpList[Process], str] = Decode_fromString(list_1_1(ISAJson_decoder), s)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ProcessSequence_toISAJsonString_Z3B036AA(spaces: int | None=None, use_idreferencing: bool | None=None) -> Callable[[FSharpList[Process]], str]:
+    id_map: Any | None = dict([]) if default_arg(use_idreferencing, False) else None
+    def _arrow3533(f: FSharpList[Process], spaces: Any=spaces, use_idreferencing: Any=use_idreferencing) -> str:
+        def mapping(oa: Process) -> IEncodable:
+            return ISAJson_encoder(None, None, id_map, oa)
+
+        value: IEncodable = list_1_2(map(mapping, f))
+        return to_string(default_spaces(spaces), value)
+
+    return _arrow3533
+
+
+def ProcessSequence_fromROCrateJsonString_Z721C83C5(s: str) -> FSharpList[Process]:
+    match_value: FSharpResult_2[FSharpList[Process], str] = Decode_fromString(list_1_1(ROCrate_decoder), s)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ProcessSequence_toROCrateJsonString_39E0BC3F(study_name: str | None=None, assay_name: str | None=None, spaces: int | None=None) -> Callable[[FSharpList[Process]], str]:
+    def _arrow3534(f: FSharpList[Process], study_name: Any=study_name, assay_name: Any=assay_name, spaces: Any=spaces) -> str:
+        def mapping(oa: Process) -> IEncodable:
+            return ROCrate_encoder(study_name, assay_name, oa)
+
+        value: IEncodable = list_1_2(map(mapping, f))
+        return to_string(default_spaces(spaces), value)
+
+    return _arrow3534
+
+
+__all__ = ["ProcessSequence_reflection", "ProcessSequence_fromISAJsonString_Z721C83C5", "ProcessSequence_toISAJsonString_Z3B036AA", "ProcessSequence_fromROCrateJsonString_Z721C83C5", "ProcessSequence_toROCrateJsonString_39E0BC3F"]
+

arctrl/py/JsonIO/Process/protocol.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...Core.Process.protocol import Protocol
+from ...Json.encode import default_spaces
+from ...Json.Process.protocol import (ISAJson_decoder, ISAJson_encoder, ROCrate_decoder, ROCrate_encoder)
+from ...fable_modules.fable_library.option import default_arg
+from ...fable_modules.fable_library.result import FSharpResult_2
+from ...fable_modules.fable_library.string_ import (to_text, printf)
+from ...fable_modules.thoth_json_core.types import IEncodable
+from ...fable_modules.thoth_json_python.decode import Decode_fromString
+from ...fable_modules.thoth_json_python.encode import to_string
+
+def ARCtrl_Process_Protocol__Protocol_fromISAJsonString_Static_Z721C83C5(s: str) -> Protocol:
+    match_value: FSharpResult_2[Protocol, str] = Decode_fromString(ISAJson_decoder, s)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ARCtrl_Process_Protocol__Protocol_toISAJsonString_Static_Z3B036AA(spaces: int | None=None, use_idreferencing: bool | None=None) -> Callable[[Protocol], str]:
+    id_map: Any | None = dict([]) if default_arg(use_idreferencing, False) else None
+    def _arrow3515(f: Protocol, spaces: Any=spaces, use_idreferencing: Any=use_idreferencing) -> str:
+        value: IEncodable = ISAJson_encoder(None, None, None, id_map, f)
+        return to_string(default_spaces(spaces), value)
+
+    return _arrow3515
+
+
+def ARCtrl_Process_Protocol__Protocol_ToISAJsonString_71136F3F(this: Protocol, spaces: int | None=None) -> str:
+    return ARCtrl_Process_Protocol__Protocol_toISAJsonString_Static_Z3B036AA(spaces)(this)
+
+
+def ARCtrl_Process_Protocol__Protocol_fromROCrateString_Static_Z721C83C5(s: str) -> Protocol:
+    match_value: FSharpResult_2[Protocol, str] = Decode_fromString(ROCrate_decoder, s)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ARCtrl_Process_Protocol__Protocol_toROCrateString_Static_Z482224B9(study_name: str | None=None, assay_name: str | None=None, process_name: str | None=None, spaces: int | None=None) -> Callable[[Protocol], str]:
+    def _arrow3516(f: Protocol, study_name: Any=study_name, assay_name: Any=assay_name, process_name: Any=process_name, spaces: Any=spaces) -> str:
+        value: IEncodable = ROCrate_encoder(study_name, assay_name, process_name, f)
+        return to_string(default_spaces(spaces), value)
+
+    return _arrow3516
+
+
+def ARCtrl_Process_Protocol__Protocol_ToROCrateString_Z482224B9(this: Protocol, study_name: str | None=None, assay_name: str | None=None, process_name: str | None=None, spaces: int | None=None) -> str:
+    return ARCtrl_Process_Protocol__Protocol_toROCrateString_Static_Z482224B9(study_name, assay_name, process_name, spaces)(this)
+
+
+__all__ = ["ARCtrl_Process_Protocol__Protocol_fromISAJsonString_Static_Z721C83C5", "ARCtrl_Process_Protocol__Protocol_toISAJsonString_Static_Z3B036AA", "ARCtrl_Process_Protocol__Protocol_ToISAJsonString_71136F3F", "ARCtrl_Process_Protocol__Protocol_fromROCrateString_Static_Z721C83C5", "ARCtrl_Process_Protocol__Protocol_toROCrateString_Static_Z482224B9", "ARCtrl_Process_Protocol__Protocol_ToROCrateString_Z482224B9"]
+

arctrl/py/JsonIO/Process/protocol_parameter.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...Core.Process.protocol_parameter import ProtocolParameter
+from ...Json.encode import default_spaces
+from ...Json.Process.protocol_parameter import (decoder as decoder_1, encoder)
+from ...fable_modules.fable_library.result import FSharpResult_2
+from ...fable_modules.fable_library.string_ import (to_text, printf)
+from ...fable_modules.thoth_json_core.types import IEncodable
+from ...fable_modules.thoth_json_python.decode import Decode_fromString
+from ...fable_modules.thoth_json_python.encode import to_string
+
+def ARCtrl_Process_ProtocolParameter__ProtocolParameter_fromISAJsonString_Static_Z721C83C5(s: str) -> ProtocolParameter:
+    match_value: FSharpResult_2[ProtocolParameter, str] = Decode_fromString(decoder_1, s)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ARCtrl_Process_ProtocolParameter__ProtocolParameter_toISAJsonString_Static_71136F3F(spaces: int | None=None) -> Callable[[ProtocolParameter], str]:
+    def _arrow3510(v: ProtocolParameter, spaces: Any=spaces) -> str:
+        value: IEncodable = encoder(None, v)
+        return to_string(default_spaces(spaces), value)
+
+    return _arrow3510
+
+
+def ARCtrl_Process_ProtocolParameter__ProtocolParameter_ToISAJsonString_71136F3F(this: ProtocolParameter, spaces: int | None=None) -> str:
+    return ARCtrl_Process_ProtocolParameter__ProtocolParameter_toISAJsonString_Static_71136F3F(spaces)(this)
+
+
+__all__ = ["ARCtrl_Process_ProtocolParameter__ProtocolParameter_fromISAJsonString_Static_Z721C83C5", "ARCtrl_Process_ProtocolParameter__ProtocolParameter_toISAJsonString_Static_71136F3F", "ARCtrl_Process_ProtocolParameter__ProtocolParameter_ToISAJsonString_71136F3F"]
+

arctrl/py/JsonIO/Process/sample.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...Core.Process.sample import Sample
+from ...Json.encode import default_spaces
+from ...Json.Process.sample import (ISAJson_decoder, ISAJson_encoder, ROCrate_decoder, ROCrate_encoder)
+from ...fable_modules.fable_library.option import default_arg
+from ...fable_modules.fable_library.result import FSharpResult_2
+from ...fable_modules.fable_library.string_ import (to_text, printf)
+from ...fable_modules.thoth_json_core.types import IEncodable
+from ...fable_modules.thoth_json_python.decode import Decode_fromString
+from ...fable_modules.thoth_json_python.encode import to_string
+
+def ARCtrl_Process_Sample__Sample_fromISAJsonString_Static_Z721C83C5(s: str) -> Sample:
+    match_value: FSharpResult_2[Sample, str] = Decode_fromString(ISAJson_decoder, s)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ARCtrl_Process_Sample__Sample_toISAJsonString_Static_Z3B036AA(spaces: int | None=None, use_idreferencing: bool | None=None) -> Callable[[Sample], str]:
+    id_map: Any | None = dict([]) if default_arg(use_idreferencing, False) else None
+    def _arrow3523(f: Sample, spaces: Any=spaces, use_idreferencing: Any=use_idreferencing) -> str:
+        value_1: IEncodable = ISAJson_encoder(id_map, f)
+        return to_string(default_spaces(spaces), value_1)
+
+    return _arrow3523
+
+
+def ARCtrl_Process_Sample__Sample_ToISAJsonString_Z3B036AA(this: Sample, spaces: int | None=None, use_idreferencing: bool | None=None) -> str:
+    return ARCtrl_Process_Sample__Sample_toISAJsonString_Static_Z3B036AA(spaces, use_idreferencing)(this)
+
+
+def ARCtrl_Process_Sample__Sample_fromROCrateString_Static_Z721C83C5(s: str) -> Sample:
+    match_value: FSharpResult_2[Sample, str] = Decode_fromString(ROCrate_decoder, s)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ARCtrl_Process_Sample__Sample_toROCrateString_Static_71136F3F(spaces: int | None=None) -> Callable[[Sample], str]:
+    def _arrow3524(f: Sample, spaces: Any=spaces) -> str:
+        value: IEncodable = ROCrate_encoder(f)
+        return to_string(default_spaces(spaces), value)
+
+    return _arrow3524
+
+
+def ARCtrl_Process_Sample__Sample_ToROCrateString_71136F3F(this: Sample, spaces: int | None=None) -> str:
+    return ARCtrl_Process_Sample__Sample_toROCrateString_Static_71136F3F(spaces)(this)
+
+
+__all__ = ["ARCtrl_Process_Sample__Sample_fromISAJsonString_Static_Z721C83C5", "ARCtrl_Process_Sample__Sample_toISAJsonString_Static_Z3B036AA", "ARCtrl_Process_Sample__Sample_ToISAJsonString_Z3B036AA", "ARCtrl_Process_Sample__Sample_fromROCrateString_Static_Z721C83C5", "ARCtrl_Process_Sample__Sample_toROCrateString_Static_71136F3F", "ARCtrl_Process_Sample__Sample_ToROCrateString_71136F3F"]
+

arctrl/py/JsonIO/Process/source.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...Core.Process.source import Source
+from ...Json.encode import default_spaces
+from ...Json.Process.source import (ISAJson_decoder, ISAJson_encoder, ROCrate_decoder, ROCrate_encoder)
+from ...fable_modules.fable_library.option import default_arg
+from ...fable_modules.fable_library.result import FSharpResult_2
+from ...fable_modules.fable_library.string_ import (to_text, printf)
+from ...fable_modules.thoth_json_core.types import IEncodable
+from ...fable_modules.thoth_json_python.decode import Decode_fromString
+from ...fable_modules.thoth_json_python.encode import to_string
+
+def ARCtrl_Process_Source__Source_fromISAJsonString_Static_Z721C83C5(s: str) -> Source:
+    match_value: FSharpResult_2[Source, str] = Decode_fromString(ISAJson_decoder, s)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ARCtrl_Process_Source__Source_toISAJsonString_Static_Z3B036AA(spaces: int | None=None, use_idreferencing: bool | None=None) -> Callable[[Source], str]:
+    id_map: Any | None = dict([]) if default_arg(use_idreferencing, False) else None
+    def _arrow3521(f: Source, spaces: Any=spaces, use_idreferencing: Any=use_idreferencing) -> str:
+        value_1: IEncodable = ISAJson_encoder(id_map, f)
+        return to_string(default_spaces(spaces), value_1)
+
+    return _arrow3521
+
+
+def ARCtrl_Process_Source__Source_ToISAJsonString_Z3B036AA(this: Source, spaces: int | None=None, use_idreferencing: bool | None=None) -> str:
+    return ARCtrl_Process_Source__Source_toISAJsonString_Static_Z3B036AA(spaces, use_idreferencing)(this)
+
+
+def ARCtrl_Process_Source__Source_fromROCrateString_Static_Z721C83C5(s: str) -> Source:
+    match_value: FSharpResult_2[Source, str] = Decode_fromString(ROCrate_decoder, s)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ARCtrl_Process_Source__Source_toROCrateString_Static_71136F3F(spaces: int | None=None) -> Callable[[Source], str]:
+    def _arrow3522(f: Source, spaces: Any=spaces) -> str:
+        value: IEncodable = ROCrate_encoder(f)
+        return to_string(default_spaces(spaces), value)
+
+    return _arrow3522
+
+
+def ARCtrl_Process_Source__Source_ToROCrateString_71136F3F(this: Source, spaces: int | None=None) -> str:
+    return ARCtrl_Process_Source__Source_toROCrateString_Static_71136F3F(spaces)(this)
+
+
+__all__ = ["ARCtrl_Process_Source__Source_fromISAJsonString_Static_Z721C83C5", "ARCtrl_Process_Source__Source_toISAJsonString_Static_Z3B036AA", "ARCtrl_Process_Source__Source_ToISAJsonString_Z3B036AA", "ARCtrl_Process_Source__Source_fromROCrateString_Static_Z721C83C5", "ARCtrl_Process_Source__Source_toROCrateString_Static_71136F3F", "ARCtrl_Process_Source__Source_ToROCrateString_71136F3F"]
+

arctrl/py/JsonIO/Process/study_materials.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...Core.Process.material import Material
+from ...Core.Process.process import Process
+from ...Core.Process.process_sequence import (get_sources, get_samples, get_materials)
+from ...Core.Process.sample import Sample
+from ...Core.Process.source import Source
+from ...Json.encode import try_include_list
+from ...Json.Process.material import ISAJson_encoder as ISAJson_encoder_2
+from ...Json.Process.sample import ISAJson_encoder as ISAJson_encoder_1
+from ...Json.Process.source import ISAJson_encoder
+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)
+
+__A_ = TypeVar("__A_")
+
+def encoder(id_map: Any | None, ps: FSharpList[Process]) -> IEncodable:
+    source: FSharpList[Source] = get_sources(ps)
+    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 _arrow3536(oa: Source, id_map: Any=id_map, ps: Any=ps) -> IEncodable:
+        return ISAJson_encoder(id_map, oa)
+
+    def _arrow3537(oa_1: Sample, id_map: Any=id_map, ps: Any=ps) -> IEncodable:
+        return ISAJson_encoder_1(id_map, oa_1)
+
+    def _arrow3538(c: Material, id_map: Any=id_map, ps: Any=ps) -> IEncodable:
+        return ISAJson_encoder_2(id_map, c)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include_list("sources", _arrow3536, source), try_include_list("samples", _arrow3537, samples), try_include_list("otherMaterials", _arrow3538, materials)]))
+    class ObjectExpr3539(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 ObjectExpr3539()
+
+
+__all__ = ["encoder"]
+

arctrl/py/JsonIO/Process/value.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...Core.value import Value
+from ...Json.encode import default_spaces
+from ...Json.Process.value import (decoder as decoder_1, encoder)
+from ...fable_modules.fable_library.result import FSharpResult_2
+from ...fable_modules.fable_library.string_ import (to_text, printf)
+from ...fable_modules.thoth_json_core.types import IEncodable
+from ...fable_modules.thoth_json_python.decode import Decode_fromString
+from ...fable_modules.thoth_json_python.encode import to_string
+
+def ARCtrl_Value__Value_fromISAJsonString_Static_Z721C83C5(s: str) -> Value:
+    match_value: FSharpResult_2[Value, str] = Decode_fromString(decoder_1, s)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ARCtrl_Value__Value_toISAJsonString_Static_71136F3F(spaces: int | None=None) -> Callable[[Value], str]:
+    def _arrow3507(v: Value, spaces: Any=spaces) -> str:
+        value: IEncodable = encoder(None, v)
+        return to_string(default_spaces(spaces), value)
+
+    return _arrow3507
+
+
+__all__ = ["ARCtrl_Value__Value_fromISAJsonString_Static_Z721C83C5", "ARCtrl_Value__Value_toISAJsonString_Static_71136F3F"]
+

arctrl/py/JsonIO/Table/arc_table.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Table.arc_table import ArcTable
+from ...Core.Table.composite_cell import CompositeCell
+from ...Json.encode import default_spaces
+from ...Json.string_table import (decoder as decoder_3, encoder as encoder_3, array_from_map as array_from_map_2)
+from ...Json.Table.arc_table import (decoder as decoder_2, encoder, decoder_compressed, encoder_compressed)
+from ...Json.Table.cell_table import (decoder as decoder_5, encoder as encoder_1, array_from_map)
+from ...Json.Table.oatable import (decoder as decoder_4, encoder as encoder_2, array_from_map as array_from_map_1)
+from ...fable_modules.fable_library.mutable_map import Dictionary
+from ...fable_modules.fable_library.result import FSharpResult_2
+from ...fable_modules.fable_library.seq import map
+from ...fable_modules.fable_library.string_ import (to_text, printf)
+from ...fable_modules.fable_library.types import Array
+from ...fable_modules.fable_library.util import (equals, safe_hash, to_enumerable, IEnumerable_1)
+from ...fable_modules.thoth_json_core.decode import (object, IRequiredGetter, IGetters)
+from ...fable_modules.thoth_json_core.types import (IEncodable, Decoder_1, IEncoderHelpers_1)
+from ...fable_modules.thoth_json_python.decode import Decode_fromString
+from ...fable_modules.thoth_json_python.encode import to_string
+
+__A_ = TypeVar("__A_")
+
+def ARCtrl_ArcTable__ArcTable_fromJsonString_Static_Z721C83C5(s: str) -> ArcTable:
+    match_value: FSharpResult_2[ArcTable, str] = Decode_fromString(decoder_2, s)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ARCtrl_ArcTable__ArcTable_toJsonString_Static_71136F3F(spaces: int | None=None) -> Callable[[ArcTable], str]:
+    def _arrow3548(obj: ArcTable, spaces: Any=spaces) -> str:
+        value: IEncodable = encoder(obj)
+        return to_string(default_spaces(spaces), value)
+
+    return _arrow3548
+
+
+def ARCtrl_ArcTable__ArcTable_ToJsonString_71136F3F(this: ArcTable, spaces: int | None=None) -> str:
+    return ARCtrl_ArcTable__ArcTable_toJsonString_Static_71136F3F(spaces)(this)
+
+
+def ARCtrl_ArcTable__ArcTable_fromCompressedJsonString_Static_Z721C83C5(json_string: str) -> ArcTable:
+    def _arrow3550(get: IGetters, json_string: Any=json_string) -> ArcTable:
+        string_table: Array[str]
+        object_arg: IRequiredGetter = get.Required
+        string_table = object_arg.Field("stringTable", decoder_3)
+        oa_table: Array[OntologyAnnotation]
+        arg_3: Decoder_1[Array[OntologyAnnotation]] = decoder_4(string_table)
+        object_arg_1: IRequiredGetter = get.Required
+        oa_table = object_arg_1.Field("oaTable", arg_3)
+        def _arrow3549(__unit: None=None) -> Array[CompositeCell]:
+            arg_5: Decoder_1[Array[CompositeCell]] = decoder_5(string_table, oa_table)
+            object_arg_2: IRequiredGetter = get.Required
+            return object_arg_2.Field("cellTable", arg_5)
+
+        arg_7: Decoder_1[ArcTable] = decoder_compressed(string_table, oa_table, _arrow3549())
+        object_arg_3: IRequiredGetter = get.Required
+        return object_arg_3.Field("table", arg_7)
+
+    match_value: FSharpResult_2[ArcTable, str] = Decode_fromString(object(_arrow3550), json_string)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ARCtrl_ArcTable__ArcTable_ToCompressedJsonString_71136F3F(this: ArcTable, spaces: int | None=None) -> str:
+    spaces_1: int = default_spaces(spaces) or 0
+    string_table: Any = dict([])
+    class ObjectExpr3551:
+        @property
+        def Equals(self) -> Callable[[OntologyAnnotation, OntologyAnnotation], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[OntologyAnnotation], int]:
+            return safe_hash
+
+    oa_table: Any = Dictionary([], ObjectExpr3551())
+    class ObjectExpr3552:
+        @property
+        def Equals(self) -> Callable[[CompositeCell, CompositeCell], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[CompositeCell], int]:
+            return safe_hash
+
+    cell_table: Any = Dictionary([], ObjectExpr3552())
+    arc_table: IEncodable = encoder_compressed(string_table, oa_table, cell_table, this)
+    def _arrow3554(__unit: None=None, this: Any=this, spaces: Any=spaces) -> IEncodable:
+        values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("cellTable", encoder_1(string_table, oa_table, array_from_map(cell_table))), ("oaTable", encoder_2(string_table, array_from_map_1(oa_table))), ("stringTable", encoder_3(array_from_map_2(string_table))), ("table", arc_table)])
+        class ObjectExpr3553(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                def mapping(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, values)
+                return helpers.encode_object(arg)
+
+        return ObjectExpr3553()
+
+    return to_string(spaces_1, _arrow3554())
+
+
+def ARCtrl_ArcTable__ArcTable_toCompressedJsonString_Static_71136F3F(spaces: int | None=None) -> Callable[[ArcTable], str]:
+    def _arrow3555(obj: ArcTable, spaces: Any=spaces) -> str:
+        return ARCtrl_ArcTable__ArcTable_ToCompressedJsonString_71136F3F(obj, spaces)
+
+    return _arrow3555
+
+
+__all__ = ["ARCtrl_ArcTable__ArcTable_fromJsonString_Static_Z721C83C5", "ARCtrl_ArcTable__ArcTable_toJsonString_Static_71136F3F", "ARCtrl_ArcTable__ArcTable_ToJsonString_71136F3F", "ARCtrl_ArcTable__ArcTable_fromCompressedJsonString_Static_Z721C83C5", "ARCtrl_ArcTable__ArcTable_ToCompressedJsonString_71136F3F", "ARCtrl_ArcTable__ArcTable_toCompressedJsonString_Static_71136F3F"]
+

arctrl/py/JsonIO/Table/composite_cell.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...Core.Table.composite_cell import CompositeCell
+from ...Json.encode import default_spaces
+from ...Json.Table.composite_cell import (decoder as decoder_1, encoder)
+from ...fable_modules.fable_library.result import FSharpResult_2
+from ...fable_modules.fable_library.string_ import (to_text, printf)
+from ...fable_modules.thoth_json_core.types import IEncodable
+from ...fable_modules.thoth_json_python.decode import Decode_fromString
+from ...fable_modules.thoth_json_python.encode import to_string
+
+def ARCtrl_CompositeCell__CompositeCell_fromJsonString_Static_Z721C83C5(s: str) -> CompositeCell:
+    match_value: FSharpResult_2[CompositeCell, str] = Decode_fromString(decoder_1, s)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ARCtrl_CompositeCell__CompositeCell_toJsonString_Static_71136F3F(spaces: int | None=None) -> Callable[[CompositeCell], str]:
+    def _arrow3545(obj: CompositeCell, spaces: Any=spaces) -> str:
+        value: IEncodable = encoder(obj)
+        return to_string(default_spaces(spaces), value)
+
+    return _arrow3545
+
+
+def ARCtrl_CompositeCell__CompositeCell_ToJsonString_71136F3F(this: CompositeCell, spaces: int | None=None) -> str:
+    return ARCtrl_CompositeCell__CompositeCell_toJsonString_Static_71136F3F(spaces)(this)
+
+
+__all__ = ["ARCtrl_CompositeCell__CompositeCell_fromJsonString_Static_Z721C83C5", "ARCtrl_CompositeCell__CompositeCell_toJsonString_Static_71136F3F", "ARCtrl_CompositeCell__CompositeCell_ToJsonString_71136F3F"]
+

arctrl/py/JsonIO/Table/composite_header.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...Core.Table.composite_header import CompositeHeader
+from ...Json.encode import default_spaces
+from ...Json.Table.composite_header import (decoder as decoder_1, encoder)
+from ...fable_modules.fable_library.result import FSharpResult_2
+from ...fable_modules.fable_library.string_ import (to_text, printf)
+from ...fable_modules.thoth_json_core.types import IEncodable
+from ...fable_modules.thoth_json_python.decode import Decode_fromString
+from ...fable_modules.thoth_json_python.encode import to_string
+
+def ARCtrl_CompositeHeader__CompositeHeader_fromJsonString_Static_Z721C83C5(s: str) -> CompositeHeader:
+    match_value: FSharpResult_2[CompositeHeader, str] = Decode_fromString(decoder_1, s)
+    if match_value.tag == 1:
+        raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+    else: 
+        return match_value.fields[0]
+
+
+
+def ARCtrl_CompositeHeader__CompositeHeader_toJsonString_Static_71136F3F(spaces: int | None=None) -> Callable[[CompositeHeader], str]:
+    def _arrow3547(obj: CompositeHeader, spaces: Any=spaces) -> str:
+        value: IEncodable = encoder(obj)
+        return to_string(default_spaces(spaces), value)
+
+    return _arrow3547
+
+
+def ARCtrl_CompositeHeader__CompositeHeader_ToJsonString_71136F3F(this: CompositeHeader, spaces: int | None=None) -> str:
+    return ARCtrl_CompositeHeader__CompositeHeader_toJsonString_Static_71136F3F(spaces)(this)
+
+
+__all__ = ["ARCtrl_CompositeHeader__CompositeHeader_fromJsonString_Static_Z721C83C5", "ARCtrl_CompositeHeader__CompositeHeader_toJsonString_Static_71136F3F", "ARCtrl_CompositeHeader__CompositeHeader_ToJsonString_71136F3F"]
+

arctrl/py/JsonIO/Table/compression.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Table.composite_cell import CompositeCell
+from ...Json.string_table import (encoder as encoder_3, array_from_map as array_from_map_2, decoder as decoder_1)
+from ...Json.Table.cell_table import (encoder as encoder_1, array_from_map, decoder as decoder_3)
+from ...Json.Table.oatable import (encoder as encoder_2, array_from_map as array_from_map_1, decoder as decoder_2)
+from ...fable_modules.fable_library.mutable_map import Dictionary
+from ...fable_modules.fable_library.seq import map
+from ...fable_modules.fable_library.types import Array
+from ...fable_modules.fable_library.util import (equals, safe_hash, ignore, to_enumerable, IEnumerable_1)
+from ...fable_modules.thoth_json_core.decode import (object as object_1, IRequiredGetter, IGetters)
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ...fable_modules.thoth_json_python.encode import to_string
+
+__A_ = TypeVar("__A_")
+
+_A = TypeVar("_A")
+
+__A = TypeVar("__A")
+
+__B = TypeVar("__B")
+
+def encode(encoder: Callable[[Any, Any, Any, _A], IEncodable], obj: Any) -> IEncodable:
+    string_table: Any = dict([])
+    class ObjectExpr3540:
+        @property
+        def Equals(self) -> Callable[[OntologyAnnotation, OntologyAnnotation], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[OntologyAnnotation], int]:
+            return safe_hash
+
+    oa_table: Any = Dictionary([], ObjectExpr3540())
+    class ObjectExpr3541:
+        @property
+        def Equals(self) -> Callable[[CompositeCell, CompositeCell], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[CompositeCell], int]:
+            return safe_hash
+
+    cell_table: Any = Dictionary([], ObjectExpr3541())
+    object: IEncodable = encoder(string_table, oa_table, cell_table, obj)
+    ignore(to_string(0, object))
+    encoded_cell_table: IEncodable = encoder_1(string_table, oa_table, array_from_map(cell_table))
+    encoded_oatable: IEncodable = encoder_2(string_table, array_from_map_1(oa_table))
+    encoded_string_table: IEncodable = encoder_3(array_from_map_2(string_table))
+    class ObjectExpr3542(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], encoder: Any=encoder, obj: Any=obj) -> Any:
+            def mapping(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, to_enumerable([("cellTable", encoded_cell_table), ("oaTable", encoded_oatable), ("stringTable", encoded_string_table), ("object", object)]))
+            return helpers.encode_object(arg)
+
+    return ObjectExpr3542()
+
+
+def decode(decoder: Callable[[Array[str], Array[OntologyAnnotation], Array[CompositeCell]], __A]) -> Decoder_1[Any]:
+    def _arrow3544(get: IGetters, decoder: Any=decoder) -> __B:
+        string_table: Array[str]
+        object_arg: IRequiredGetter = get.Required
+        string_table = object_arg.Field("stringTable", decoder_1)
+        oa_table: Array[OntologyAnnotation]
+        arg_3: Decoder_1[Array[OntologyAnnotation]] = decoder_2(string_table)
+        object_arg_1: IRequiredGetter = get.Required
+        oa_table = object_arg_1.Field("oaTable", arg_3)
+        def _arrow3543(__unit: None=None) -> Array[CompositeCell]:
+            arg_5: Decoder_1[Array[CompositeCell]] = decoder_3(string_table, oa_table)
+            object_arg_2: IRequiredGetter = get.Required
+            return object_arg_2.Field("cellTable", arg_5)
+
+        arg_7: __A = decoder(string_table, oa_table, _arrow3543())
+        object_arg_3: IRequiredGetter = get.Required
+        return object_arg_3.Field("object", arg_7)
+
+    return object_1(_arrow3544)
+
+
+__all__ = ["encode", "decode"]
+