arctrl 3.0.0__py3-none-any.whl

arctrl/py/Json/decode.py

@@ -0,0 +1,271 @@
+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, empty, cons, tail)
+from ..fable_modules.fable_library.map_util import add_to_dict
+from ..fable_modules.fable_library.mutable_map import Dictionary
+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, equals, structural_hash)
+from ..fable_modules.thoth_json_core.decode import (string, Getters_2__ctor_Z4BE6C149, Getters_2, Getters_2__get_Errors, IGetters, map, datetime_local, tuple2, int_1)
+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")
+
+_KEY__ = TypeVar("_KEY__")
+
+_KEY_ = TypeVar("_KEY_")
+
+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 ObjectExpr2532(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] = ObjectExpr2532()
+
+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 ObjectExpr2533:
+        @property
+        def Compare(self) -> Callable[[str, str], int]:
+            return compare_primitives
+
+    allowed_properties_1: Any = of_seq(allowed_properties, ObjectExpr2533())
+    class ObjectExpr2534(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 ObjectExpr2534()
+
+
+def Decode_noAdditionalProperties(allowed_properties: IEnumerable_1[str], decoder: Decoder_1[Any]) -> Decoder_1[Any]:
+    class ObjectExpr2535:
+        @property
+        def Compare(self) -> Callable[[str, str], int]:
+            return compare_primitives
+
+    allowed_properties_1: Any = of_seq(allowed_properties, ObjectExpr2535())
+    class ObjectExpr2536(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 ObjectExpr2536()
+
+
+def Decode_resizeArrayOrSingleton(decoder: Decoder_1[Any]) -> Decoder_1[Array[Any]]:
+    class ObjectExpr2540(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 _arrow2537(__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, _arrow2537())
+
+
+                    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 ObjectExpr2540()
+
+
+Decode_datetime: Decoder_1[Any] = map(PyTime_toUniversalTimePy, datetime_local)
+
+def Decode_dictionary(key_decoder: Decoder_1[Any], value_decoder: Decoder_1[Any]) -> Decoder_1[Any]:
+    class ObjectExpr2545(Decoder_1[Any]):
+        def Decode(self, helpers: IDecoderHelpers_1[Any], value: Any, key_decoder: Any=key_decoder, value_decoder: Any=value_decoder) -> FSharpResult_2[Any, tuple[str, ErrorReason_1[__A_]]]:
+            if helpers.is_array(value):
+                errors: FSharpList[Any] = empty()
+                tokens: Array[__A_] = helpers.as_array(value)
+                class ObjectExpr2543:
+                    @property
+                    def Equals(self) -> Callable[[_KEY__, _KEY__], bool]:
+                        return equals
+
+                    @property
+                    def GetHashCode(self) -> Callable[[_KEY__], int]:
+                        return structural_hash
+
+                dict_1: Any = Dictionary([], ObjectExpr2543())
+                decoder: Decoder_1[tuple[_KEY_, _VALUE_]] = tuple2(key_decoder, value_decoder)
+                def folder(acc: FSharpResult_2[Any, tuple[str, ErrorReason_1[__A_]]], value_1: __A_) -> FSharpResult_2[Any, tuple[str, ErrorReason_1[__A_]]]:
+                    if acc.tag == 0:
+                        acc_1: Any = acc.fields[0]
+                        match_value: FSharpResult_2[tuple[_KEY_, _VALUE_], tuple[str, ErrorReason_1[__A_]]] = decoder.Decode(helpers, value_1)
+                        if match_value.tag == 0:
+                            tupled_arg: tuple[_KEY_, _VALUE_] = match_value.fields[0]
+                            add_to_dict(acc_1, tupled_arg[0], tupled_arg[1])
+                            return FSharpResult_2(0, acc_1)
+
+                        else: 
+                            return FSharpResult_2(1, match_value.fields[0])
+
+
+                    else: 
+                        return acc
+
+
+                return fold(folder, FSharpResult_2(0, dict_1), tokens)
+
+            else: 
+                return FSharpResult_2(1, ("", ErrorReason_1(0, "an object", value)))
+
+
+    return ObjectExpr2545()
+
+
+def Decode_intDictionary(value_decoder: Decoder_1[Any]) -> Decoder_1[Any]:
+    class ObjectExpr2549(Decoder_1[Any]):
+        def Decode(self, helpers: IDecoderHelpers_1[Any], value: Any, value_decoder: Any=value_decoder) -> FSharpResult_2[Any, tuple[str, ErrorReason_1[__A_]]]:
+            if helpers.is_array(value):
+                errors: FSharpList[Any] = empty()
+                tokens: Array[__A_] = helpers.as_array(value)
+                dict_1: Any = dict([])
+                decoder: Decoder_1[tuple[int, _VALUE_]] = tuple2(int_1, value_decoder)
+                def folder(acc: FSharpResult_2[Any, tuple[str, ErrorReason_1[__A_]]], value_1: __A_) -> FSharpResult_2[Any, tuple[str, ErrorReason_1[__A_]]]:
+                    if acc.tag == 0:
+                        acc_1: Any = acc.fields[0]
+                        match_value: FSharpResult_2[tuple[int, _VALUE_], tuple[str, ErrorReason_1[__A_]]] = decoder.Decode(helpers, value_1)
+                        if match_value.tag == 0:
+                            tupled_arg: tuple[int, _VALUE_] = match_value.fields[0]
+                            add_to_dict(acc_1, tupled_arg[0], tupled_arg[1])
+                            return FSharpResult_2(0, acc_1)
+
+                        else: 
+                            return FSharpResult_2(1, match_value.fields[0])
+
+
+                    else: 
+                        return acc
+
+
+                return fold(folder, FSharpResult_2(0, dict_1), tokens)
+
+            else: 
+                return FSharpResult_2(1, ("", ErrorReason_1(0, "an object", value)))
+
+
+    return ObjectExpr2549()
+
+
+def Decode_tryOneOf(decoders: FSharpList[Decoder_1[Any]]) -> Decoder_1[Any]:
+    class ObjectExpr2550(Decoder_1[_VALUE_]):
+        def Decode(self, helpers: IDecoderHelpers_1[Any], value: Any, decoders: Any=decoders) -> FSharpResult_2[_VALUE_, tuple[str, ErrorReason_1[__A_]]]:
+            def loop(errors_mut: FSharpList[tuple[str, ErrorReason_1[__A_]]], decoders_1_mut: FSharpList[Decoder_1[_VALUE_]]) -> FSharpResult_2[_VALUE_, tuple[str, ErrorReason_1[__A_]]]:
+                while True:
+                    (errors, decoders_1) = (errors_mut, decoders_1_mut)
+                    if not is_empty(decoders_1):
+                        decoding_result: FSharpResult_2[_VALUE_, tuple[str, ErrorReason_1[__A_]]]
+                        try: 
+                            decoding_result = head(decoders_1).Decode(helpers, value)
+
+                        except Exception as e:
+                            decoding_result = FSharpResult_2(1, ("", ErrorReason_1(6, str(e))))
+
+                        if decoding_result.tag == 1:
+                            errors_mut = cons(decoding_result.fields[0], errors)
+                            decoders_1_mut = tail(decoders_1)
+                            continue
+
+                        else: 
+                            return FSharpResult_2(0, decoding_result.fields[0])
+
+
+                    else: 
+                        return FSharpResult_2(1, ("", ErrorReason_1(7, errors)))
+
+                    break
+
+            return loop(empty(), decoders)
+
+    return ObjectExpr2550()
+
+
+__all__ = ["PyTime_toUniversalTimePy", "Helpers_prependPath", "Decode_isURI", "Decode_uri", "Decode_hasUnknownFields", "Decode_objectNoAdditionalProperties", "Decode_noAdditionalProperties", "Decode_resizeArrayOrSingleton", "Decode_datetime", "Decode_dictionary", "Decode_intDictionary", "Decode_tryOneOf"]
+

arctrl/py/Json/encode.py

@@ -0,0 +1,140 @@
+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, to_array)
+from ..fable_modules.fable_library.string_ import (to_fail, printf)
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import (to_enumerable, count, IDictionary)
+from ..fable_modules.thoth_json_core.encode import (seq, list_1 as list_1_1, tuple2)
+from ..fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Json)
+
+_VALUE = TypeVar("_VALUE")
+
+__A = TypeVar("__A")
+
+__A_ = TypeVar("__A_")
+
+_T = TypeVar("_T")
+
+_KEY = TypeVar("_KEY")
+
+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 _arrow2539(__unit: None=None, name: Any=name, encoder: Any=encoder, value: Any=value) -> IEncodable:
+        values: Array[IEncodable] = map_2(encoder, value, None)
+        class ObjectExpr2538(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 ObjectExpr2538()
+
+    return (name, None if (len(value) == 0) else _arrow2539())
+
+
+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 _arrow2541(__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, _arrow2541() 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 ObjectExpr2542(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], d: Any=d) -> Any:
+            return helpers.encode_string(value)
+
+    return ObjectExpr2542()
+
+
+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))
+
+
+
+def dictionary(key_encoder: Callable[[_KEY], IEncodable], value_encoder: Callable[[_VALUE], IEncodable], values: IDictionary[Any, Any]) -> IEncodable:
+    if count(values) == 0:
+        class ObjectExpr2544(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any], key_encoder: Any=key_encoder, value_encoder: Any=value_encoder, values: Any=values) -> Any:
+                return helpers.encode_null()
+
+        return ObjectExpr2544()
+
+    else: 
+        def mapping(_arg: Any, key_encoder: Any=key_encoder, value_encoder: Any=value_encoder, values: Any=values) -> IEncodable:
+            active_pattern_result: tuple[_KEY, _VALUE] = _arg
+            return tuple2(key_encoder, value_encoder, active_pattern_result[0], active_pattern_result[1])
+
+        return seq(to_array(map_1(mapping, values)))
+
+
+
+def int_dictionary(value_encoder: Callable[[_VALUE], IEncodable], values: IDictionary[int, Any]) -> IEncodable:
+    if count(values) == 0:
+        class ObjectExpr2546(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any], value_encoder: Any=value_encoder, values: Any=values) -> Any:
+                return helpers.encode_null()
+
+        return ObjectExpr2546()
+
+    else: 
+        def mapping(_arg: Any, value_encoder: Any=value_encoder, values: Any=values) -> IEncodable:
+            active_pattern_result: tuple[int, _VALUE] = _arg
+            k: int = active_pattern_result[0] or 0
+            if True if (k > 2147483647) else (k < -2147483648):
+                to_fail(printf("Key %d is out of bounds for Int32"))(k)
+
+            def _arrow2548(value: int, _arg: Any=_arg) -> IEncodable:
+                class ObjectExpr2547(IEncodable):
+                    def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                        return helpers_1.encode_signed_integral_number(value)
+
+                return ObjectExpr2547()
+
+            return tuple2(_arrow2548, value_encoder, k, active_pattern_result[1])
+
+        return seq(to_array(map_1(mapping, 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", "dictionary", "int_dictionary"]
+

arctrl/py/Json/idtable.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ..fable_modules.fable_library.list import (singleton, FSharpList)
+from ..fable_modules.fable_library.map_util import add_to_dict
+from ..fable_modules.fable_library.seq import map
+from ..fable_modules.fable_library.util import IEnumerable_1
+from ..fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1)
+
+__A_ = TypeVar("__A_")
+
+_VALUE = TypeVar("_VALUE")
+
+def encode_id(id: str) -> IEncodable:
+    class ObjectExpr2619(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], id: Any=id) -> Any:
+            return helpers.encode_string(id)
+
+    values: FSharpList[tuple[str, IEncodable]] = singleton(("@id", ObjectExpr2619()))
+    class ObjectExpr2620(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], id: Any=id) -> 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 ObjectExpr2620()
+
+
+def encode(gen_id: Callable[[_VALUE], str], encoder: Callable[[_VALUE], IEncodable], value: Any, table: Any) -> IEncodable:
+    id: str = gen_id(value)
+    if id in table:
+        return encode_id(id)
+
+    else: 
+        v: IEncodable = encoder(value)
+        add_to_dict(table, gen_id(value), v)
+        return v
+
+
+
+__all__ = ["encode_id", "encode"]
+