arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/Json/data.py

@@ -0,0 +1,356 @@
+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, singleton)
+from ..fable_modules.fable_library.option import map
+from ..fable_modules.fable_library.seq import map as map_1
+from ..fable_modules.fable_library.string_ import replace
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import IEnumerable_1
+from ..fable_modules.thoth_json_core.decode import (object, IOptionalGetter, string, resize_array, IGetters)
+from ..fable_modules.thoth_json_core.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.data import Data
+from ..Core.data_file import DataFile
+from ..Core.uri import URIModule_toString
+from .comment import (encoder as encoder_1, decoder as decoder_1, 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_data_context import context_jsonvalue
+from .data_file import (ISAJson_encoder as ISAJson_encoder_1, ISAJson_decoder as ISAJson_decoder_1, ROCrate_encoder as ROCrate_encoder_1, ROCrate_decoder as ROCrate_decoder_1)
+from .decode import (Decode_uri, Decode_objectNoAdditionalProperties)
+from .encode import (try_include, try_include_seq)
+from .idtable import encode
+from .string_table import (encode_string, decode_string)
+
+__A_ = TypeVar("__A_")
+
+def encoder(d: Data) -> IEncodable:
+    def chooser(tupled_arg: tuple[str, IEncodable | None], d: Any=d) -> 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 _arrow2167(value: str, d: Any=d) -> IEncodable:
+        class ObjectExpr2166(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr2166()
+
+    def _arrow2169(value_2: str, d: Any=d) -> IEncodable:
+        class ObjectExpr2168(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_1.encode_string(value_2)
+
+        return ObjectExpr2168()
+
+    def _arrow2171(value_4: str, d: Any=d) -> IEncodable:
+        class ObjectExpr2170(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_2.encode_string(value_4)
+
+        return ObjectExpr2170()
+
+    def _arrow2173(value_6: str, d: Any=d) -> IEncodable:
+        class ObjectExpr2172(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_3.encode_string(value_6)
+
+        return ObjectExpr2172()
+
+    def _arrow2174(comment: Comment, d: Any=d) -> IEncodable:
+        return encoder_1(comment)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("@id", _arrow2167, d.ID), try_include("name", _arrow2169, d.Name), try_include("dataType", ISAJson_encoder_1, d.DataType), try_include("format", _arrow2171, d.Format), try_include("selectorFormat", _arrow2173, d.SelectorFormat), try_include_seq("comments", _arrow2174, d.Comments)]))
+    class ObjectExpr2175(IEncodable):
+        def Encode(self, helpers_4: IEncoderHelpers_1[Any], d: Any=d) -> Any:
+            def mapping_1(tupled_arg_1: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg_1[0], tupled_arg_1[1].Encode(helpers_4))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+            return helpers_4.encode_object(arg)
+
+    return ObjectExpr2175()
+
+
+def _arrow2182(get: IGetters) -> Data:
+    def _arrow2176(__unit: None=None) -> str | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("@id", Decode_uri)
+
+    def _arrow2177(__unit: None=None) -> str | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("name", string)
+
+    def _arrow2178(__unit: None=None) -> DataFile | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("dataType", ISAJson_decoder_1)
+
+    def _arrow2179(__unit: None=None) -> str | None:
+        object_arg_3: IOptionalGetter = get.Optional
+        return object_arg_3.Field("format", string)
+
+    def _arrow2180(__unit: None=None) -> str | None:
+        object_arg_4: IOptionalGetter = get.Optional
+        return object_arg_4.Field("selectorFormat", Decode_uri)
+
+    def _arrow2181(__unit: None=None) -> Array[Comment] | None:
+        arg_11: Decoder_1[Array[Comment]] = resize_array(decoder_1)
+        object_arg_5: IOptionalGetter = get.Optional
+        return object_arg_5.Field("comments", arg_11)
+
+    return Data(_arrow2176(), _arrow2177(), _arrow2178(), _arrow2179(), _arrow2180(), _arrow2181())
+
+
+decoder: Decoder_1[Data] = object(_arrow2182)
+
+def compressed_encoder(string_table: Any, d: Data) -> IEncodable:
+    def chooser(tupled_arg: tuple[str, IEncodable | None], string_table: Any=string_table, d: Any=d) -> 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 _arrow2184(s: str, string_table: Any=string_table, d: Any=d) -> IEncodable:
+        return encode_string(string_table, s)
+
+    def _arrow2185(s_1: str, string_table: Any=string_table, d: Any=d) -> IEncodable:
+        return encode_string(string_table, s_1)
+
+    def _arrow2186(s_2: str, string_table: Any=string_table, d: Any=d) -> IEncodable:
+        return encode_string(string_table, s_2)
+
+    def _arrow2187(s_3: str, string_table: Any=string_table, d: Any=d) -> IEncodable:
+        return encode_string(string_table, s_3)
+
+    def _arrow2188(comment: Comment, string_table: Any=string_table, d: Any=d) -> IEncodable:
+        return encoder_1(comment)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([try_include("i", _arrow2184, d.ID), try_include("n", _arrow2185, d.Name), try_include("d", ISAJson_encoder_1, d.DataType), try_include("f", _arrow2186, d.Format), try_include("s", _arrow2187, d.SelectorFormat), try_include_seq("c", _arrow2188, d.Comments)]))
+    class ObjectExpr2189(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], string_table: Any=string_table, d: Any=d) -> 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 ObjectExpr2189()
+
+
+def compressed_decoder(string_table: Array[str]) -> Decoder_1[Data]:
+    def _arrow2196(get: IGetters, string_table: Any=string_table) -> Data:
+        def _arrow2190(__unit: None=None) -> str | None:
+            arg_1: Decoder_1[str] = decode_string(string_table)
+            object_arg: IOptionalGetter = get.Optional
+            return object_arg.Field("i", arg_1)
+
+        def _arrow2191(__unit: None=None) -> str | None:
+            arg_3: Decoder_1[str] = decode_string(string_table)
+            object_arg_1: IOptionalGetter = get.Optional
+            return object_arg_1.Field("n", arg_3)
+
+        def _arrow2192(__unit: None=None) -> DataFile | None:
+            object_arg_2: IOptionalGetter = get.Optional
+            return object_arg_2.Field("d", ISAJson_decoder_1)
+
+        def _arrow2193(__unit: None=None) -> str | None:
+            arg_7: Decoder_1[str] = decode_string(string_table)
+            object_arg_3: IOptionalGetter = get.Optional
+            return object_arg_3.Field("f", arg_7)
+
+        def _arrow2194(__unit: None=None) -> str | None:
+            arg_9: Decoder_1[str] = decode_string(string_table)
+            object_arg_4: IOptionalGetter = get.Optional
+            return object_arg_4.Field("s", arg_9)
+
+        def _arrow2195(__unit: None=None) -> Array[Comment] | None:
+            arg_11: Decoder_1[Array[Comment]] = resize_array(decoder_1)
+            object_arg_5: IOptionalGetter = get.Optional
+            return object_arg_5.Field("c", arg_11)
+
+        return Data(_arrow2190(), _arrow2191(), _arrow2192(), _arrow2193(), _arrow2194(), _arrow2195())
+
+    return object(_arrow2196)
+
+
+def ROCrate_genID(d: Data) -> str:
+    match_value: str | None = d.ID
+    if match_value is None:
+        match_value_1: str | None = d.Name
+        if match_value_1 is None:
+            return "#EmptyData"
+
+        else: 
+            return replace(match_value_1, " ", "_")
+
+
+    else: 
+        return URIModule_toString(match_value)
+
+
+
+def ROCrate_encoder(oa: Data) -> IEncodable:
+    def chooser(tupled_arg: tuple[str, IEncodable | None], oa: Any=oa) -> tuple[str, IEncodable] | None:
+        def mapping(v_1: IEncodable, tupled_arg: Any=tupled_arg) -> tuple[str, IEncodable]:
+            return (tupled_arg[0], v_1)
+
+        return map(mapping, tupled_arg[1])
+
+    def _arrow2200(__unit: None=None, oa: Any=oa) -> IEncodable:
+        value: str = ROCrate_genID(oa)
+        class ObjectExpr2199(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr2199()
+
+    class ObjectExpr2201(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], oa: Any=oa) -> Any:
+            return helpers_1.encode_string("Data")
+
+    def _arrow2203(value_2: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2202(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_2.encode_string(value_2)
+
+        return ObjectExpr2202()
+
+    def _arrow2204(value_4: DataFile, oa: Any=oa) -> IEncodable:
+        return ROCrate_encoder_1(value_4)
+
+    def _arrow2206(value_5: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2205(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_3.encode_string(value_5)
+
+        return ObjectExpr2205()
+
+    def _arrow2208(value_7: str, oa: Any=oa) -> IEncodable:
+        class ObjectExpr2207(IEncodable):
+            def Encode(self, helpers_4: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_4.encode_string(value_7)
+
+        return ObjectExpr2207()
+
+    def _arrow2209(comment: Comment, oa: Any=oa) -> IEncodable:
+        return ROCrate_encoder_2(comment)
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([("@id", _arrow2200()), ("@type", list_1_1(singleton(ObjectExpr2201()))), try_include("name", _arrow2203, oa.Name), try_include("type", _arrow2204, oa.DataType), try_include("encodingFormat", _arrow2206, oa.Format), try_include("usageInfo", _arrow2208, oa.SelectorFormat), try_include_seq("comments", _arrow2209, oa.Comments), ("@context", context_jsonvalue)]))
+    class ObjectExpr2210(IEncodable):
+        def Encode(self, helpers_5: IEncoderHelpers_1[Any], oa: Any=oa) -> Any:
+            def mapping_1(tupled_arg_1: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg_1[0], tupled_arg_1[1].Encode(helpers_5))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+            return helpers_5.encode_object(arg)
+
+    return ObjectExpr2210()
+
+
+def _arrow2217(get: IGetters) -> Data:
+    def _arrow2211(__unit: None=None) -> str | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("@id", Decode_uri)
+
+    def _arrow2212(__unit: None=None) -> str | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("name", string)
+
+    def _arrow2213(__unit: None=None) -> DataFile | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("type", ROCrate_decoder_1)
+
+    def _arrow2214(__unit: None=None) -> str | None:
+        object_arg_3: IOptionalGetter = get.Optional
+        return object_arg_3.Field("encodingFormat", string)
+
+    def _arrow2215(__unit: None=None) -> str | None:
+        object_arg_4: IOptionalGetter = get.Optional
+        return object_arg_4.Field("usageInfo", Decode_uri)
+
+    def _arrow2216(__unit: None=None) -> Array[Comment] | None:
+        arg_11: Decoder_1[Array[Comment]] = resize_array(ROCrate_decoder_2)
+        object_arg_5: IOptionalGetter = get.Optional
+        return object_arg_5.Field("comments", arg_11)
+
+    return Data(_arrow2211(), _arrow2212(), _arrow2213(), _arrow2214(), _arrow2215(), _arrow2216())
+
+
+ROCrate_decoder: Decoder_1[Data] = object(_arrow2217)
+
+def ISAJson_encoder(id_map: Any | None, oa: Data) -> IEncodable:
+    def f(oa_1: Data, 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 _arrow2221(value: str, oa_1: Any=oa_1) -> IEncodable:
+            class ObjectExpr2220(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value)
+
+            return ObjectExpr2220()
+
+        def _arrow2223(value_2: str, oa_1: Any=oa_1) -> IEncodable:
+            class ObjectExpr2222(IEncodable):
+                def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers_1.encode_string(value_2)
+
+            return ObjectExpr2222()
+
+        def _arrow2224(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", _arrow2221, ROCrate_genID(oa_1)), try_include("name", _arrow2223, oa_1.Name), try_include("type", ISAJson_encoder_1, oa_1.DataType), try_include_seq("comments", _arrow2224, oa_1.Comments)]))
+        class ObjectExpr2225(IEncodable):
+            def Encode(self, helpers_2: 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_2))
+
+                arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+                return helpers_2.encode_object(arg)
+
+        return ObjectExpr2225()
+
+    if id_map is not None:
+        def _arrow2226(d_1: Data, id_map: Any=id_map, oa: Any=oa) -> str:
+            return ROCrate_genID(d_1)
+
+        return encode(_arrow2226, f, oa, id_map)
+
+    else: 
+        return f(oa)
+
+
+
+ISAJson_allowedFields: FSharpList[str] = of_array(["@id", "name", "type", "comments", "@type", "@context"])
+
+def _arrow2231(get: IGetters) -> Data:
+    def _arrow2227(__unit: None=None) -> str | None:
+        object_arg: IOptionalGetter = get.Optional
+        return object_arg.Field("@id", Decode_uri)
+
+    def _arrow2228(__unit: None=None) -> str | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("name", string)
+
+    def _arrow2229(__unit: None=None) -> DataFile | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("type", ISAJson_decoder_1)
+
+    def _arrow2230(__unit: None=None) -> Array[Comment] | None:
+        arg_7: Decoder_1[Array[Comment]] = resize_array(ISAJson_decoder_2)
+        object_arg_3: IOptionalGetter = get.Optional
+        return object_arg_3.Field("comments", arg_7)
+
+    return Data(_arrow2227(), _arrow2228(), _arrow2229(), None, None, _arrow2230())
+
+
+ISAJson_decoder: Decoder_1[Data] = Decode_objectNoAdditionalProperties(ISAJson_allowedFields, _arrow2231)
+
+__all__ = ["encoder", "decoder", "compressed_encoder", "compressed_decoder", "ROCrate_genID", "ROCrate_encoder", "ROCrate_decoder", "ISAJson_encoder", "ISAJson_allowedFields", "ISAJson_decoder"]
+

arctrl/py/Json/data_file.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ..fable_modules.fable_library.result import FSharpResult_2
+from ..fable_modules.thoth_json_core.decode import string
+from ..fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1, ErrorReason_1, IDecoderHelpers_1)
+from ..Core.data_file import DataFile
+
+__A_ = TypeVar("__A_")
+
+def ROCrate_encoder(value: DataFile) -> IEncodable:
+    if value.tag == 1:
+        class ObjectExpr2104(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_1.encode_string("Derived Data File")
+
+        return ObjectExpr2104()
+
+    elif value.tag == 2:
+        class ObjectExpr2107(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_2.encode_string("Image File")
+
+        return ObjectExpr2107()
+
+    else: 
+        class ObjectExpr2108(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers.encode_string("Raw Data File")
+
+        return ObjectExpr2108()
+
+
+
+class ObjectExpr2110(Decoder_1[DataFile]):
+    def Decode(self, s: IDecoderHelpers_1[Any], json: Any) -> FSharpResult_2[DataFile, tuple[str, ErrorReason_1[__A_]]]:
+        match_value: FSharpResult_2[str, tuple[str, ErrorReason_1[__A_]]] = string.Decode(s, json)
+        if match_value.tag == 1:
+            return FSharpResult_2(1, match_value.fields[0])
+
+        elif match_value.fields[0] == "Raw Data File":
+            return FSharpResult_2(0, DataFile(0))
+
+        elif match_value.fields[0] == "Derived Data File":
+            return FSharpResult_2(0, DataFile(1))
+
+        elif match_value.fields[0] == "Image File":
+            return FSharpResult_2(0, DataFile(2))
+
+        else: 
+            s_1: str = match_value.fields[0]
+            return FSharpResult_2(1, (("Could not parse " + s_1) + ".", ErrorReason_1(0, s_1, json)))
+
+
+
+ROCrate_decoder: Decoder_1[DataFile] = ObjectExpr2110()
+
+ISAJson_encoder: Callable[[DataFile], IEncodable] = ROCrate_encoder
+
+ISAJson_decoder: Decoder_1[DataFile] = ROCrate_decoder
+
+__all__ = ["ROCrate_encoder", "ROCrate_decoder", "ISAJson_encoder", "ISAJson_decoder"]
+

arctrl/py/Json/decode.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+from abc import abstractmethod
+from collections.abc import Callable
+from datetime import datetime
+from typing import (Any, Protocol, TypeVar)
+from ..fable_modules.fable_library.array_ import fold
+from ..fable_modules.fable_library.date import to_universal_time
+from ..fable_modules.fable_library.list import (FSharpList, is_empty, length, head)
+from ..fable_modules.fable_library.result import (FSharpResult_2, Result_Map)
+from ..fable_modules.fable_library.seq import exists
+from ..fable_modules.fable_library.set import (contains, of_seq)
+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 (compare_primitives, IEnumerable_1, int32_to_string)
+from ..fable_modules.thoth_json_core.decode import (string, Getters_2__ctor_Z4BE6C149, Getters_2, Getters_2__get_Errors, IGetters, map, datetime_local)
+from ..fable_modules.thoth_json_core.types import (ErrorReason_1, Decoder_1, IDecoderHelpers_1)
+
+_JSONVALUE = TypeVar("_JSONVALUE")
+
+__A_ = TypeVar("__A_")
+
+_VALUE_ = TypeVar("_VALUE_")
+
+_VALUE = TypeVar("_VALUE")
+
+class DateTimeStatic(Protocol):
+    @abstractmethod
+    def from_time_stamp(self, timestamp: float) -> Any:
+        ...
+
+
+def PyTime_toUniversalTimePy(dt: Any) -> Any:
+    timestamp: float = to_universal_time(dt).timestamp()
+    return datetime.fromtimestamp(timestamp=timestamp)
+
+
+def Helpers_prependPath(path: str, err_: str, err__1: ErrorReason_1[Any]) -> tuple[str, ErrorReason_1[_JSONVALUE]]:
+    err: tuple[str, ErrorReason_1[_JSONVALUE]] = (err_, err__1)
+    return (path + err[0], err[1])
+
+
+def Decode_isURI(s: str) -> bool:
+    return True
+
+
+class ObjectExpr1876(Decoder_1[str]):
+    def Decode(self, s: IDecoderHelpers_1[Any], json: Any) -> FSharpResult_2[str, tuple[str, ErrorReason_1[__A_]]]:
+        match_value: FSharpResult_2[str, tuple[str, ErrorReason_1[__A_]]] = string.Decode(s, json)
+        if match_value.tag == 1:
+            return FSharpResult_2(1, match_value.fields[0])
+
+        elif Decode_isURI(match_value.fields[0]):
+            return FSharpResult_2(0, match_value.fields[0])
+
+        else: 
+            s_3: str = match_value.fields[0]
+            return FSharpResult_2(1, (s_3, ErrorReason_1(6, to_text(printf("Expected URI, got %s"))(s_3))))
+
+
+
+Decode_uri: Decoder_1[str] = ObjectExpr1876()
+
+def Decode_hasUnknownFields(helpers: IDecoderHelpers_1[Any], known_fields: Any, json: Any) -> bool:
+    def predicate(x: str, helpers: Any=helpers, known_fields: Any=known_fields, json: Any=json) -> bool:
+        return not contains(x, known_fields)
+
+    return exists(predicate, helpers.get_properties(json))
+
+
+def Decode_objectNoAdditionalProperties(allowed_properties: IEnumerable_1[str], builder: Callable[[IGetters], _VALUE]) -> Decoder_1[Any]:
+    class ObjectExpr1877:
+        @property
+        def Compare(self) -> Callable[[str, str], int]:
+            return compare_primitives
+
+    allowed_properties_1: Any = of_seq(allowed_properties, ObjectExpr1877())
+    class ObjectExpr1878(Decoder_1[_VALUE_]):
+        def Decode(self, helpers: IDecoderHelpers_1[Any], value: Any, allowed_properties: Any=allowed_properties, builder: Any=builder) -> FSharpResult_2[_VALUE_, tuple[str, ErrorReason_1[__A_]]]:
+            getters: Getters_2[__A_, Any] = Getters_2__ctor_Z4BE6C149(helpers, value)
+            if Decode_hasUnknownFields(helpers, allowed_properties_1, value):
+                return FSharpResult_2(1, ("Unknown fields in object", ErrorReason_1(0, "", value)))
+
+            else: 
+                result: _VALUE_ = builder(getters)
+                match_value: FSharpList[tuple[str, ErrorReason_1[__A_]]] = Getters_2__get_Errors(getters)
+                if not is_empty(match_value):
+                    errors: FSharpList[tuple[str, ErrorReason_1[__A_]]] = match_value
+                    return FSharpResult_2(1, ("", ErrorReason_1(7, errors))) if (length(errors) > 1) else FSharpResult_2(1, head(match_value))
+
+                else: 
+                    return FSharpResult_2(0, result)
+
+
+
+    return ObjectExpr1878()
+
+
+def Decode_noAdditionalProperties(allowed_properties: IEnumerable_1[str], decoder: Decoder_1[Any]) -> Decoder_1[Any]:
+    class ObjectExpr1879:
+        @property
+        def Compare(self) -> Callable[[str, str], int]:
+            return compare_primitives
+
+    allowed_properties_1: Any = of_seq(allowed_properties, ObjectExpr1879())
+    class ObjectExpr1880(Decoder_1[_VALUE_]):
+        def Decode(self, helpers: IDecoderHelpers_1[Any], value: Any, allowed_properties: Any=allowed_properties, decoder: Any=decoder) -> FSharpResult_2[_VALUE_, tuple[str, ErrorReason_1[__A_]]]:
+            getters: Getters_2[__A_, Any] = Getters_2__ctor_Z4BE6C149(helpers, value)
+            return FSharpResult_2(1, ("Unknown fields in object", ErrorReason_1(0, "", value))) if Decode_hasUnknownFields(helpers, allowed_properties_1, value) else decoder.Decode(helpers, value)
+
+    return ObjectExpr1880()
+
+
+def Decode_resizeArrayOrSingleton(decoder: Decoder_1[Any]) -> Decoder_1[Array[Any]]:
+    class ObjectExpr1884(Decoder_1[Array[_VALUE_]]):
+        def Decode(self, helpers: IDecoderHelpers_1[Any], value: Any, decoder: Any=decoder) -> FSharpResult_2[Array[_VALUE_], tuple[str, ErrorReason_1[__A_]]]:
+            if helpers.is_array(value):
+                i: int = -1
+                def folder(acc: FSharpResult_2[Array[_VALUE_], tuple[str, ErrorReason_1[__A_]]], value_1: __A_) -> FSharpResult_2[Array[_VALUE_], tuple[str, ErrorReason_1[__A_]]]:
+                    nonlocal i
+                    i = (i + 1) or 0
+                    if acc.tag == 0:
+                        acc_1: Array[_VALUE_] = acc.fields[0]
+                        match_value: FSharpResult_2[_VALUE_, tuple[str, ErrorReason_1[__A_]]] = decoder.Decode(helpers, value_1)
+                        if match_value.tag == 0:
+                            (acc_1.append(match_value.fields[0]))
+                            return FSharpResult_2(0, acc_1)
+
+                        else: 
+                            def _arrow1881(__unit: None=None, acc: Any=acc, value_1: Any=value_1) -> tuple[str, ErrorReason_1[__A_]]:
+                                tupled_arg: tuple[str, ErrorReason_1[__A_]] = match_value.fields[0]
+                                return Helpers_prependPath((".[" + int32_to_string(i)) + "]", tupled_arg[0], tupled_arg[1])
+
+                            return FSharpResult_2(1, _arrow1881())
+
+
+                    else: 
+                        return acc
+
+
+                return fold(folder, FSharpResult_2(0, []), helpers.as_array(value))
+
+            else: 
+                def mapping(x: _VALUE_ | None=None) -> Array[_VALUE_]:
+                    return [x]
+
+                return Result_Map(mapping, decoder.Decode(helpers, value))
+
+
+    return ObjectExpr1884()
+
+
+Decode_datetime: Decoder_1[Any] = map(PyTime_toUniversalTimePy, datetime_local)
+
+__all__ = ["PyTime_toUniversalTimePy", "Helpers_prependPath", "Decode_isURI", "Decode_uri", "Decode_hasUnknownFields", "Decode_objectNoAdditionalProperties", "Decode_noAdditionalProperties", "Decode_resizeArrayOrSingleton", "Decode_datetime"]
+

arctrl/py/Json/encode.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ..fable_modules.fable_library.array_ import map as map_2
+from ..fable_modules.fable_library.date import to_string
+from ..fable_modules.fable_library.list import (is_empty as is_empty_1, map as map_3, FSharpList)
+from ..fable_modules.fable_library.option import (map, default_arg)
+from ..fable_modules.fable_library.seq import (is_empty, map as map_1, append)
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import to_enumerable
+from ..fable_modules.thoth_json_core.encode import (seq, list_1 as list_1_1)
+from ..fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Json)
+
+_VALUE = TypeVar("_VALUE")
+
+__A = TypeVar("__A")
+
+__A_ = TypeVar("__A_")
+
+_T = TypeVar("_T")
+
+def try_include(name: str, encoder: Callable[[_VALUE], IEncodable], value: Any | None=None) -> tuple[str, IEncodable | None]:
+    return (name, map(encoder, value))
+
+
+def try_include_seq(name: Any, encoder: Callable[[_VALUE], IEncodable], value: Any) -> tuple[__A, IEncodable | None]:
+    return (name, None if is_empty(value) else seq(map_1(encoder, value)))
+
+
+def try_include_array(name: Any, encoder: Callable[[_VALUE], IEncodable], value: Array[Any]) -> tuple[__A, IEncodable | None]:
+    def _arrow1883(__unit: None=None, name: Any=name, encoder: Any=encoder, value: Any=value) -> IEncodable:
+        values: Array[IEncodable] = map_2(encoder, value, None)
+        class ObjectExpr1882(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[__A_]) -> __A_:
+                def mapping(v: IEncodable) -> __A_:
+                    return v.Encode(helpers)
+
+                arg: Array[__A_] = map_2(mapping, values, None)
+                return helpers.encode_array(arg)
+
+        return ObjectExpr1882()
+
+    return (name, None if (len(value) == 0) else _arrow1883())
+
+
+def try_include_list(name: Any, encoder: Callable[[_VALUE], IEncodable], value: FSharpList[Any]) -> tuple[__A, IEncodable | None]:
+    return (name, None if is_empty_1(value) else list_1_1(map_3(encoder, value)))
+
+
+def try_include_list_opt(name: Any, encoder: Callable[[_VALUE], IEncodable], value: FSharpList[Any] | None=None) -> tuple[__A, IEncodable | None]:
+    def _arrow1885(__unit: None=None, name: Any=name, encoder: Any=encoder, value: Any=value) -> IEncodable | None:
+        o: FSharpList[_VALUE] = value
+        return None if is_empty_1(o) else list_1_1(map_3(encoder, o))
+
+    return (name, _arrow1885() if (value is not None) else None)
+
+
+DefaultSpaces: int = 0
+
+def default_spaces(spaces: int | None=None) -> int:
+    return default_arg(spaces, DefaultSpaces)
+
+
+def date_time(d: Any) -> IEncodable:
+    value: str = to_string(d, "O", {}).split("+")[0]
+    class ObjectExpr1886(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], d: Any=d) -> Any:
+            return helpers.encode_string(value)
+
+    return ObjectExpr1886()
+
+
+def add_property_to_object(name: str, value: Json, obj: Json) -> Json:
+    if obj.tag == 5:
+        return Json(5, append(obj.fields[0], to_enumerable([(name, value)])))
+
+    else: 
+        raise Exception("Expected object")
+
+
+
+def resize_array_or_singleton(encoder: Callable[[_T], IEncodable], values: Array[Any]) -> IEncodable:
+    if len(values) == 1:
+        return encoder(values[0])
+
+    else: 
+        return seq(map_1(encoder, values))
+
+
+
+__all__ = ["try_include", "try_include_seq", "try_include_array", "try_include_list", "try_include_list_opt", "DefaultSpaces", "default_spaces", "date_time", "add_property_to_object", "resize_array_or_singleton"]
+