arctrl 3.0.0__py3-none-any.whl

arctrl/py/Json/ROCrate/ldcontext.py

@@ -0,0 +1,143 @@
+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_2, init_v1_1)
+
+__A_ = TypeVar("__A_")
+
+class ObjectExpr2571(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 _arrow2570(__unit: None=None) -> str:
+                            object_arg: IRequiredGetter = getters.Required
+                            return object_arg.Field(property, string)
+
+                        o.AddMapping(property, _arrow2570())
+
+            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_2()) if (True if (s == "https://w3id.org/ro/crate/1.2-DRAFT/context") else (s == "https://w3id.org/ro/crate/1.2/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] = ObjectExpr2571()
+
+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.2/context":
+                pattern_matching_result = 1
+
+            elif match_value == "https://w3id.org/ro/crate/1.1/context":
+                pattern_matching_result = 2
+
+            else: 
+                pattern_matching_result = 3
+
+
+        else: 
+            pattern_matching_result = 3
+
+        if pattern_matching_result == 0:
+            class ObjectExpr2572(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 ObjectExpr2572()
+
+        elif pattern_matching_result == 1:
+            class ObjectExpr2573(IEncodable):
+                def Encode(self, helpers_1: IEncoderHelpers_1[Any], ctx: Any=ctx) -> Any:
+                    return helpers_1.encode_string("https://w3id.org/ro/crate/1.2/context")
+
+            return ObjectExpr2573()
+
+        elif pattern_matching_result == 2:
+            class ObjectExpr2574(IEncodable):
+                def Encode(self, helpers_2: IEncoderHelpers_1[Any], ctx: Any=ctx) -> Any:
+                    return helpers_2.encode_string("https://w3id.org/ro/crate/1.1/context")
+
+            return ObjectExpr2574()
+
+        elif pattern_matching_result == 3:
+            mappings: IEncodable
+            def mapping(kv: Any, ctx: Any=ctx) -> tuple[str, IEncodable]:
+                class ObjectExpr2575(IEncodable):
+                    def Encode(self, helpers_3: IEncoderHelpers_1[Any], kv: Any=kv) -> Any:
+                        return helpers_3.encode_string(kv[1])
+
+                return (kv[0], ObjectExpr2575())
+
+            values: IEnumerable_1[tuple[str, IEncodable]] = map(mapping, ctx.Mappings)
+            class ObjectExpr2576(IEncodable):
+                def Encode(self, helpers_4: 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_4))
+
+                    arg: IEnumerable_1[tuple[str, __A_]] = map(mapping_1, values)
+                    return helpers_4.encode_object(arg)
+
+            mappings = ObjectExpr2576()
+            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 _arrow2578(__unit: None=None, ctx: Any=ctx) -> IEnumerable_1[IEncodable]:
+                    source_4: IEnumerable_1[IEncodable] = map(encoder, ctx.BaseContexts)
+                    def _arrow2577(__unit: None=None) -> IEnumerable_1[IEncodable]:
+                        return singleton(mappings) if (len(ctx.Mappings) != 0) else empty()
+
+                    return append(to_list(delay(_arrow2577)), source_4)
+
+                return seq(_arrow2578())
+
+
+        break
+
+
+__all__ = ["decoder", "encoder"]
+

arctrl/py/Json/ROCrate/ldgraph.py

@@ -0,0 +1,117 @@
+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.types import Array
+from ...fable_modules.fable_library.util import (IEnumerable_1, get_enumerator, dispose)
+from ...fable_modules.thoth_json_core.decode import (Getters_2__ctor_Z4BE6C149, Getters_2, IGetters, IOptionalGetter, string, resize_array, 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 _arrow2627(__unit: None=None, obj: Any=obj) -> IEnumerable_1[tuple[str, IEncodable | None]]:
+        def _arrow2622(value: str) -> IEncodable:
+            class ObjectExpr2621(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value)
+
+            return ObjectExpr2621()
+
+        def _arrow2626(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable | None]]:
+            def _arrow2625(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable | None]]:
+                def _arrow2623(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 _arrow2624(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable | None]]:
+                    return singleton(("@graph", seq(map_1(encoder_2, obj.Nodes))))
+
+                return append(collect(_arrow2623, obj.GetProperties(True)), delay(_arrow2624))
+
+            return append(singleton(try_include("@context", encoder_1, obj.TryGetContext())), delay(_arrow2625))
+
+        return append(singleton(try_include("@id", _arrow2622, obj.Id)), delay(_arrow2626))
+
+    values_1: FSharpList[tuple[str, IEncodable]] = choose(chooser, to_list(delay(_arrow2627)))
+    class ObjectExpr2628(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 ObjectExpr2628()
+
+
+class ObjectExpr2630(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: Array[LDNode]
+            arg_5: Decoder_1[Array[LDNode]] = resize_array(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 _arrow2629(__unit: None=None) -> Any:
+                            object_arg_3: IRequiredGetter = get.Required
+                            return object_arg_3.Field(property, generic_decoder)
+
+                        o.SetProperty(property, _arrow2629())
+
+            enumerator_1: Any = get_enumerator(nodes)
+            try: 
+                while enumerator_1.System_Collections_IEnumerator_MoveNext():
+                    node: LDNode = enumerator_1.System_Collections_Generic_IEnumerator_1_get_Current()
+                    o.AddNode(node)
+
+            finally: 
+                dispose(enumerator_1)
+
+            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] = ObjectExpr2630()
+
+__all__ = ["encoder", "decoder"]
+

arctrl/py/Json/ROCrate/ldnode.py

@@ -0,0 +1,304 @@
+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_14
+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, bool_1)
+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 ObjectExpr2579(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any], obj: Any=obj) -> Any:
+                return helpers.encode_string(obj)
+
+        return ObjectExpr2579()
+
+    elif str(type(obj)) == "<class \'int\'>":
+        class ObjectExpr2580(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any], obj: Any=obj) -> Any:
+                return helpers_1.encode_signed_integral_number(obj)
+
+        return ObjectExpr2580()
+
+    elif str(type(obj)) == "<class \'bool\'>":
+        class ObjectExpr2581(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any], obj: Any=obj) -> Any:
+                return helpers_2.encode_bool(obj)
+
+        return ObjectExpr2581()
+
+    elif str(type(obj)) == "<class \'float\'>":
+        class ObjectExpr2582(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any], obj: Any=obj) -> Any:
+                return helpers_3.encode_decimal_number(obj)
+
+        return ObjectExpr2582()
+
+    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 ObjectExpr2583(IEncodable):
+            def Encode(self, helpers_4: IEncoderHelpers_1[Any], obj: Any=obj) -> Any:
+                return helpers_4.encode_null()
+
+        return ObjectExpr2583()
+
+    elif is_iterable(obj):
+        def _arrow2587(__unit: None=None, obj: Any=obj) -> IEnumerable_1[IEncodable]:
+            def _arrow2584(__unit: None=None) -> IEnumerator[Any]:
+                return get_enumerator(obj)
+
+            def _arrow2585(enumerator: IEnumerator[Any]) -> bool:
+                return enumerator.System_Collections_IEnumerator_MoveNext()
+
+            def _arrow2586(enumerator_1: IEnumerator[Any]) -> Any:
+                return enumerator_1.System_Collections_IEnumerator_get_Current()
+
+            return map(generic_encoder, enumerate_from_functions(_arrow2584, _arrow2585, _arrow2586))
+
+        return list_1(to_list(delay(_arrow2587)))
+
+    else: 
+        raise Exception("Unknown type")
+
+
+
+def encoder(obj: LDNode) -> IEncodable:
+    def _arrow2600(__unit: None=None, obj: Any=obj) -> IEnumerable_1[tuple[str, IEncodable]]:
+        def _arrow2589(__unit: None=None) -> IEncodable:
+            value: str = obj.Id
+            class ObjectExpr2588(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value)
+
+            return ObjectExpr2588()
+
+        def _arrow2599(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+            def _arrow2591(value_1: str) -> IEncodable:
+                class ObjectExpr2590(IEncodable):
+                    def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                        return helpers_1.encode_string(value_1)
+
+                return ObjectExpr2590()
+
+            def _arrow2598(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+                def _arrow2593(value_3: str) -> IEncodable:
+                    class ObjectExpr2592(IEncodable):
+                        def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                            return helpers_2.encode_string(value_3)
+
+                    return ObjectExpr2592()
+
+                def _arrow2597(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+                    def _arrow2594(__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 _arrow2596(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+                        def _arrow2595(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(_arrow2595, obj.GetProperties(True))
+
+                    return append(_arrow2594(), delay(_arrow2596))
+
+                return append(singleton(("additionalType", resize_array_or_singleton(_arrow2593, obj.AdditionalType))) if (len(obj.AdditionalType) != 0) else empty(), delay(_arrow2597))
+
+            return append(singleton(("@type", resize_array_or_singleton(_arrow2591, obj.SchemaType))), delay(_arrow2598))
+
+        return append(singleton(("@id", _arrow2589())), delay(_arrow2599))
+
+    values: FSharpList[tuple[str, IEncodable]] = to_list(delay(_arrow2600))
+    class ObjectExpr2601(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 ObjectExpr2601()
+
+
+class ObjectExpr2602(Decoder_1[None]):
+    def Decode(self, helpers: IDecoderHelpers_1[Any], value: Any) -> FSharpResult_2[None, tuple[str, ErrorReason_1[__A_]]]:
+        return FSharpResult_2(0, None) if helpers.is_null_value(value) else FSharpResult_2(1, ("", ErrorReason_1(0, "null", value)))
+
+
+null_decoder: Decoder_1[None] = ObjectExpr2602()
+
+def get_decoder(expect_object: bool) -> Decoder_1[Any]:
+    def decode(expect_object_1: bool, expect_object: Any=expect_object) -> Decoder_1[Any]:
+        class ObjectExpr2604(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 _arrow2603(__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, _arrow2603())
+                    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:
+                                r: Any
+                                arg_9: Decoder_1[Any] = decode(False)
+                                object_arg_4: IRequiredGetter = get.Required
+                                r = object_arg_4.Field(property, arg_9)
+                                if not equals(r, None):
+                                    o.SetProperty(property, r)
+
+
+                    if context is not None:
+                        o.SetContext(value_14(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] = ObjectExpr2604()
+        class ObjectExpr2606(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 _arrow2605(__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, _arrow2605())
+
+
+                        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]] = ObjectExpr2606()
+        if expect_object_1:
+            def _arrow2607(value_4: LDNode, expect_object_1: Any=expect_object_1) -> Any:
+                return value_4
+
+            return map_1(_arrow2607, decode_object)
+
+        else: 
+            def _arrow2609(value_5: LDValue, expect_object_1: Any=expect_object_1) -> Any:
+                return value_5
+
+            def _arrow2610(value_6: LDNode, expect_object_1: Any=expect_object_1) -> Any:
+                return value_6
+
+            def _arrow2611(value_7: LDRef, expect_object_1: Any=expect_object_1) -> Any:
+                return value_7
+
+            def _arrow2612(value_8: Array[Any], expect_object_1: Any=expect_object_1) -> Any:
+                return value_8
+
+            def _arrow2613(value_9: str, expect_object_1: Any=expect_object_1) -> Any:
+                return value_9
+
+            def _arrow2614(value_10: int, expect_object_1: Any=expect_object_1) -> Any:
+                return value_10
+
+            def _arrow2615(value_11: Decimal, expect_object_1: Any=expect_object_1) -> Any:
+                return value_11
+
+            def _arrow2616(value_12: bool, expect_object_1: Any=expect_object_1) -> Any:
+                return value_12
+
+            def _arrow2617(__unit: None=None, expect_object_1: Any=expect_object_1) -> Any:
+                return None
+
+            return one_of(of_array([map_1(_arrow2609, decoder_2), map_1(_arrow2610, decode_object), map_1(_arrow2611, decoder_3), map_1(_arrow2612, resize_array), map_1(_arrow2613, string), map_1(_arrow2614, int_1), map_1(_arrow2615, decimal), map_1(_arrow2616, bool_1), map_1(_arrow2617, null_decoder)]))
+
+
+    return decode(expect_object)
+
+
+def _arrow2618(value: Any=None) -> LDNode:
+    return value
+
+
+decoder: Decoder_1[LDNode] = map_1(_arrow2618, get_decoder(True))
+
+generic_decoder: Decoder_1[Any] = get_decoder(False)
+
+__all__ = ["generic_encoder", "encoder", "null_decoder", "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 _arrow2552(decoders: IGetters) -> LDRef:
+    def _arrow2551(__unit: None=None) -> str:
+        object_arg: IRequiredGetter = decoders.Required
+        return object_arg.Field("@id", string)
+
+    return LDRef(_arrow2551())
+
+
+decoder: Decoder_1[LDRef] = object(_arrow2552)
+
+def encoder(r: LDRef) -> IEncodable:
+    def _arrow2554(__unit: None=None, r: Any=r) -> IEncodable:
+        value: str = r.Id
+        class ObjectExpr2553(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr2553()
+
+    values: FSharpList[tuple[str, IEncodable]] = singleton(("@id", _arrow2554()))
+    class ObjectExpr2555(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 ObjectExpr2555()
+
+
+__all__ = ["decoder", "encoder"]
+