arctrl 3.0.0__py3-none-any.whl

arctrl/py/Json/Table/composite_cell.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.list import (singleton, of_array, FSharpList)
+from ...fable_modules.fable_library.seq import map
+from ...fable_modules.fable_library.string_ import (to_fail, printf)
+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, IRequiredGetter, string, index, IGetters)
+from ...fable_modules.thoth_json_core.encode import list_1
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ...Core.data import Data
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Table.composite_cell import CompositeCell
+from ..data import (encoder as encoder_1, decoder as decoder_5, compressed_encoder, compressed_decoder)
+from ..ontology_annotation import (OntologyAnnotation_encoder, OntologyAnnotation_decoder)
+from ..string_table import (encode_string, decode_string)
+from .oatable import (encode_oa, decode_oa)
+
+__A_ = TypeVar("__A_")
+
+def encoder(cc: CompositeCell) -> IEncodable:
+    def oa_to_json_string(oa: OntologyAnnotation, cc: Any=cc) -> IEncodable:
+        return OntologyAnnotation_encoder(oa)
+
+    class ObjectExpr3415(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], cc: Any=cc) -> Any:
+            return helpers_1.encode_string(cc.fields[0])
+
+    class ObjectExpr3416(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], cc: Any=cc) -> Any:
+            return helpers.encode_string(cc.fields[0])
+
+    pattern_input: tuple[str, FSharpList[IEncodable]] = (("Term", singleton(oa_to_json_string(cc.fields[0])))) if (cc.tag == 0) else ((("Unitized", of_array([ObjectExpr3415(), oa_to_json_string(cc.fields[1])]))) if (cc.tag == 2) else ((("Data", singleton(encoder_1(cc.fields[0])))) if (cc.tag == 3) else (("FreeText", singleton(ObjectExpr3416())))))
+    class ObjectExpr3417(IEncodable):
+        def Encode(self, helpers_2: IEncoderHelpers_1[Any], cc: Any=cc) -> Any:
+            return helpers_2.encode_string(pattern_input[0])
+
+    values_1: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("celltype", ObjectExpr3417()), ("values", list_1(pattern_input[1]))])
+    class ObjectExpr3418(IEncodable):
+        def Encode(self, helpers_3: IEncoderHelpers_1[Any], cc: Any=cc) -> Any:
+            def mapping(tupled_arg: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers_3))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map(mapping, values_1)
+            return helpers_3.encode_object(arg)
+
+    return ObjectExpr3418()
+
+
+def _arrow3424(get: IGetters) -> CompositeCell:
+    match_value: str
+    object_arg: IRequiredGetter = get.Required
+    match_value = object_arg.Field("celltype", string)
+    def _arrow3419(__unit: None=None) -> str:
+        arg_3: Decoder_1[str] = index(0, string)
+        object_arg_1: IRequiredGetter = get.Required
+        return object_arg_1.Field("values", arg_3)
+
+    def _arrow3420(__unit: None=None) -> OntologyAnnotation:
+        arg_5: Decoder_1[OntologyAnnotation] = index(0, OntologyAnnotation_decoder)
+        object_arg_2: IRequiredGetter = get.Required
+        return object_arg_2.Field("values", arg_5)
+
+    def _arrow3421(__unit: None=None) -> str:
+        arg_7: Decoder_1[str] = index(0, string)
+        object_arg_3: IRequiredGetter = get.Required
+        return object_arg_3.Field("values", arg_7)
+
+    def _arrow3422(__unit: None=None) -> OntologyAnnotation:
+        arg_9: Decoder_1[OntologyAnnotation] = index(1, OntologyAnnotation_decoder)
+        object_arg_4: IRequiredGetter = get.Required
+        return object_arg_4.Field("values", arg_9)
+
+    def _arrow3423(__unit: None=None) -> Data:
+        arg_11: Decoder_1[Data] = index(0, decoder_5)
+        object_arg_5: IRequiredGetter = get.Required
+        return object_arg_5.Field("values", arg_11)
+
+    return CompositeCell(1, _arrow3419()) if (match_value == "FreeText") else (CompositeCell(0, _arrow3420()) if (match_value == "Term") else (CompositeCell(2, _arrow3421(), _arrow3422()) if (match_value == "Unitized") else (CompositeCell(3, _arrow3423()) if (match_value == "Data") else to_fail(printf("Error reading CompositeCell from json string: %A"))(match_value))))
+
+
+decoder: Decoder_1[CompositeCell] = object(_arrow3424)
+
+def encoder_compressed(string_table: Any, oa_table: Any, cc: CompositeCell) -> IEncodable:
+    pattern_input: tuple[str, FSharpList[IEncodable]] = (("Term", singleton(encode_oa(oa_table, cc.fields[0])))) if (cc.tag == 0) else ((("Unitized", of_array([encode_string(string_table, cc.fields[0]), encode_oa(oa_table, cc.fields[1])]))) if (cc.tag == 2) else ((("Data", singleton(compressed_encoder(string_table, cc.fields[0])))) if (cc.tag == 3) else (("FreeText", singleton(encode_string(string_table, cc.fields[0]))))))
+    values_1: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("t", encode_string(string_table, pattern_input[0])), ("v", list_1(pattern_input[1]))])
+    class ObjectExpr3425(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], string_table: Any=string_table, oa_table: Any=oa_table, cc: Any=cc) -> 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_1)
+            return helpers.encode_object(arg)
+
+    return ObjectExpr3425()
+
+
+def decoder_compressed(string_table: Array[str], oa_table: Array[OntologyAnnotation]) -> Decoder_1[CompositeCell]:
+    def _arrow3431(get: IGetters, string_table: Any=string_table, oa_table: Any=oa_table) -> CompositeCell:
+        match_value: str
+        arg_1: Decoder_1[str] = decode_string(string_table)
+        object_arg: IRequiredGetter = get.Required
+        match_value = object_arg.Field("t", arg_1)
+        def _arrow3426(__unit: None=None) -> str:
+            arg_3: Decoder_1[str] = index(0, decode_string(string_table))
+            object_arg_1: IRequiredGetter = get.Required
+            return object_arg_1.Field("v", arg_3)
+
+        def _arrow3427(__unit: None=None) -> OntologyAnnotation:
+            arg_5: Decoder_1[OntologyAnnotation] = index(0, decode_oa(oa_table))
+            object_arg_2: IRequiredGetter = get.Required
+            return object_arg_2.Field("v", arg_5)
+
+        def _arrow3428(__unit: None=None) -> str:
+            arg_7: Decoder_1[str] = index(0, decode_string(string_table))
+            object_arg_3: IRequiredGetter = get.Required
+            return object_arg_3.Field("v", arg_7)
+
+        def _arrow3429(__unit: None=None) -> OntologyAnnotation:
+            arg_9: Decoder_1[OntologyAnnotation] = index(1, decode_oa(oa_table))
+            object_arg_4: IRequiredGetter = get.Required
+            return object_arg_4.Field("v", arg_9)
+
+        def _arrow3430(__unit: None=None) -> Data:
+            arg_11: Decoder_1[Data] = index(0, compressed_decoder(string_table))
+            object_arg_5: IRequiredGetter = get.Required
+            return object_arg_5.Field("v", arg_11)
+
+        return CompositeCell(1, _arrow3426()) if (match_value == "FreeText") else (CompositeCell(0, _arrow3427()) if (match_value == "Term") else (CompositeCell(2, _arrow3428(), _arrow3429()) if (match_value == "Unitized") else (CompositeCell(3, _arrow3430()) if (match_value == "Data") else to_fail(printf("Error reading CompositeCell from json string: %A"))(match_value))))
+
+    return object(_arrow3431)
+
+
+__all__ = ["encoder", "decoder", "encoder_compressed", "decoder_compressed"]
+

arctrl/py/Json/Table/composite_header.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.list import (singleton, empty, FSharpList)
+from ...fable_modules.fable_library.seq import map
+from ...fable_modules.fable_library.util import (to_enumerable, IEnumerable_1)
+from ...fable_modules.thoth_json_core.decode import (object, IRequiredGetter, string, index, IGetters)
+from ...fable_modules.thoth_json_core.encode import list_1
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Table.composite_header import (CompositeHeader, IOType)
+from ..ontology_annotation import (OntologyAnnotation_encoder, OntologyAnnotation_decoder)
+from .iotype import (encoder as encoder_1, decoder as decoder_1)
+
+__A_ = TypeVar("__A_")
+
+def encoder(ch: CompositeHeader) -> IEncodable:
+    def oa_to_json_string(oa: OntologyAnnotation, ch: Any=ch) -> IEncodable:
+        return OntologyAnnotation_encoder(oa)
+
+    class ObjectExpr3438(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], ch: Any=ch) -> Any:
+            return helpers.encode_string(ch.fields[0])
+
+    pattern_input: tuple[str, FSharpList[IEncodable]] = (("Comment", singleton(ObjectExpr3438()))) if (ch.tag == 14) else ((("Parameter", singleton(oa_to_json_string(ch.fields[0])))) if (ch.tag == 3) else ((("Factor", singleton(oa_to_json_string(ch.fields[0])))) if (ch.tag == 2) else ((("Characteristic", singleton(oa_to_json_string(ch.fields[0])))) if (ch.tag == 1) else ((("Component", singleton(oa_to_json_string(ch.fields[0])))) if (ch.tag == 0) else ((("ProtocolType", empty())) if (ch.tag == 4) else ((("ProtocolREF", empty())) if (ch.tag == 8) else ((("ProtocolDescription", empty())) if (ch.tag == 5) else ((("ProtocolUri", empty())) if (ch.tag == 6) else ((("ProtocolVersion", empty())) if (ch.tag == 7) else ((("Performer", empty())) if (ch.tag == 9) else ((("Date", empty())) if (ch.tag == 10) else ((("Input", singleton(encoder_1(ch.fields[0])))) if (ch.tag == 11) else ((("Output", singleton(encoder_1(ch.fields[0])))) if (ch.tag == 12) else ((ch.fields[0], empty())))))))))))))))
+    class ObjectExpr3439(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], ch: Any=ch) -> Any:
+            return helpers_1.encode_string(pattern_input[0])
+
+    values_1: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("headertype", ObjectExpr3439()), ("values", list_1(pattern_input[1]))])
+    class ObjectExpr3440(IEncodable):
+        def Encode(self, helpers_2: IEncoderHelpers_1[Any], ch: Any=ch) -> Any:
+            def mapping(tupled_arg: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers_2))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map(mapping, values_1)
+            return helpers_2.encode_object(arg)
+
+    return ObjectExpr3440()
+
+
+def _arrow3442(get: IGetters) -> CompositeHeader:
+    header_type: str
+    object_arg: IRequiredGetter = get.Required
+    header_type = object_arg.Field("headertype", string)
+    def oa(__unit: None=None) -> OntologyAnnotation:
+        arg_3: Decoder_1[OntologyAnnotation] = index(0, OntologyAnnotation_decoder)
+        object_arg_1: IRequiredGetter = get.Required
+        return object_arg_1.Field("values", arg_3)
+
+    def io(__unit: None=None) -> IOType:
+        arg_5: Decoder_1[IOType] = index(0, decoder_1)
+        object_arg_2: IRequiredGetter = get.Required
+        return object_arg_2.Field("values", arg_5)
+
+    def _arrow3441(__unit: None=None) -> str:
+        arg_7: Decoder_1[str] = index(0, string)
+        object_arg_3: IRequiredGetter = get.Required
+        return object_arg_3.Field("values", arg_7)
+
+    return CompositeHeader(1, oa(None)) if (header_type == "Characteristic") else (CompositeHeader(3, oa(None)) if (header_type == "Parameter") else (CompositeHeader(0, oa(None)) if (header_type == "Component") else (CompositeHeader(2, oa(None)) if (header_type == "Factor") else (CompositeHeader(11, io(None)) if (header_type == "Input") else (CompositeHeader(12, io(None)) if (header_type == "Output") else (CompositeHeader(4) if (header_type == "ProtocolType") else (CompositeHeader(8) if (header_type == "ProtocolREF") else (CompositeHeader(5) if (header_type == "ProtocolDescription") else (CompositeHeader(6) if (header_type == "ProtocolUri") else (CompositeHeader(7) if (header_type == "ProtocolVersion") else (CompositeHeader(9) if (header_type == "Performer") else (CompositeHeader(10) if (header_type == "Date") else (CompositeHeader(14, _arrow3441()) if (header_type == "Comment") else CompositeHeader(13, header_type))))))))))))))
+
+
+decoder: Decoder_1[CompositeHeader] = object(_arrow3442)
+
+__all__ = ["encoder", "decoder"]
+

arctrl/py/Json/Table/iotype.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+from typing import Any
+from ...fable_modules.fable_library.types import to_string
+from ...fable_modules.thoth_json_core.decode import (and_then, succeed, string)
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ...Core.Table.composite_header import IOType
+
+def encoder(io: IOType) -> IEncodable:
+    value: str = to_string(io)
+    class ObjectExpr3437(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], io: Any=io) -> Any:
+            return helpers.encode_string(value)
+
+    return ObjectExpr3437()
+
+
+def cb(s: str) -> Decoder_1[IOType]:
+    return succeed(IOType.of_string(s))
+
+
+decoder: Decoder_1[IOType] = and_then(cb, string)
+
+__all__ = ["encoder", "decoder"]
+

arctrl/py/Json/Table/oatable.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.array_ import map as map_1
+from ...fable_modules.fable_library.map_util import add_to_dict
+from ...fable_modules.fable_library.seq import (to_array, map, sort_by)
+from ...fable_modules.fable_library.types import Array
+from ...fable_modules.fable_library.util import compare_primitives
+from ...fable_modules.thoth_json_core.decode import (array as array_2, object, int_1, IGetters)
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ...Core.Helper.collections_ import (Dictionary_items, Dictionary_tryFind)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ..ontology_annotation import (OntologyAnnotation_compressedEncoder, OntologyAnnotation_compressedDecoder)
+
+__A_ = TypeVar("__A_")
+
+def array_from_map(otm: Any) -> Array[OntologyAnnotation]:
+    def mapping(kv_1: Any, otm: Any=otm) -> OntologyAnnotation:
+        return kv_1[0]
+
+    def projection(kv: Any, otm: Any=otm) -> int:
+        return kv[1]
+
+    class ObjectExpr3409:
+        @property
+        def Compare(self) -> Callable[[int, int], int]:
+            return compare_primitives
+
+    return to_array(map(mapping, sort_by(projection, Dictionary_items(otm), ObjectExpr3409())))
+
+
+def encoder(string_table: Any, ot: Array[OntologyAnnotation]) -> IEncodable:
+    def mapping(oa: OntologyAnnotation, string_table: Any=string_table, ot: Any=ot) -> IEncodable:
+        return OntologyAnnotation_compressedEncoder(string_table, oa)
+
+    values: Array[IEncodable] = map_1(mapping, ot, None)
+    class ObjectExpr3410(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], string_table: Any=string_table, ot: Any=ot) -> Any:
+            def mapping_1(v: IEncodable) -> __A_:
+                return v.Encode(helpers)
+
+            arg: Array[__A_] = map_1(mapping_1, values, None)
+            return helpers.encode_array(arg)
+
+    return ObjectExpr3410()
+
+
+def decoder(string_table: Array[str]) -> Decoder_1[Array[OntologyAnnotation]]:
+    return array_2(OntologyAnnotation_compressedDecoder(string_table))
+
+
+def encode_oa(otm: Any, oa: OntologyAnnotation) -> IEncodable:
+    match_value: int | None = Dictionary_tryFind(oa, otm)
+    if match_value is None:
+        i_1: int = len(otm) or 0
+        add_to_dict(otm, oa, i_1)
+        class ObjectExpr3411(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any], otm: Any=otm, oa: Any=oa) -> Any:
+                return helpers_1.encode_signed_integral_number(i_1)
+
+        return ObjectExpr3411()
+
+    else: 
+        i: int = match_value or 0
+        class ObjectExpr3412(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any], otm: Any=otm, oa: Any=oa) -> Any:
+                return helpers.encode_signed_integral_number(i)
+
+        return ObjectExpr3412()
+
+
+
+def decode_oa(ot: Array[OntologyAnnotation]) -> Decoder_1[OntologyAnnotation]:
+    def _arrow3413(get: IGetters, ot: Any=ot) -> OntologyAnnotation:
+        i: int = get.Required.Raw(int_1) or 0
+        return ot[i]
+
+    return object(_arrow3413)
+
+
+__all__ = ["array_from_map", "encoder", "decoder", "encode_oa", "decode_oa"]
+

arctrl/py/Json/Table/templates.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.array_ import map as map_1
+from ...fable_modules.fable_library.date import to_string as to_string_1
+from ...fable_modules.fable_library.seq import map
+from ...fable_modules.fable_library.types import (to_string, Array)
+from ...fable_modules.fable_library.util import (to_enumerable, IEnumerable_1)
+from ...fable_modules.thoth_json_core.decode import (and_then, succeed, string, object, IRequiredGetter, guid, resize_array, IOptionalGetter, IGetters, datetime_local, array as array_2)
+from ...fable_modules.thoth_json_core.encode import seq
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.person import Person
+from ...Core.Table.arc_table import ArcTable
+from ...Core.Table.composite_cell import CompositeCell
+from ...Core.template import (Organisation, Template)
+from ..decode import Decode_datetime
+from ..encode import date_time
+from ..ontology_annotation import (OntologyAnnotation_encoder, OntologyAnnotation_decoder)
+from ..person import (encoder as encoder_1, decoder as decoder_2)
+from .arc_table import (encoder, decoder as decoder_1, encoder_compressed, decoder_compressed)
+
+__A_ = TypeVar("__A_")
+
+def _arrow3460(arg: Organisation) -> IEncodable:
+    value: str = to_string(arg)
+    class ObjectExpr3457(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+            return helpers.encode_string(value)
+
+    return ObjectExpr3457()
+
+
+Template_Organisation_encoder: Callable[[Organisation], IEncodable] = _arrow3460
+
+def cb(text_value: str) -> Decoder_1[Organisation]:
+    return succeed(Organisation.of_string(text_value))
+
+
+Template_Organisation_decoder: Decoder_1[Organisation] = and_then(cb, string)
+
+def Template_encoder(template: Template) -> IEncodable:
+    def _arrow3466(__unit: None=None, template: Any=template) -> IEncodable:
+        value_1: str
+        copy_of_struct: str = template.Id
+        value_1 = str(copy_of_struct)
+        class ObjectExpr3465(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value_1)
+
+        return ObjectExpr3465()
+
+    def _arrow3474(__unit: None=None, template: Any=template) -> IEncodable:
+        value_3: str = template.Name
+        class ObjectExpr3473(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_1.encode_string(value_3)
+
+        return ObjectExpr3473()
+
+    def _arrow3477(__unit: None=None, template: Any=template) -> IEncodable:
+        value_4: str = template.Description
+        class ObjectExpr3476(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_2.encode_string(value_4)
+
+        return ObjectExpr3476()
+
+    def _arrow3479(__unit: None=None, template: Any=template) -> IEncodable:
+        value_5: str = template.Version
+        class ObjectExpr3478(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_3.encode_string(value_5)
+
+        return ObjectExpr3478()
+
+    def mapping(person: Person, template: Any=template) -> IEncodable:
+        return encoder_1(person)
+
+    def mapping_1(oa: OntologyAnnotation, template: Any=template) -> IEncodable:
+        return OntologyAnnotation_encoder(oa)
+
+    def mapping_2(oa_1: OntologyAnnotation, template: Any=template) -> IEncodable:
+        return OntologyAnnotation_encoder(oa_1)
+
+    values_3: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("id", _arrow3466()), ("table", encoder(template.Table)), ("name", _arrow3474()), ("description", _arrow3477()), ("organisation", Template_Organisation_encoder(template.Organisation)), ("version", _arrow3479()), ("authors", seq(map(mapping, template.Authors))), ("endpoint_repositories", seq(map(mapping_1, template.EndpointRepositories))), ("tags", seq(map(mapping_2, template.Tags))), ("last_updated", date_time(template.LastUpdated))])
+    class ObjectExpr3485(IEncodable):
+        def Encode(self, helpers_4: IEncoderHelpers_1[Any], template: Any=template) -> Any:
+            def mapping_3(tupled_arg: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers_4))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map(mapping_3, values_3)
+            return helpers_4.encode_object(arg)
+
+    return ObjectExpr3485()
+
+
+def _arrow3502(get: IGetters) -> Template:
+    def _arrow3487(__unit: None=None) -> str:
+        object_arg: IRequiredGetter = get.Required
+        return object_arg.Field("id", guid)
+
+    def _arrow3488(__unit: None=None) -> ArcTable:
+        object_arg_1: IRequiredGetter = get.Required
+        return object_arg_1.Field("table", decoder_1)
+
+    def _arrow3489(__unit: None=None) -> str:
+        object_arg_2: IRequiredGetter = get.Required
+        return object_arg_2.Field("name", string)
+
+    def _arrow3490(__unit: None=None) -> str:
+        object_arg_3: IRequiredGetter = get.Required
+        return object_arg_3.Field("description", string)
+
+    def _arrow3491(__unit: None=None) -> Organisation:
+        object_arg_4: IRequiredGetter = get.Required
+        return object_arg_4.Field("organisation", Template_Organisation_decoder)
+
+    def _arrow3493(__unit: None=None) -> str:
+        object_arg_5: IRequiredGetter = get.Required
+        return object_arg_5.Field("version", string)
+
+    def _arrow3494(__unit: None=None) -> Array[Person] | None:
+        arg_13: Decoder_1[Array[Person]] = resize_array(decoder_2)
+        object_arg_6: IOptionalGetter = get.Optional
+        return object_arg_6.Field("authors", arg_13)
+
+    def _arrow3497(__unit: None=None) -> Array[OntologyAnnotation] | None:
+        arg_15: Decoder_1[Array[OntologyAnnotation]] = resize_array(OntologyAnnotation_decoder)
+        object_arg_7: IOptionalGetter = get.Optional
+        return object_arg_7.Field("endpoint_repositories", arg_15)
+
+    def _arrow3498(__unit: None=None) -> Array[OntologyAnnotation] | None:
+        arg_17: Decoder_1[Array[OntologyAnnotation]] = resize_array(OntologyAnnotation_decoder)
+        object_arg_8: IOptionalGetter = get.Optional
+        return object_arg_8.Field("tags", arg_17)
+
+    def _arrow3500(__unit: None=None) -> Any:
+        object_arg_9: IRequiredGetter = get.Required
+        return object_arg_9.Field("last_updated", Decode_datetime)
+
+    return Template.create(_arrow3487(), _arrow3488(), _arrow3489(), _arrow3490(), _arrow3491(), _arrow3493(), _arrow3494(), _arrow3497(), _arrow3498(), _arrow3500())
+
+
+Template_decoder: Decoder_1[Template] = object(_arrow3502)
+
+def Template_encoderCompressed(string_table: Any, oa_table: Any, cell_table: Any, template: Template) -> IEncodable:
+    def _arrow3505(__unit: None=None, string_table: Any=string_table, oa_table: Any=oa_table, cell_table: Any=cell_table, template: Any=template) -> IEncodable:
+        value_1: str
+        copy_of_struct: str = template.Id
+        value_1 = str(copy_of_struct)
+        class ObjectExpr3504(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value_1)
+
+        return ObjectExpr3504()
+
+    def _arrow3509(__unit: None=None, string_table: Any=string_table, oa_table: Any=oa_table, cell_table: Any=cell_table, template: Any=template) -> IEncodable:
+        value_3: str = template.Name
+        class ObjectExpr3508(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_1.encode_string(value_3)
+
+        return ObjectExpr3508()
+
+    def _arrow3512(__unit: None=None, string_table: Any=string_table, oa_table: Any=oa_table, cell_table: Any=cell_table, template: Any=template) -> IEncodable:
+        value_4: str = template.Description
+        class ObjectExpr3511(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_2.encode_string(value_4)
+
+        return ObjectExpr3511()
+
+    def _arrow3515(__unit: None=None, string_table: Any=string_table, oa_table: Any=oa_table, cell_table: Any=cell_table, template: Any=template) -> IEncodable:
+        value_5: str = template.Version
+        class ObjectExpr3514(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_3.encode_string(value_5)
+
+        return ObjectExpr3514()
+
+    def mapping(person: Person, string_table: Any=string_table, oa_table: Any=oa_table, cell_table: Any=cell_table, template: Any=template) -> IEncodable:
+        return encoder_1(person)
+
+    def mapping_1(oa: OntologyAnnotation, string_table: Any=string_table, oa_table: Any=oa_table, cell_table: Any=cell_table, template: Any=template) -> IEncodable:
+        return OntologyAnnotation_encoder(oa)
+
+    def mapping_2(oa_1: OntologyAnnotation, string_table: Any=string_table, oa_table: Any=oa_table, cell_table: Any=cell_table, template: Any=template) -> IEncodable:
+        return OntologyAnnotation_encoder(oa_1)
+
+    def _arrow3517(__unit: None=None, string_table: Any=string_table, oa_table: Any=oa_table, cell_table: Any=cell_table, template: Any=template) -> IEncodable:
+        value_1_1: str = to_string_1(template.LastUpdated, "O", {})
+        class ObjectExpr3516(IEncodable):
+            def Encode(self, helpers_4: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_4.encode_string(value_1_1)
+
+        return ObjectExpr3516()
+
+    values_3: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("id", _arrow3505()), ("table", encoder_compressed(string_table, oa_table, cell_table, template.Table)), ("name", _arrow3509()), ("description", _arrow3512()), ("organisation", Template_Organisation_encoder(template.Organisation)), ("version", _arrow3515()), ("authors", seq(map(mapping, template.Authors))), ("endpoint_repositories", seq(map(mapping_1, template.EndpointRepositories))), ("tags", seq(map(mapping_2, template.Tags))), ("last_updated", _arrow3517())])
+    class ObjectExpr3519(IEncodable):
+        def Encode(self, helpers_5: IEncoderHelpers_1[Any], string_table: Any=string_table, oa_table: Any=oa_table, cell_table: Any=cell_table, template: Any=template) -> Any:
+            def mapping_3(tupled_arg: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers_5))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map(mapping_3, values_3)
+            return helpers_5.encode_object(arg)
+
+    return ObjectExpr3519()
+
+
+def Template_decoderCompressed(string_table: Array[str], oa_table: Array[OntologyAnnotation], cell_table: Array[CompositeCell]) -> Decoder_1[Template]:
+    def _arrow3533(get: IGetters, string_table: Any=string_table, oa_table: Any=oa_table, cell_table: Any=cell_table) -> Template:
+        def _arrow3521(__unit: None=None) -> str:
+            object_arg: IRequiredGetter = get.Required
+            return object_arg.Field("id", guid)
+
+        def _arrow3522(__unit: None=None) -> ArcTable:
+            arg_3: Decoder_1[ArcTable] = decoder_compressed(string_table, oa_table, cell_table)
+            object_arg_1: IRequiredGetter = get.Required
+            return object_arg_1.Field("table", arg_3)
+
+        def _arrow3523(__unit: None=None) -> str:
+            object_arg_2: IRequiredGetter = get.Required
+            return object_arg_2.Field("name", string)
+
+        def _arrow3524(__unit: None=None) -> str:
+            object_arg_3: IRequiredGetter = get.Required
+            return object_arg_3.Field("description", string)
+
+        def _arrow3525(__unit: None=None) -> Organisation:
+            object_arg_4: IRequiredGetter = get.Required
+            return object_arg_4.Field("organisation", Template_Organisation_decoder)
+
+        def _arrow3526(__unit: None=None) -> str:
+            object_arg_5: IRequiredGetter = get.Required
+            return object_arg_5.Field("version", string)
+
+        def _arrow3528(__unit: None=None) -> Array[Person] | None:
+            arg_13: Decoder_1[Array[Person]] = resize_array(decoder_2)
+            object_arg_6: IOptionalGetter = get.Optional
+            return object_arg_6.Field("authors", arg_13)
+
+        def _arrow3530(__unit: None=None) -> Array[OntologyAnnotation] | None:
+            arg_15: Decoder_1[Array[OntologyAnnotation]] = resize_array(OntologyAnnotation_decoder)
+            object_arg_7: IOptionalGetter = get.Optional
+            return object_arg_7.Field("endpoint_repositories", arg_15)
+
+        def _arrow3531(__unit: None=None) -> Array[OntologyAnnotation] | None:
+            arg_17: Decoder_1[Array[OntologyAnnotation]] = resize_array(OntologyAnnotation_decoder)
+            object_arg_8: IOptionalGetter = get.Optional
+            return object_arg_8.Field("tags", arg_17)
+
+        def _arrow3532(__unit: None=None) -> Any:
+            object_arg_9: IRequiredGetter = get.Required
+            return object_arg_9.Field("last_updated", datetime_local)
+
+        return Template.create(_arrow3521(), _arrow3522(), _arrow3523(), _arrow3524(), _arrow3525(), _arrow3526(), _arrow3528(), _arrow3530(), _arrow3531(), _arrow3532())
+
+    return object(_arrow3533)
+
+
+def Templates_encoder(templates: Array[Template]) -> IEncodable:
+    def mapping(template: Template, templates: Any=templates) -> IEncodable:
+        return Template_encoder(template)
+
+    values: Array[IEncodable] = map_1(mapping, templates, None)
+    class ObjectExpr3541(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], templates: Any=templates) -> Any:
+            def mapping_1(v: IEncodable) -> __A_:
+                return v.Encode(helpers)
+
+            arg: Array[__A_] = map_1(mapping_1, values, None)
+            return helpers.encode_array(arg)
+
+    return ObjectExpr3541()
+
+
+Templates_decoder: Decoder_1[Array[Template]] = array_2(Template_decoder)
+
+__all__ = ["Template_Organisation_encoder", "Template_Organisation_decoder", "Template_encoder", "Template_decoder", "Template_encoderCompressed", "Template_decoderCompressed", "Templates_encoder", "Templates_decoder"]
+