arctrl 3.0.0__py3-none-any.whl

arctrl/py/fable_modules/fable_library/file.py

@@ -0,0 +1,107 @@
+import os
+from typing import Awaitable
+
+
+def read_all_text(file_name: str) -> str:
+    with open(file_name, "r") as f:
+        return f.read()
+
+
+def read_all_text_async(file_name: str) -> Awaitable[str]:
+    async def read_all_text_async():
+        with open(file_name, "r") as f:
+            return f.read()
+
+    return read_all_text_async()
+
+
+def read_all_lines(file_name: str) -> list[str]:
+    with open(file_name, "r") as f:
+        return [line.strip("\n") for line in f.readlines()]
+
+
+def read_all_lines_async(file_name: str) -> Awaitable[list[str]]:
+    async def read_all_lines_async():
+        with open(file_name, "r") as f:
+            return [line.strip("\n") for line in f.readlines()]
+
+    return read_all_lines_async()
+
+
+def read_all_bytes(file_name: str) -> bytes:
+    with open(file_name, "rb") as f:
+        return f.read()
+
+
+def read_all_bytes_async(file_name: str) -> Awaitable[bytes]:
+    async def read_all_bytes_async():
+        with open(file_name, "rb") as f:
+            return f.read()
+
+    return read_all_bytes_async()
+
+
+def write_all_text(file_name: str, text: str) -> None:
+    with open(file_name, "w") as f:
+        f.write(text)
+
+
+def write_all_text_async(file_name: str, text: str) -> Awaitable[None]:
+    async def write_all_text_async():
+        with open(file_name, "w") as f:
+            f.write(text)
+
+    return write_all_text_async()
+
+
+def write_all_lines(file_name: str, lines: list[str]) -> None:
+    with open(file_name, "w") as f:
+        f.write("\n".join(lines))
+
+
+def write_all_lines_async(file_name: str, lines: list[str]) -> Awaitable[None]:
+    async def write_all_lines_async():
+        with open(file_name, "w") as f:
+            f.write("\n".join(lines))
+
+    return write_all_lines_async()
+
+
+def write_all_bytes(file_name: str, bytes: bytes) -> None:
+    with open(file_name, "wb") as f:
+        f.write(bytes)
+
+
+def write_all_bytes_async(file_name: str, bytes: bytes) -> Awaitable[None]:
+    async def write_all_bytes_async():
+        with open(file_name, "wb") as f:
+            f.write(bytes)
+
+    return write_all_bytes_async()
+
+
+def delete(path: str) -> None:
+    os.remove(path)
+
+
+def move(source: str, destination: str) -> None:
+    os.rename(source, destination)
+
+
+def copy(source: str, destination: str) -> None:
+    with open(source, "rb") as f:
+        data = f.read()
+    with open(destination, "wb") as f:
+        f.write(data)
+
+
+def exists(path: str) -> bool:
+    return os.path.exists(path)
+
+
+def replace(source_file_name: str, destination_file_name: str, destination_backup_file_name: str) -> None:
+    with open(destination_file_name, "rb") as f:
+        data = f.read()
+    with open(destination_backup_file_name, "wb") as f:
+        f.write(data)
+    os.replace(source_file_name, destination_file_name)

arctrl/py/fable_modules/fable_library/fsharp_collections.py

@@ -0,0 +1,52 @@
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+from .util import IComparer_1, IEqualityComparer_1, compare, equals, physical_hash, structural_hash
+
+
+_T_ = TypeVar("_T_")
+
+_T = TypeVar("_T")
+
+
+def HashIdentity_FromFunctions(hash_1: Callable[[_T], int], eq: Callable[[_T, _T], bool]) -> IEqualityComparer_1[Any]:
+    class ObjectExpr0(IEqualityComparer_1[Any]):
+        def Equals(self, x: _T_, y: _T_, hash_1: Any = hash_1, eq: Any = eq) -> bool:
+            return eq(x, y)
+
+        def GetHashCode(self, x_1: _T_ | None = None, hash_1: Any = hash_1, eq: Any = eq) -> int:
+            return hash_1(x_1)
+
+    return ObjectExpr0()
+
+
+def HashIdentity_Structural(__unit: None = None) -> IEqualityComparer_1[Any]:
+    return HashIdentity_FromFunctions(structural_hash, equals)
+
+
+def HashIdentity_Reference(__unit: None = None) -> IEqualityComparer_1[Any]:
+    def _arrow1(e: _T, e_1: _T) -> bool:
+        return e == e_1
+
+    return HashIdentity_FromFunctions(physical_hash, _arrow1)
+
+
+def ComparisonIdentity_FromFunction(comparer: Callable[[_T, _T], int]) -> IComparer_1[Any]:
+    class ObjectExpr2(IComparer_1[_T_]):
+        def Compare(self, x: _T_, y: _T_, comparer: Any = comparer) -> int:
+            return comparer(x, y)
+
+    return ObjectExpr2()
+
+
+def ComparisonIdentity_Structural(__unit: None = None) -> IComparer_1[Any]:
+    return ComparisonIdentity_FromFunction(compare)
+
+
+__all__ = [
+    "HashIdentity_FromFunctions",
+    "HashIdentity_Structural",
+    "HashIdentity_Reference",
+    "ComparisonIdentity_FromFunction",
+    "ComparisonIdentity_Structural",
+]

arctrl/py/fable_modules/fable_library/fsharp_core.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+from .fsharp_collections import ComparisonIdentity_Structural, HashIdentity_Structural
+from .system_text import StringBuilder, StringBuilder__Append_Z721C83C5
+from .util import IComparer_1, IEqualityComparer, IEqualityComparer_1, dispose, equals, ignore, structural_hash
+
+
+_T = TypeVar("_T")
+
+_R = TypeVar("_R")
+
+__B = TypeVar("__B")
+
+__A = TypeVar("__A")
+
+
+class ObjectExpr4(IEqualityComparer):
+    def System_Collections_IEqualityComparer_Equals541DA560(self, x: Any = None, y: Any = None) -> bool:
+        return equals(x, y)
+
+    def System_Collections_IEqualityComparer_GetHashCode4E60E31B(self, x_1: Any = None) -> int:
+        return structural_hash(x_1)
+
+
+LanguagePrimitives_GenericEqualityComparer: IEqualityComparer = ObjectExpr4()
+
+
+class ObjectExpr5(IEqualityComparer):
+    def System_Collections_IEqualityComparer_Equals541DA560(self, x: Any = None, y: Any = None) -> bool:
+        return equals(x, y)
+
+    def System_Collections_IEqualityComparer_GetHashCode4E60E31B(self, x_1: Any = None) -> int:
+        return structural_hash(x_1)
+
+
+LanguagePrimitives_GenericEqualityERComparer: IEqualityComparer = ObjectExpr5()
+
+
+def LanguagePrimitives_FastGenericComparer(__unit: None = None) -> IComparer_1[Any]:
+    return ComparisonIdentity_Structural()
+
+
+def LanguagePrimitives_FastGenericComparerFromTable(__unit: None = None) -> IComparer_1[Any]:
+    return ComparisonIdentity_Structural()
+
+
+def LanguagePrimitives_FastGenericEqualityComparer(__unit: None = None) -> IEqualityComparer_1[Any]:
+    return HashIdentity_Structural()
+
+
+def LanguagePrimitives_FastGenericEqualityComparerFromTable(__unit: None = None) -> IEqualityComparer_1[Any]:
+    return HashIdentity_Structural()
+
+
+def Operators_Failure(message: str) -> Exception:
+    return Exception(message)
+
+
+def Operators_FailurePattern(exn: Exception) -> str | None:
+    return str(exn)
+
+
+def Operators_NullArg(x: str) -> Any:
+    raise Exception(x)
+
+
+def Operators_Using(resource: Any, action: Callable[[_T], _R]) -> Any:
+    try:
+        return action(resource)
+
+    finally:
+        if equals(resource, None):
+            pass
+
+        else:
+            copy_of_struct: _T = resource
+            dispose(copy_of_struct)
+
+
+def Operators_Lock(_lockObj: Any, action: Callable[[], __B]) -> Any:
+    return action(None)
+
+
+def ExtraTopLevelOperators_LazyPattern(input: Any) -> Any:
+    return input.Value
+
+
+def PrintfModule_PrintFormatToStringBuilderThen(
+    continuation: Callable[[], __A], builder: StringBuilder, format: Any
+) -> Any:
+    def append(s: str, continuation: Any = continuation, builder: Any = builder, format: Any = format) -> __A:
+        ignore(StringBuilder__Append_Z721C83C5(builder, s))
+        return continuation(None)
+
+    return format.cont(append)
+
+
+def PrintfModule_PrintFormatToStringBuilder(builder: StringBuilder, format: Any) -> Any:
+    def _arrow6(__unit: None = None, builder: Any = builder, format: Any = format) -> None:
+        ignore(None)
+
+    return PrintfModule_PrintFormatToStringBuilderThen(_arrow6, builder, format)
+
+
+__all__ = [
+    "LanguagePrimitives_GenericEqualityComparer",
+    "LanguagePrimitives_GenericEqualityERComparer",
+    "LanguagePrimitives_FastGenericComparer",
+    "LanguagePrimitives_FastGenericComparerFromTable",
+    "LanguagePrimitives_FastGenericEqualityComparer",
+    "LanguagePrimitives_FastGenericEqualityComparerFromTable",
+    "Operators_Failure",
+    "Operators_FailurePattern",
+    "Operators_NullArg",
+    "Operators_Using",
+    "Operators_Lock",
+    "ExtraTopLevelOperators_LazyPattern",
+    "PrintfModule_PrintFormatToStringBuilderThen",
+    "PrintfModule_PrintFormatToStringBuilder",
+]

arctrl/py/fable_modules/fable_library/global_.py

@@ -0,0 +1,63 @@
+from abc import abstractmethod
+from typing import Any, Generic, Protocol, TypeVar
+
+
+_T = TypeVar("_T")
+
+
+class IGenericAdder_1(Protocol, Generic[_T]):
+    @abstractmethod
+    def Add(self, __arg0: _T, __arg1: _T) -> _T: ...
+
+    @abstractmethod
+    def GetZero(self) -> _T: ...
+
+
+class IGenericAverager_1(Protocol, Generic[_T]):
+    @abstractmethod
+    def Add(self, __arg0: _T, __arg1: _T) -> _T: ...
+
+    @abstractmethod
+    def DivideByInt(self, __arg0: _T, __arg1: int) -> _T: ...
+
+    @abstractmethod
+    def GetZero(self) -> _T: ...
+
+
+class Symbol_wellknown(Protocol):
+    @property
+    @abstractmethod
+    def Symbol_toStringTag(self) -> str: ...
+
+
+class IJsonSerializable(Protocol):
+    @abstractmethod
+    def to_json(self) -> Any: ...
+
+
+SR_indexOutOfBounds: str = "The index was outside the range of elements in the collection."
+
+SR_inputWasEmpty: str = "Collection was empty."
+
+SR_inputMustBeNonNegative: str = "The input must be non-negative."
+
+SR_inputSequenceEmpty: str = "The input sequence was empty."
+
+SR_inputSequenceTooLong: str = "The input sequence contains more than one element."
+
+SR_keyNotFoundAlt: str = "An index satisfying the predicate was not found in the collection."
+
+SR_differentLengths: str = "The collections had different lengths."
+
+SR_notEnoughElements: str = "The input sequence has an insufficient number of elements."
+
+__all__ = [
+    "SR_indexOutOfBounds",
+    "SR_inputWasEmpty",
+    "SR_inputMustBeNonNegative",
+    "SR_inputSequenceEmpty",
+    "SR_inputSequenceTooLong",
+    "SR_keyNotFoundAlt",
+    "SR_differentLengths",
+    "SR_notEnoughElements",
+]

arctrl/py/fable_modules/fable_library/guid.py

@@ -0,0 +1,41 @@
+import uuid
+
+from .types import FSharpRef
+
+
+def parse(string: str) -> uuid.UUID:
+    return uuid.UUID(string.strip("()"))
+
+
+def try_parse(string: str, def_value: FSharpRef[uuid.UUID]) -> bool:
+    try:
+        def_value.contents = parse(string)
+        return True
+    except Exception:
+        return False
+
+
+def to_string(guid: uuid.UUID) -> str:
+    return str(guid)
+
+
+def new_guid() -> uuid.UUID:
+    return uuid.uuid4()
+
+
+def guid_to_array(guid: uuid.UUID) -> bytearray:
+    return bytearray(guid.bytes_le)
+
+
+def array_to_guid(guid: bytearray) -> uuid.UUID:
+    return uuid.UUID(bytes_le=bytes(guid))
+
+
+__all__ = [
+    "parse",
+    "try_parse",
+    "to_string",
+    "new_guid",
+    "guid_to_array",
+    "array_to_guid",
+]

arctrl/py/fable_modules/fable_library/int32.py

@@ -0,0 +1,73 @@
+from typing import Tuple
+
+from .types import FSharpRef
+
+
+def get_range(unsigned: bool, bitsize: int) -> Tuple[int, int]:
+    if bitsize == 8:
+        return (0, 255) if unsigned else (-128, 127)
+    if bitsize == 16:
+        return (0, 65535) if unsigned else (-32768, 32767)
+    if bitsize == 32:
+        return (0, 4294967295) if unsigned else (-2147483648, 2147483647)
+    raise ValueError("Invalid bit size.")
+
+
+AllowHexSpecifier = 0x00000200
+
+
+def parse(string: str, style: int, unsigned: bool, bitsize: int, radix: int = 10) -> int:
+    # const res = isValid(str, style, radix);
+    if style & AllowHexSpecifier or string.startswith("0x"):
+        radix = 16
+    elif string.startswith("0b"):
+        radix = 2
+    elif string.startswith("0o"):
+        radix = 8
+
+    try:
+        v = int(string, base=radix)
+    except Exception:
+        raise ValueError(f"The input string {string} was not in a correct format.")
+
+    (umin, umax) = get_range(True, bitsize)
+    if not unsigned and radix != 10 and v >= umin and v <= umax:
+        mask = 1 << (bitsize - 1)
+        if v & mask:  # Test if negative
+            v = v - (mask << 1)
+
+    (min, max) = get_range(unsigned, bitsize)
+    if v >= min and v <= max:
+        return v
+
+    raise ValueError(f"The input string {string} was not in a correct format.")
+
+
+def try_parse(string: str, style: int, unsigned: bool, bitsize: int, defValue: FSharpRef[int]) -> bool:
+    try:
+        defValue.contents = parse(string, style, unsigned, bitsize)
+        return True
+    except Exception:
+        return False
+
+
+def op_unary_negation_int8(x: int) -> int:
+    return x if x == -128 else -x
+
+
+def op_unary_negation_int16(x: int) -> int:
+    return x if x == -32768 else -x
+
+
+def op_unary_negation_int32(x: int) -> int:
+    return x if x == -2147483648 else -x
+
+
+__all__ = [
+    "parse",
+    "try_parse",
+    "get_range",
+    "op_unary_negation_int8",
+    "op_unary_negation_int16",
+    "op_unary_negation_int32",
+]