arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/fable_modules/fable_library/bit_converter.py

@@ -0,0 +1,131 @@
+import struct
+import sys
+
+
+def get_bytes_char(value: str) -> bytes:
+    return bytes(value, "UTF-8")
+
+
+def get_bytes_int16(value: int) -> bytes:
+    return value.to_bytes(length=2, byteorder=sys.byteorder)
+
+
+def get_bytes_uint16(value: int) -> bytes:
+    return value.to_bytes(length=2, byteorder=sys.byteorder)
+
+
+def get_bytes_int32(value: int) -> bytes:
+    return value.to_bytes(length=4, byteorder=sys.byteorder)
+
+
+def get_bytes_uint32(value: int) -> bytes:
+    return value.to_bytes(length=4, byteorder=sys.byteorder)
+
+
+def get_bytes_int64(value: int) -> bytes:
+    return value.to_bytes(length=8, byteorder=sys.byteorder)
+
+
+def get_bytes_uint64(value: int) -> bytes:
+    return value.to_bytes(length=8, byteorder=sys.byteorder)
+
+
+def get_bytes_boolean(value: bool) -> bytes:
+    return value.to_bytes(length=1, byteorder=sys.byteorder)
+
+
+def get_bytes_single(value: float) -> bytes:
+    return struct.pack("f", value)
+
+
+def get_bytes_double(value: float) -> bytes:
+    return struct.pack("d", value)
+
+
+def int64bits_to_double(value: int) -> float:
+    bytes = value.to_bytes(length=8, byteorder=sys.byteorder)
+    [number] = struct.unpack("d", bytes)
+    return number
+
+
+def double_to_int64bits(value: float) -> int:
+    bytes = bytearray(struct.pack("d", value))
+    [number] = struct.unpack("q", bytes)
+    return number
+
+
+def to_boolean(bytes: bytearray, offset: int) -> bool:
+    return bool(bool.from_bytes(bytes[offset : offset + 1], byteorder=sys.byteorder))
+
+
+def to_char(bytes: bytearray, offset: int) -> str:
+    return bytes[offset : offset + 1].decode("utf8")
+
+
+def to_int16(bytes: bytearray, offset: int) -> int:
+    return int.from_bytes(bytes[offset : offset + 2], byteorder=sys.byteorder, signed=True)
+
+
+def to_uint16(bytes: bytearray, offset: int) -> int:
+    return int.from_bytes(bytes[offset : offset + 2], byteorder=sys.byteorder, signed=False)
+
+
+def to_int32(bytes: bytearray, offset: int) -> int:
+    return int.from_bytes(bytes[offset : offset + 4], byteorder=sys.byteorder, signed=True)
+
+
+def to_uint32(bytes: bytearray, offset: int) -> int:
+    return int.from_bytes(bytes[offset : offset + 4], byteorder=sys.byteorder, signed=False)
+
+
+def to_int64(bytes: bytes, offset: int) -> int:
+    return int.from_bytes(bytes[offset : offset + 8], byteorder=sys.byteorder, signed=True)
+
+
+def to_uint64(bytes: bytearray, offset: int) -> int:
+    return int.from_bytes(bytes[offset : offset + 8], byteorder=sys.byteorder, signed=False)
+
+
+def to_single(bytes: bytearray, offset: int) -> float:
+    [number] = struct.unpack("f", bytes[offset : offset + 4])
+    return number
+
+
+def to_double(bytes: bytearray, offset: int) -> float:
+    [number] = struct.unpack("d", bytes[offset : offset + 8])
+    return number
+
+
+def to_string(bytes: bytearray, offset: int = 0, count: int | None = None) -> str:
+    count = len(bytes) if count is None else count
+    return "-".join([f"{x:02x}" for x in bytes[offset : offset + count]])
+
+
+def is_little_endian() -> bool:
+    return sys.byteorder == "little"
+
+
+__all__ = [
+    "get_bytes_char",
+    "get_bytes_int16",
+    "get_bytes_uint16",
+    "get_bytes_int32",
+    "get_bytes_uint32",
+    "get_bytes_int64",
+    "get_bytes_uint64",
+    "get_bytes_boolean",
+    "get_bytes_single",
+    "get_bytes_double",
+    "int64bits_to_double",
+    "double_to_int64bits",
+    "to_boolean",
+    "to_char",
+    "to_int16",
+    "to_uint16",
+    "to_int32",
+    "to_uint64",
+    "to_single",
+    "to_double",
+    "to_string",
+    "is_little_endian",
+]

arctrl/py/fable_modules/fable_library/boolean.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+from .types import FSharpRef
+
+
+def try_parse(string: str, defValue: FSharpRef[bool]) -> bool:
+    string = string.strip().capitalize()
+    if string == "True":
+        defValue.contents = True
+        return True
+    elif string == "False":
+        defValue.contents = False
+        return True
+
+    return False
+
+
+def parse(value: Any) -> bool:
+    def_value: FSharpRef[bool] = FSharpRef(False)
+    if try_parse(value, def_value):
+        return def_value.contents
+
+    raise ValueError(f"String '{value}' was not recognized as a valid Boolean.")
+
+
+__all__ = ["parse", "try_parse"]

arctrl/py/fable_modules/fable_library/char.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import unicodedata
+from enum import IntEnum
+
+
+class UnicodeCategory(IntEnum):
+    """Defines the Unicode category of a character.
+
+    https://docs.microsoft.com/en-us/dotnet/api/system.globalization.unicodecategory?view=net-6.0
+    """
+
+    UppercaseLetter = 0
+    LowercaseLetter = 1
+    TitlecaseLetter = 2
+    ModifierLetter = 3
+    OtherLetter = 4
+    NonSpacingMark = 5
+    SpacingCombiningMark = 6
+    EnclosingMark = 7
+    DecimalDigitNumber = 8
+    LetterNumber = 9
+    OtherNumber = 10
+    SpaceSeparator = 11
+    LineSeparator = 12
+    ParagraphSeparator = 13
+    Control = 14
+    Format = 15
+    Surrogate = 16
+    PrivateUse = 17
+    ConnectorPunctuation = 18
+    DashPunctuation = 19
+    OpenPunctuation = 20
+    ClosePunctuation = 21
+    InitialQuotePunctuation = 22
+    FinalQuotePunctuation = 23
+    OtherPunctuation = 24
+    MathSymbol = 25
+    CurrencySymbol = 26
+    ModifierSymbol = 27
+    OtherSymbol = 28
+    OtherNotAssigned = 29
+
+
+unicode_category_2_python: dict[str, UnicodeCategory] = {
+    "Ll": UnicodeCategory.LowercaseLetter,
+    "Lu": UnicodeCategory.UppercaseLetter,
+    "Nd": UnicodeCategory.DecimalDigitNumber,
+    "Cc": UnicodeCategory.Control,
+    "Pd": UnicodeCategory.DashPunctuation,
+    "Sc": UnicodeCategory.CurrencySymbol,
+    "Pc": UnicodeCategory.ConnectorPunctuation,
+    "Cf": UnicodeCategory.Format,
+    "Pi": UnicodeCategory.InitialQuotePunctuation,
+    "Po": UnicodeCategory.OtherPunctuation,
+    "Nl": UnicodeCategory.LetterNumber,
+    "Zl": UnicodeCategory.LineSeparator,
+    "Zs": UnicodeCategory.SpaceSeparator,
+    "Sm": UnicodeCategory.MathSymbol,
+    "Sk": UnicodeCategory.ModifierSymbol,
+    "Mn": UnicodeCategory.NonSpacingMark,
+    "Lo": UnicodeCategory.OtherLetter,
+    "No": UnicodeCategory.OtherLetter,
+}
+
+
+def char_code_at(s: str, index: int) -> int:
+    if index >= 0 and index < len(s):
+        return ord(s[index : index + 1])
+    else:
+        raise ValueError("Index out of range.")
+
+
+def get_unicode_category(s: str, index: int = 0) -> UnicodeCategory:
+    category = unicodedata.category(s[index : index + 1])
+    ret = unicode_category_2_python.get(category)
+    if ret is not None:
+        return ret
+    raise ValueError(f"Fable error, unknown Unicode category: {category}")
+
+
+IS_LETTER_MASK = (
+    0
+    | 1 << UnicodeCategory.UppercaseLetter
+    | 1 << UnicodeCategory.LowercaseLetter
+    | 1 << UnicodeCategory.TitlecaseLetter
+    | 1 << UnicodeCategory.ModifierLetter
+    | 1 << UnicodeCategory.OtherLetter
+)
+IS_PUNCTUATION_MASK = (
+    0
+    | 1 << UnicodeCategory.ConnectorPunctuation
+    | 1 << UnicodeCategory.DashPunctuation
+    | 1 << UnicodeCategory.OpenPunctuation
+    | 1 << UnicodeCategory.ClosePunctuation
+    | 1 << UnicodeCategory.InitialQuotePunctuation
+    | 1 << UnicodeCategory.FinalQuotePunctuation
+    | 1 << UnicodeCategory.OtherPunctuation
+)
+
+IS_SEPARATOR_MASK = (
+    0
+    | 1 << UnicodeCategory.SpaceSeparator
+    | 1 << UnicodeCategory.LineSeparator
+    | 1 << UnicodeCategory.ParagraphSeparator
+)
+IS_NUMBER_MASK = (
+    0 | 1 << UnicodeCategory.DecimalDigitNumber | 1 << UnicodeCategory.LetterNumber | 1 << UnicodeCategory.OtherNumber
+)
+IS_SYMBOL_MASK = (
+    0
+    | 1 << UnicodeCategory.MathSymbol
+    | 1 << UnicodeCategory.CurrencySymbol
+    | 1 << UnicodeCategory.ModifierSymbol
+    | 1 << UnicodeCategory.OtherSymbol
+)
+IS_WHITESPACE_MASK = (
+    0
+    | 1 << UnicodeCategory.SpaceSeparator
+    | 1 << UnicodeCategory.LineSeparator
+    | 1 << UnicodeCategory.ParagraphSeparator
+)
+
+IS_DIGIT_MASK = 1 << UnicodeCategory.DecimalDigitNumber
+IS_CONTROL_MASK = 1 << UnicodeCategory.Control
+IS_LETTER_OR_DIGIT_MASK = IS_LETTER_MASK | IS_DIGIT_MASK
+IS_UPPER_MASK = 1 << UnicodeCategory.UppercaseLetter
+IS_LOWER_MASK = 1 << UnicodeCategory.LowercaseLetter
+
+
+def is_digit(s: str, index: int = 0) -> bool:
+    return s[index : index + 1].isdigit()
+
+
+def is_letter(s: str, index: int = 0) -> bool:
+    return s[index : index + 1].isalpha()
+
+
+def is_letter_or_digit(s: str, index: int = 0) -> bool:
+    test = 1 << get_unicode_category(s, index)
+    return bool(test & IS_LETTER_OR_DIGIT_MASK)
+
+
+def is_control(s: str, index: int = 0):
+    test = 1 << get_unicode_category(s, index)
+    return bool(test & IS_CONTROL_MASK)
+
+
+def is_upper(s: str, index: int = 0) -> bool:
+    test = 1 << get_unicode_category(s, index)
+    return bool(test & IS_UPPER_MASK)
+
+
+def is_lower(s: str, index: int = 0) -> bool:
+    test = 1 << get_unicode_category(s, index)
+    return bool(test & IS_LOWER_MASK)
+
+
+def is_punctuation(s: str, index: int = 0) -> bool:
+    test = 1 << get_unicode_category(s, index)
+    return bool(test & IS_PUNCTUATION_MASK)
+
+
+def is_separator(s: str, index: int = 0) -> bool:
+    test = 1 << get_unicode_category(s, index)
+    return bool(test & IS_SEPARATOR_MASK)
+
+
+def is_number(s: str, index: int = 0) -> bool:
+    test = 1 << get_unicode_category(s, index)
+    return bool(test & IS_NUMBER_MASK)
+
+
+def is_symbol(s: str, index: int = 0) -> bool:
+    test = 1 << get_unicode_category(s, index)
+    return bool(test & IS_SYMBOL_MASK)
+
+
+def is_white_space(s: str, index: int = 0) -> bool:
+    test = 1 << get_unicode_category(s, index)
+    if test & IS_WHITESPACE_MASK:
+        return True
+
+    cp = char_code_at(s, index)
+    return (0x09 <= cp <= 0x0D) or cp == 0x85 or cp == 0xA0
+
+
+def is_high_surrogate(s: str, index: int = 0) -> bool:
+    cp = char_code_at(s, index)
+    return 0xD800 <= cp <= 0xDBFF
+
+
+def is_low_surrogate(s: str, index: int = 0) -> bool:
+    cp = char_code_at(s, index)
+    return 0xDC00 <= cp <= 0xDFFF
+
+
+def is_surrogate(s: str, index: int = 0) -> bool:
+    cp = char_code_at(s, index)
+    return 0xD800 <= cp <= 0xDFFF
+
+
+def is_surrogate_pair(s: str, index: str | int) -> bool:
+    if isinstance(index, int):
+        return is_high_surrogate(s, index) and is_low_surrogate(s, index + 1)
+
+    return is_high_surrogate(s) and is_low_surrogate(index)
+
+
+def parse(input: str) -> str:
+    if len(input) == 1:
+        return input[0]
+    else:
+        raise ValueError("String must be exactly one character long.")
+
+
+__all__ = [
+    "char_code_at",
+    "get_unicode_category",
+    "is_control",
+    "is_letter_or_digit",
+    "is_letter",
+    "is_digit",
+    "is_upper",
+    "is_lower",
+    "is_separator",
+    "is_punctuation",
+    "is_number",
+    "is_symbol",
+    "is_separator",
+    "is_white_space",
+    "is_surrogate",
+    "is_low_surrogate",
+    "is_high_surrogate",
+    "is_surrogate_pair",
+    "parse",
+]

arctrl/py/fable_modules/fable_library/choice.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+from typing import Any, Generic, TypeVar
+
+from .option import some
+from .reflection import TypeInfo, union_type
+from .types import Array, Union
+
+
+_T1 = TypeVar("_T1")
+
+_T2 = TypeVar("_T2")
+
+_T3 = TypeVar("_T3")
+
+_T4 = TypeVar("_T4")
+
+_T5 = TypeVar("_T5")
+
+_T6 = TypeVar("_T6")
+
+_T7 = TypeVar("_T7")
+
+
+def _expr35(gen0: TypeInfo, gen1: TypeInfo) -> TypeInfo:
+    return union_type(
+        "FSharp.Core.FSharpChoice`2", [gen0, gen1], FSharpChoice_2, lambda: [[("Item", gen0)], [("Item", gen1)]]
+    )
+
+
+class FSharpChoice_2(Union, Generic[_T1, _T2]):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Choice1Of2", "Choice2Of2"]
+
+
+FSharpChoice_2_reflection = _expr35
+
+
+def _expr36(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo) -> TypeInfo:
+    return union_type(
+        "FSharp.Core.FSharpChoice`3",
+        [gen0, gen1, gen2],
+        FSharpChoice_3,
+        lambda: [[("Item", gen0)], [("Item", gen1)], [("Item", gen2)]],
+    )
+
+
+class FSharpChoice_3(Union, Generic[_T1, _T2, _T3]):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Choice1Of3", "Choice2Of3", "Choice3Of3"]
+
+
+FSharpChoice_3_reflection = _expr36
+
+
+def _expr37(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo, gen3: TypeInfo) -> TypeInfo:
+    return union_type(
+        "FSharp.Core.FSharpChoice`4",
+        [gen0, gen1, gen2, gen3],
+        FSharpChoice_4,
+        lambda: [[("Item", gen0)], [("Item", gen1)], [("Item", gen2)], [("Item", gen3)]],
+    )
+
+
+class FSharpChoice_4(Union, Generic[_T1, _T2, _T3, _T4]):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Choice1Of4", "Choice2Of4", "Choice3Of4", "Choice4Of4"]
+
+
+FSharpChoice_4_reflection = _expr37
+
+
+def _expr38(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo, gen3: TypeInfo, gen4: TypeInfo) -> TypeInfo:
+    return union_type(
+        "FSharp.Core.FSharpChoice`5",
+        [gen0, gen1, gen2, gen3, gen4],
+        FSharpChoice_5,
+        lambda: [[("Item", gen0)], [("Item", gen1)], [("Item", gen2)], [("Item", gen3)], [("Item", gen4)]],
+    )
+
+
+class FSharpChoice_5(Union, Generic[_T1, _T2, _T3, _T4, _T5]):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Choice1Of5", "Choice2Of5", "Choice3Of5", "Choice4Of5", "Choice5Of5"]
+
+
+FSharpChoice_5_reflection = _expr38
+
+
+def _expr39(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo, gen3: TypeInfo, gen4: TypeInfo, gen5: TypeInfo) -> TypeInfo:
+    return union_type(
+        "FSharp.Core.FSharpChoice`6",
+        [gen0, gen1, gen2, gen3, gen4, gen5],
+        FSharpChoice_6,
+        lambda: [
+            [("Item", gen0)],
+            [("Item", gen1)],
+            [("Item", gen2)],
+            [("Item", gen3)],
+            [("Item", gen4)],
+            [("Item", gen5)],
+        ],
+    )
+
+
+class FSharpChoice_6(Union, Generic[_T1, _T2, _T3, _T4, _T5, _T6]):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Choice1Of6", "Choice2Of6", "Choice3Of6", "Choice4Of6", "Choice5Of6", "Choice6Of6"]
+
+
+FSharpChoice_6_reflection = _expr39
+
+
+def _expr40(
+    gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo, gen3: TypeInfo, gen4: TypeInfo, gen5: TypeInfo, gen6: TypeInfo
+) -> TypeInfo:
+    return union_type(
+        "FSharp.Core.FSharpChoice`7",
+        [gen0, gen1, gen2, gen3, gen4, gen5, gen6],
+        FSharpChoice_7,
+        lambda: [
+            [("Item", gen0)],
+            [("Item", gen1)],
+            [("Item", gen2)],
+            [("Item", gen3)],
+            [("Item", gen4)],
+            [("Item", gen5)],
+            [("Item", gen6)],
+        ],
+    )
+
+
+class FSharpChoice_7(Union, Generic[_T1, _T2, _T3, _T4, _T5, _T6, _T7]):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Choice1Of7", "Choice2Of7", "Choice3Of7", "Choice4Of7", "Choice5Of7", "Choice6Of7", "Choice7Of7"]
+
+
+FSharpChoice_7_reflection = _expr40
+
+
+def Choice_makeChoice1Of2(x: Any | None = None) -> FSharpChoice_2[Any, Any]:
+    return FSharpChoice_2(0, x)
+
+
+def Choice_makeChoice2Of2(x: Any | None = None) -> FSharpChoice_2[Any, Any]:
+    return FSharpChoice_2(1, x)
+
+
+def Choice_tryValueIfChoice1Of2(x: FSharpChoice_2[Any, Any]) -> Any | None:
+    if x.tag == 0:
+        return some(x.fields[0])
+
+    else:
+        return None
+
+
+def Choice_tryValueIfChoice2Of2(x: FSharpChoice_2[Any, Any]) -> Any | None:
+    if x.tag == 1:
+        return some(x.fields[0])
+
+    else:
+        return None
+
+
+__all__ = [
+    "FSharpChoice_2_reflection",
+    "FSharpChoice_3_reflection",
+    "FSharpChoice_4_reflection",
+    "FSharpChoice_5_reflection",
+    "FSharpChoice_6_reflection",
+    "FSharpChoice_7_reflection",
+    "Choice_makeChoice1Of2",
+    "Choice_makeChoice2Of2",
+    "Choice_tryValueIfChoice1Of2",
+    "Choice_tryValueIfChoice2Of2",
+]