arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/Json/ROCrate/ldcontext.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.list import (FSharpList, is_empty, length, head)
+from ...fable_modules.fable_library.result import FSharpResult_2
+from ...fable_modules.fable_library.seq import (map, append, to_list, delay, singleton, empty)
+from ...fable_modules.fable_library.types import Array
+from ...fable_modules.fable_library.util import (IEnumerable_1, get_enumerator)
+from ...fable_modules.thoth_json_core.decode import (Getters_2__ctor_Z4BE6C149, Getters_2, IRequiredGetter, string, Getters_2__get_Errors, resize_array)
+from ...fable_modules.thoth_json_core.encode import seq
+from ...fable_modules.thoth_json_core.types import (Decoder_1, ErrorReason_1, IDecoderHelpers_1, IEncodable, IEncoderHelpers_1)
+from ...ROCrate.ldcontext import LDContext
+from ...ROCrate.rocrate_context import (init_v1_2draft, init_v1_1)
+
+__A_ = TypeVar("__A_")
+
+class ObjectExpr1907(Decoder_1[LDContext]):
+    def Decode(self, helpers: IDecoderHelpers_1[Any], value: Any) -> FSharpResult_2[LDContext, tuple[str, ErrorReason_1[__A_]]]:
+        this: Decoder_1[LDContext] = self
+        if helpers.is_object(value):
+            getters: Getters_2[__A_, Any] = Getters_2__ctor_Z4BE6C149(helpers, value)
+            properties: IEnumerable_1[str] = helpers.get_properties(value)
+            result: LDContext
+            o: LDContext = LDContext()
+            with get_enumerator(properties) as enumerator:
+                while enumerator.System_Collections_IEnumerator_MoveNext():
+                    property: str = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+                    if (property != "@type") if (property != "@id") else False:
+                        def _arrow1906(__unit: None=None) -> str:
+                            object_arg: IRequiredGetter = getters.Required
+                            return object_arg.Field(property, string)
+
+                        o.AddMapping(property, _arrow1906())
+
+            result = o
+            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)
+
+
+        elif helpers.is_string(value):
+            s: str = helpers.as_string(value)
+            return FSharpResult_2(0, init_v1_2draft()) if (s == "https://w3id.org/ro/crate/1.2-DRAFT/context") else (FSharpResult_2(0, init_v1_1()) if (s == "https://w3id.org/ro/crate/1.1/context") else FSharpResult_2(1, ("", ErrorReason_1(0, "an object", value))))
+
+        elif helpers.is_array(value):
+            match_value_1: FSharpResult_2[Array[LDContext], tuple[str, ErrorReason_1[__A_]]] = resize_array(this).Decode(helpers, value)
+            return FSharpResult_2(1, match_value_1.fields[0]) if (match_value_1.tag == 1) else FSharpResult_2(0, LDContext(None, match_value_1.fields[0]))
+
+        else: 
+            return FSharpResult_2(1, ("", ErrorReason_1(0, "an object", value)))
+
+
+
+decoder: Decoder_1[LDContext] = ObjectExpr1907()
+
+def encoder(ctx_mut: LDContext) -> IEncodable:
+    while True:
+        (ctx,) = (ctx_mut,)
+        match_value: str | None = ctx.Name
+        (pattern_matching_result,) = (None,)
+        if match_value is not None:
+            if match_value == "https://w3id.org/ro/crate/1.2-DRAFT/context":
+                pattern_matching_result = 0
+
+            elif match_value == "https://w3id.org/ro/crate/1.1/context":
+                pattern_matching_result = 1
+
+            else: 
+                pattern_matching_result = 2
+
+
+        else: 
+            pattern_matching_result = 2
+
+        if pattern_matching_result == 0:
+            class ObjectExpr1908(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any], ctx: Any=ctx) -> Any:
+                    return helpers.encode_string("https://w3id.org/ro/crate/1.2-DRAFT/context")
+
+            return ObjectExpr1908()
+
+        elif pattern_matching_result == 1:
+            class ObjectExpr1909(IEncodable):
+                def Encode(self, helpers_1: IEncoderHelpers_1[Any], ctx: Any=ctx) -> Any:
+                    return helpers_1.encode_string("https://w3id.org/ro/crate/1.1/context")
+
+            return ObjectExpr1909()
+
+        elif pattern_matching_result == 2:
+            mappings: IEncodable
+            def mapping(kv: Any, ctx: Any=ctx) -> tuple[str, IEncodable]:
+                class ObjectExpr1910(IEncodable):
+                    def Encode(self, helpers_2: IEncoderHelpers_1[Any], kv: Any=kv) -> Any:
+                        return helpers_2.encode_string(kv[1])
+
+                return (kv[0], ObjectExpr1910())
+
+            values: IEnumerable_1[tuple[str, IEncodable]] = map(mapping, ctx.Mappings)
+            class ObjectExpr1911(IEncodable):
+                def Encode(self, helpers_3: IEncoderHelpers_1[Any], ctx: Any=ctx) -> Any:
+                    def mapping_1(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_1, values)
+                    return helpers_3.encode_object(arg)
+
+            mappings = ObjectExpr1911()
+            if len(ctx.BaseContexts) == 0:
+                return mappings
+
+            elif (len(ctx.Mappings) == 0) if (len(ctx.BaseContexts) == 1) else False:
+                ctx_mut = ctx.BaseContexts[0]
+                continue
+
+            else: 
+                def _arrow1913(__unit: None=None, ctx: Any=ctx) -> IEnumerable_1[IEncodable]:
+                    source_4: IEnumerable_1[IEncodable] = map(encoder, ctx.BaseContexts)
+                    def _arrow1912(__unit: None=None) -> IEnumerable_1[IEncodable]:
+                        return singleton(mappings) if (len(ctx.Mappings) != 0) else empty()
+
+                    return append(to_list(delay(_arrow1912)), source_4)
+
+                return seq(_arrow1913())
+
+
+        break
+
+
+__all__ = ["decoder", "encoder"]
+

arctrl/py/Json/ROCrate/ldgraph.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.list import (choose, FSharpList, is_empty, length, head)
+from ...fable_modules.fable_library.option import map
+from ...fable_modules.fable_library.result import FSharpResult_2
+from ...fable_modules.fable_library.seq import (to_list, delay, append, singleton, collect, empty, map as map_1)
+from ...fable_modules.fable_library.util import (IEnumerable_1, get_enumerator)
+from ...fable_modules.thoth_json_core.decode import (Getters_2__ctor_Z4BE6C149, Getters_2, IGetters, IOptionalGetter, string, seq as seq_1, IRequiredGetter, Getters_2__get_Errors)
+from ...fable_modules.thoth_json_core.encode import seq
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1, ErrorReason_1, IDecoderHelpers_1)
+from ...ROCrate.ldcontext import LDContext
+from ...ROCrate.ldobject import (LDNode, LDGraph)
+from ..encode import try_include
+from .ldcontext import (encoder as encoder_1, decoder as decoder_1)
+from .ldnode import (generic_encoder, encoder as encoder_2, decoder as decoder_2, generic_decoder)
+
+__A_ = TypeVar("__A_")
+
+def encoder(obj: LDGraph) -> IEncodable:
+    def chooser(tupled_arg: tuple[str, IEncodable | None], obj: Any=obj) -> tuple[str, IEncodable] | None:
+        def mapping_1(v_1: IEncodable, tupled_arg: Any=tupled_arg) -> tuple[str, IEncodable]:
+            return (tupled_arg[0], v_1)
+
+        return map(mapping_1, tupled_arg[1])
+
+    def _arrow1960(__unit: None=None, obj: Any=obj) -> IEnumerable_1[tuple[str, IEncodable | None]]:
+        def _arrow1955(value: str) -> IEncodable:
+            class ObjectExpr1954(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value)
+
+            return ObjectExpr1954()
+
+        def _arrow1959(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable | None]]:
+            def _arrow1958(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable | None]]:
+                def _arrow1956(kv: Any) -> IEnumerable_1[tuple[str, IEncodable | None]]:
+                    l: str = kv[0].lower()
+                    return singleton((kv[0], generic_encoder(kv[1]))) if ((l != "mappings") if ((l != "nodes") if ((l != "@context") if (l != "id") else False) else False) else False) else empty()
+
+                def _arrow1957(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable | None]]:
+                    return singleton(("@graph", seq(map_1(encoder_2, obj.Nodes))))
+
+                return append(collect(_arrow1956, obj.GetProperties(True)), delay(_arrow1957))
+
+            return append(singleton(try_include("@context", encoder_1, obj.TryGetContext())), delay(_arrow1958))
+
+        return append(singleton(try_include("@id", _arrow1955, obj.Id)), delay(_arrow1959))
+
+    values_1: FSharpList[tuple[str, IEncodable]] = choose(chooser, to_list(delay(_arrow1960)))
+    class ObjectExpr1961(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], obj: Any=obj) -> Any:
+            def mapping_2(tupled_arg_1: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg_1[0], tupled_arg_1[1].Encode(helpers_1))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_2, values_1)
+            return helpers_1.encode_object(arg)
+
+    return ObjectExpr1961()
+
+
+class ObjectExpr1963(Decoder_1[LDGraph]):
+    def Decode(self, helpers: IDecoderHelpers_1[Any], value: Any) -> FSharpResult_2[LDGraph, tuple[str, ErrorReason_1[__A_]]]:
+        if helpers.is_object(value):
+            getters: Getters_2[__A_, Any] = Getters_2__ctor_Z4BE6C149(helpers, value)
+            properties: IEnumerable_1[str] = helpers.get_properties(value)
+            result: LDGraph
+            get: IGetters = getters
+            id: str | None
+            object_arg: IOptionalGetter = get.Optional
+            id = object_arg.Field("@id", string)
+            context: LDContext | None
+            object_arg_1: IOptionalGetter = get.Optional
+            context = object_arg_1.Field("@context", decoder_1)
+            nodes: IEnumerable_1[LDNode]
+            arg_5: Decoder_1[IEnumerable_1[LDNode]] = seq_1(decoder_2)
+            object_arg_2: IRequiredGetter = get.Required
+            nodes = object_arg_2.Field("@graph", arg_5)
+            o: LDGraph = LDGraph(id, None, context)
+            with get_enumerator(properties) as enumerator:
+                while enumerator.System_Collections_IEnumerator_MoveNext():
+                    property: str = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+                    if (property != "@context") if ((property != "@graph") if (property != "@id") else False) else False:
+                        def _arrow1962(__unit: None=None) -> Any:
+                            object_arg_3: IRequiredGetter = get.Required
+                            return object_arg_3.Field(property, generic_decoder)
+
+                        o.SetProperty(property, _arrow1962())
+
+            with get_enumerator(nodes) as enumerator_1:
+                while enumerator_1.System_Collections_IEnumerator_MoveNext():
+                    node: LDNode = enumerator_1.System_Collections_Generic_IEnumerator_1_get_Current()
+                    o.AddNode(node)
+            result = o
+            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)
+
+
+        else: 
+            return FSharpResult_2(1, ("", ErrorReason_1(0, "an object", value)))
+
+
+
+decoder: Decoder_1[LDGraph] = ObjectExpr1963()
+
+__all__ = ["encoder", "decoder"]
+

arctrl/py/Json/ROCrate/ldnode.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+from collections.abc import Callable
+from datetime import datetime
+from decimal import Decimal
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.array_ import fold
+from ...fable_modules.fable_library.list import (FSharpList, is_empty, length, head, of_array)
+from ...fable_modules.fable_library.option import value as value_12
+from ...fable_modules.fable_library.result import FSharpResult_2
+from ...fable_modules.fable_library.seq import (to_list, delay, map, enumerate_from_functions, append, singleton, empty, collect)
+from ...fable_modules.fable_library.string_ import starts_with_exact
+from ...fable_modules.fable_library.types import Array
+from ...fable_modules.fable_library.util import (equals, is_iterable, get_enumerator, IEnumerator, IEnumerable_1, int32_to_string)
+from ...fable_modules.thoth_json_core.decode import (Getters_2__ctor_Z4BE6C149, Getters_2, IGetters, string, IRequiredGetter, IOptionalGetter, Getters_2__get_Errors, map as map_1, one_of, int_1, decimal)
+from ...fable_modules.thoth_json_core.encode import list_1
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1, ErrorReason_1, IDecoderHelpers_1)
+from ...ROCrate.ldcontext import LDContext
+from ...ROCrate.ldobject import (LDValue, LDRef, LDNode)
+from ..decode import (Decode_resizeArrayOrSingleton, Helpers_prependPath)
+from ..encode import (date_time, resize_array_or_singleton)
+from .ldcontext import (encoder as encoder_3, decoder as decoder_1)
+from .ldref import (encoder as encoder_2, decoder as decoder_3)
+from .ldvalue import (encoder as encoder_1, decoder as decoder_2)
+
+__A_ = TypeVar("__A_")
+
+def generic_encoder(obj: Any=None) -> IEncodable:
+    if str(type(obj)) == "<class \'str\'>":
+        class ObjectExpr1914(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any], obj: Any=obj) -> Any:
+                return helpers.encode_string(obj)
+
+        return ObjectExpr1914()
+
+    elif str(type(obj)) == "<class \'int\'>":
+        class ObjectExpr1915(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any], obj: Any=obj) -> Any:
+                return helpers_1.encode_signed_integral_number(obj)
+
+        return ObjectExpr1915()
+
+    elif str(type(obj)) == "<class \'bool\'>":
+        class ObjectExpr1916(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any], obj: Any=obj) -> Any:
+                return helpers_2.encode_bool(obj)
+
+        return ObjectExpr1916()
+
+    elif str(type(obj)) == "<class \'float\'>":
+        class ObjectExpr1917(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any], obj: Any=obj) -> Any:
+                return helpers_3.encode_decimal_number(obj)
+
+        return ObjectExpr1917()
+
+    elif isinstance(obj, datetime):
+        return date_time(obj)
+
+    elif isinstance(obj, LDValue):
+        return encoder_1(obj)
+
+    elif isinstance(obj, LDRef):
+        return encoder_2(obj)
+
+    elif isinstance(obj, LDNode):
+        return encoder(obj)
+
+    elif equals(obj, None):
+        class ObjectExpr1918(IEncodable):
+            def Encode(self, helpers_4: IEncoderHelpers_1[Any], obj: Any=obj) -> Any:
+                return helpers_4.encode_null()
+
+        return ObjectExpr1918()
+
+    elif is_iterable(obj):
+        def _arrow1922(__unit: None=None, obj: Any=obj) -> IEnumerable_1[IEncodable]:
+            def _arrow1919(__unit: None=None) -> IEnumerator[Any]:
+                return get_enumerator(obj)
+
+            def _arrow1920(enumerator: IEnumerator[Any]) -> bool:
+                return enumerator.System_Collections_IEnumerator_MoveNext()
+
+            def _arrow1921(enumerator_1: IEnumerator[Any]) -> Any:
+                return enumerator_1.System_Collections_IEnumerator_get_Current()
+
+            return map(generic_encoder, enumerate_from_functions(_arrow1919, _arrow1920, _arrow1921))
+
+        return list_1(to_list(delay(_arrow1922)))
+
+    else: 
+        raise Exception("Unknown type")
+
+
+
+def encoder(obj: LDNode) -> IEncodable:
+    def _arrow1935(__unit: None=None, obj: Any=obj) -> IEnumerable_1[tuple[str, IEncodable]]:
+        def _arrow1924(__unit: None=None) -> IEncodable:
+            value: str = obj.Id
+            class ObjectExpr1923(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value)
+
+            return ObjectExpr1923()
+
+        def _arrow1934(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+            def _arrow1926(value_1: str) -> IEncodable:
+                class ObjectExpr1925(IEncodable):
+                    def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                        return helpers_1.encode_string(value_1)
+
+                return ObjectExpr1925()
+
+            def _arrow1933(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+                def _arrow1928(value_3: str) -> IEncodable:
+                    class ObjectExpr1927(IEncodable):
+                        def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                            return helpers_2.encode_string(value_3)
+
+                    return ObjectExpr1927()
+
+                def _arrow1932(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+                    def _arrow1929(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+                        match_value: LDContext | None = obj.TryGetContext()
+                        if match_value is not None:
+                            return singleton(("@context", encoder_3(match_value)))
+
+                        else: 
+                            return empty()
+
+
+                    def _arrow1931(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+                        def _arrow1930(kv: Any) -> IEnumerable_1[tuple[str, IEncodable]]:
+                            l: str = kv[0].lower()
+                            return singleton((kv[0], generic_encoder(kv[1]))) if ((not starts_with_exact(l, "init_")) if ((not starts_with_exact(l, "init@")) if ((l != "@context") if ((l != "additionaltype") if ((l != "schematype") if (l != "id") else False) else False) else False) else False) else False) else empty()
+
+                        return collect(_arrow1930, obj.GetProperties(True))
+
+                    return append(_arrow1929(), delay(_arrow1931))
+
+                return append(singleton(("additionalType", resize_array_or_singleton(_arrow1928, obj.AdditionalType))) if (len(obj.AdditionalType) != 0) else empty(), delay(_arrow1932))
+
+            return append(singleton(("@type", resize_array_or_singleton(_arrow1926, obj.SchemaType))), delay(_arrow1933))
+
+        return append(singleton(("@id", _arrow1924())), delay(_arrow1934))
+
+    values: FSharpList[tuple[str, IEncodable]] = to_list(delay(_arrow1935))
+    class ObjectExpr1936(IEncodable):
+        def Encode(self, helpers_3: IEncoderHelpers_1[Any], obj: Any=obj) -> 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)
+            return helpers_3.encode_object(arg)
+
+    return ObjectExpr1936()
+
+
+def get_decoder(expect_object: bool) -> Decoder_1[Any]:
+    def decode(expect_object_1: bool, expect_object: Any=expect_object) -> Decoder_1[Any]:
+        class ObjectExpr1939(Decoder_1[LDNode]):
+            def Decode(self, helpers: IDecoderHelpers_1[Any], value: Any, expect_object_1: Any=expect_object_1) -> FSharpResult_2[LDNode, tuple[str, ErrorReason_1[__A_]]]:
+                if helpers.is_object(value):
+                    getters: Getters_2[__A_, Any] = Getters_2__ctor_Z4BE6C149(helpers, value)
+                    properties: IEnumerable_1[str] = helpers.get_properties(value)
+                    result: LDNode
+                    get: IGetters = getters
+                    t: Array[str]
+                    arg_1: Decoder_1[Array[str]] = Decode_resizeArrayOrSingleton(string)
+                    object_arg: IRequiredGetter = get.Required
+                    t = object_arg.Field("@type", arg_1)
+                    id: str
+                    object_arg_1: IRequiredGetter = get.Required
+                    id = object_arg_1.Field("@id", string)
+                    context: LDContext | None
+                    object_arg_2: IOptionalGetter = get.Optional
+                    context = object_arg_2.Field("@context", decoder_1)
+                    def _arrow1937(__unit: None=None) -> Array[str] | None:
+                        arg_7: Decoder_1[Array[str]] = Decode_resizeArrayOrSingleton(string)
+                        object_arg_3: IOptionalGetter = get.Optional
+                        return object_arg_3.Field("additionalType", arg_7)
+
+                    o: LDNode = LDNode(id, t, _arrow1937())
+                    with get_enumerator(properties) as enumerator:
+                        while enumerator.System_Collections_IEnumerator_MoveNext():
+                            property: str = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+                            if (property != "@context") if ((property != "@type") if (property != "@id") else False) else False:
+                                def _arrow1938(__unit: None=None) -> Any:
+                                    arg_9: Decoder_1[Any] = decode(False)
+                                    object_arg_4: IRequiredGetter = get.Required
+                                    return object_arg_4.Field(property, arg_9)
+
+                                o.SetProperty(property, _arrow1938())
+
+                    if context is not None:
+                        o.SetContext(value_12(context))
+
+                    result = o
+                    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)
+
+
+                else: 
+                    return FSharpResult_2(1, ("", ErrorReason_1(0, "an object", value)))
+
+
+        decode_object: Decoder_1[LDNode] = ObjectExpr1939()
+        class ObjectExpr1941(Decoder_1[Array[Any]]):
+            def Decode(self, helpers_1: IDecoderHelpers_1[Any], value_1: Any, expect_object_1: Any=expect_object_1) -> FSharpResult_2[Array[Any], tuple[str, ErrorReason_1[__A_]]]:
+                if helpers_1.is_array(value_1):
+                    i: int = -1
+                    def folder(acc: FSharpResult_2[Array[Any], tuple[str, ErrorReason_1[__A_]]], value_2: __A_) -> FSharpResult_2[Array[Any], tuple[str, ErrorReason_1[__A_]]]:
+                        nonlocal i
+                        i = (i + 1) or 0
+                        if acc.tag == 0:
+                            acc_1: Array[Any] = acc.fields[0]
+                            match_value_1: FSharpResult_2[Any, tuple[str, ErrorReason_1[__A_]]]
+                            copy_of_struct: Decoder_1[Any] = decode(False)
+                            match_value_1 = copy_of_struct.Decode(helpers_1, value_2)
+                            if match_value_1.tag == 0:
+                                (acc_1.append(match_value_1.fields[0]))
+                                return FSharpResult_2(0, acc_1)
+
+                            else: 
+                                def _arrow1940(__unit: None=None, acc: Any=acc, value_2: Any=value_2) -> tuple[str, ErrorReason_1[__A_]]:
+                                    tupled_arg: tuple[str, ErrorReason_1[__A_]] = match_value_1.fields[0]
+                                    return Helpers_prependPath((".[" + int32_to_string(i)) + "]", tupled_arg[0], tupled_arg[1])
+
+                                return FSharpResult_2(1, _arrow1940())
+
+
+                        else: 
+                            return acc
+
+
+                    return fold(folder, FSharpResult_2(0, []), helpers_1.as_array(value_1))
+
+                else: 
+                    return FSharpResult_2(1, ("", ErrorReason_1(0, "an array", value_1)))
+
+
+        resize_array: Decoder_1[Array[Any]] = ObjectExpr1941()
+        if expect_object_1:
+            def _arrow1942(value_4: LDNode, expect_object_1: Any=expect_object_1) -> Any:
+                return value_4
+
+            return map_1(_arrow1942, decode_object)
+
+        else: 
+            def _arrow1944(value_5: LDValue, expect_object_1: Any=expect_object_1) -> Any:
+                return value_5
+
+            def _arrow1945(value_6: LDNode, expect_object_1: Any=expect_object_1) -> Any:
+                return value_6
+
+            def _arrow1946(value_7: LDRef, expect_object_1: Any=expect_object_1) -> Any:
+                return value_7
+
+            def _arrow1947(value_8: Array[Any], expect_object_1: Any=expect_object_1) -> Any:
+                return value_8
+
+            def _arrow1948(value_9: str, expect_object_1: Any=expect_object_1) -> Any:
+                return value_9
+
+            def _arrow1949(value_10: int, expect_object_1: Any=expect_object_1) -> Any:
+                return value_10
+
+            def _arrow1950(value_11: Decimal, expect_object_1: Any=expect_object_1) -> Any:
+                return value_11
+
+            return one_of(of_array([map_1(_arrow1944, decoder_2), map_1(_arrow1945, decode_object), map_1(_arrow1946, decoder_3), map_1(_arrow1947, resize_array), map_1(_arrow1948, string), map_1(_arrow1949, int_1), map_1(_arrow1950, decimal)]))
+
+
+    return decode(expect_object)
+
+
+def _arrow1951(value: Any=None) -> LDNode:
+    return value
+
+
+decoder: Decoder_1[LDNode] = map_1(_arrow1951, get_decoder(True))
+
+generic_decoder: Decoder_1[Any] = get_decoder(False)
+
+__all__ = ["generic_encoder", "encoder", "get_decoder", "decoder", "generic_decoder"]
+

arctrl/py/Json/ROCrate/ldref.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.list import (singleton, FSharpList)
+from ...fable_modules.fable_library.seq import map
+from ...fable_modules.fable_library.util import IEnumerable_1
+from ...fable_modules.thoth_json_core.decode import (object, IRequiredGetter, string, IGetters)
+from ...fable_modules.thoth_json_core.types import (Decoder_1, IEncodable, IEncoderHelpers_1)
+from ...ROCrate.ldobject import LDRef
+
+__A_ = TypeVar("__A_")
+
+def _arrow1888(decoders: IGetters) -> LDRef:
+    def _arrow1887(__unit: None=None) -> str:
+        object_arg: IRequiredGetter = decoders.Required
+        return object_arg.Field("@id", string)
+
+    return LDRef(_arrow1887())
+
+
+decoder: Decoder_1[LDRef] = object(_arrow1888)
+
+def encoder(r: LDRef) -> IEncodable:
+    def _arrow1890(__unit: None=None, r: Any=r) -> IEncodable:
+        value: str = r.Id
+        class ObjectExpr1889(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr1889()
+
+    values: FSharpList[tuple[str, IEncodable]] = singleton(("@id", _arrow1890()))
+    class ObjectExpr1891(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], r: Any=r) -> Any:
+            def mapping(tupled_arg: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers_1))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map(mapping, values)
+            return helpers_1.encode_object(arg)
+
+    return ObjectExpr1891()
+
+
+__all__ = ["decoder", "encoder"]
+

arctrl/py/Json/ROCrate/ldvalue.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+from datetime import datetime
+from decimal import Decimal
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.list import (of_array, FSharpList)
+from ...fable_modules.fable_library.seq import map as map_1
+from ...fable_modules.fable_library.util import IEnumerable_1
+from ...fable_modules.thoth_json_core.decode import (one_of, map, string, int_1, decimal, object, IRequiredGetter, IOptionalGetter, IGetters)
+from ...fable_modules.thoth_json_core.types import (Decoder_1, IEncodable, IEncoderHelpers_1)
+from ...ROCrate.ldobject import LDValue
+from ..encode import date_time
+
+__A_ = TypeVar("__A_")
+
+def _arrow1893(value: str) -> Any:
+    return value
+
+
+def _arrow1894(value_1: int) -> Any:
+    return value_1
+
+
+def _arrow1895(value_2: Decimal) -> Any:
+    return value_2
+
+
+generic_decoder: Decoder_1[Any] = one_of(of_array([map(_arrow1893, string), map(_arrow1894, int_1), map(_arrow1895, decimal)]))
+
+def generic_encoder(value: Any=None) -> IEncodable:
+    if str(type(value)) == "<class \'str\'>":
+        class ObjectExpr1896(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr1896()
+
+    elif str(type(value)) == "<class \'int\'>":
+        class ObjectExpr1897(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_1.encode_signed_integral_number(value)
+
+        return ObjectExpr1897()
+
+    elif str(type(value)) == "<class \'bool\'>":
+        class ObjectExpr1898(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_2.encode_bool(value)
+
+        return ObjectExpr1898()
+
+    elif str(type(value)) == "<class \'float\'>":
+        class ObjectExpr1899(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_3.encode_decimal_number(value)
+
+        return ObjectExpr1899()
+
+    elif isinstance(value, datetime):
+        return date_time(value)
+
+    else: 
+        raise Exception("Unknown type")
+
+
+
+def _arrow1902(decoders: IGetters) -> LDValue:
+    def _arrow1900(__unit: None=None) -> Any:
+        object_arg: IRequiredGetter = decoders.Required
+        return object_arg.Field("@value", generic_decoder)
+
+    def _arrow1901(__unit: None=None) -> str | None:
+        object_arg_1: IOptionalGetter = decoders.Optional
+        return object_arg_1.Field("@type", string)
+
+    return LDValue(_arrow1900(), _arrow1901())
+
+
+decoder: Decoder_1[LDValue] = object(_arrow1902)
+
+def encoder(v: LDValue) -> IEncodable:
+    def _arrow1904(__unit: None=None, v: Any=v) -> IEncodable:
+        value: str = v.ValueType
+        class ObjectExpr1903(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr1903()
+
+    values: FSharpList[tuple[str, IEncodable]] = of_array([("@value", generic_encoder(v.Value)), ("@type", _arrow1904())])
+    class ObjectExpr1905(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], v: Any=v) -> Any:
+            def mapping(tupled_arg: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers_1))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping, values)
+            return helpers_1.encode_object(arg)
+
+    return ObjectExpr1905()
+
+
+__all__ = ["generic_decoder", "generic_encoder", "decoder", "encoder"]
+