arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/fable_modules/fable_library/long.py

@@ -0,0 +1,240 @@
+from typing import Any
+
+from .types import FSharpRef
+
+
+def compare(x: int, y: int) -> int:
+    return -1 if x < y else 1 if x > y else 0
+
+
+def equals(a: int, b: int) -> bool:
+    return a == b
+
+
+def abs(x: int) -> int:
+    return -x if x < 0 else x
+
+
+def sign(x: int) -> int:
+    return -1 if x < 0 else 1 if x > 0 else 0
+
+
+def max(x: int, y: int) -> int:
+    return x if x > y else y
+
+
+def min(x: int, y: int) -> int:
+    return x if x < y else y
+
+
+def op_unary_negation(value: int) -> int:
+    # Note that we cannot negate the smallest negative number
+    return -value if value != -0x8000000000000000 else -0x8000000000000000
+
+
+# def op_unary_negation(a: int) -> int: return -a
+def op_unary_plus(a: int) -> int:
+    return +a
+
+
+def op_logical_not(a: int) -> int:
+    return ~a
+
+
+def op_addition(a: int, b: int) -> int:
+    return a + b
+
+
+def op_subtraction(a: int, b: int) -> int:
+    return a - b
+
+
+def op_multiply(a: int, b: int) -> int:
+    return a * b
+
+
+def op_division(a: int, b: int) -> int:
+    return a // b
+
+
+def op_modulus(a: int, b: int) -> int:
+    return a % b
+
+
+def op_right_shift(a: int, b: int) -> int:
+    return a >> b
+
+
+def op_left_shift(a: int, b: int) -> int:
+    return a << b
+
+
+def op_bitwise_and(a: int, b: int) -> int:
+    return a & b
+
+
+def op_bitwise_or(a: int, b: int) -> int:
+    return a | b
+
+
+def op_exclusive_or(a: int, b: int) -> int:
+    return a ^ b
+
+
+def op_less_than(a: int, b: int) -> bool:
+    return a < b
+
+
+def op_less_than_or_equal(a: int, b: int) -> bool:
+    return a <= b
+
+
+def op_greater_than(a: int, b: int) -> bool:
+    return a > b
+
+
+def op_greater_than_or_equal(a: int, b: int) -> bool:
+    return a >= b
+
+
+def op_equality(a: int, b: int) -> bool:
+    return a == b
+
+
+def op_inequality(a: int, b: int) -> bool:
+    return a != b
+
+
+def from_bits(lowBits: int, highBits: int, unsigned: bool) -> int:
+    ret = lowBits + (highBits << 32)
+    if not unsigned and ret > 0x7FFFFFFFFFFFFFFF:
+        return ret - 0x10000000000000000
+
+    return ret
+
+
+def from_int(value: int, unsigned: bool = False) -> int:
+    if unsigned and value < 0:
+        return value + 0x10000000000000000
+    return value
+
+
+def from_value(value: Any, unsigned: bool = False) -> int:
+    value = int(value)
+    if unsigned and value < 0:
+        return value + 0x10000000000000000
+    elif not unsigned and value > 9223372036854775807:
+        return value - 0x10000000000000000
+
+    return value
+
+
+def from_number(value: int, unsigned: bool) -> int:
+    return int(value)
+
+
+def to_number(value: int) -> float:
+    return float(value)
+
+
+def from_integer(value: int, unsigned: bool | None = None, kind: int | None = None) -> int:
+    if unsigned and value < 0:
+        return value + 0x10000000000000000
+    elif not unsigned and value > 9223372036854775807:
+        return value - 0x10000000000000000
+    return value
+
+
+def get_range(unsigned: bool) -> tuple[int, int]:
+    return (0, 18446744073709551615) if unsigned else (-9223372036854775808, 9223372036854775807)
+
+
+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)
+    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)
+    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 to_string(x: int) -> str:
+    return str(x)
+
+
+def to_int(value: int) -> int:
+    if value > 9223372036854775807:
+        return value - 0x10000000000000000
+    return value
+
+
+long = int
+
+__all__ = [
+    "compare",
+    "equals",
+    "abs",
+    "sign",
+    "max",
+    "min",
+    "op_unary_negation",
+    "op_unary_plus",
+    "op_logical_not",
+    "op_addition",
+    "op_subtraction",
+    "op_multiply",
+    "op_division",
+    "op_modulus",
+    "op_right_shift",
+    "op_left_shift",
+    "op_bitwise_and",
+    "op_bitwise_or",
+    "op_exclusive_or",
+    "op_less_than",
+    "op_less_than_or_equal",
+    "op_greater_than",
+    "op_greater_than_or_equal",
+    "op_equality",
+    "op_inequality",
+    "from_bits",
+    "from_int",
+    "from_value",
+    "from_number",
+    "to_number",
+    "from_integer",
+    "get_range",
+    "parse",
+    "try_parse",
+    "to_string",
+    "to_int",
+    "long",
+]

arctrl/py/fable_modules/fable_library/mailbox_processor.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from queue import SimpleQueue
+from threading import RLock
+from typing import Any, Generic, TypeVar
+
+from .async_ import from_continuations, start_immediate
+from .async_builder import (
+    Async,
+    CancellationToken,
+    Continuations,
+    OperationCanceledError,
+)
+
+
+_Msg = TypeVar("_Msg")
+_Reply = TypeVar("_Reply")
+
+
+class AsyncReplyChannel(Generic[_Reply]):
+    def __init__(self, fn: Callable[[Any], None]) -> None:
+        self.fn = fn
+
+    def reply(self, r: Any) -> None:
+        self.fn(r)
+
+
+class MailboxProcessor(Generic[_Msg]):
+    def __init__(
+        self,
+        body: Callable[[MailboxProcessor[_Msg]], Async[None]],
+        cancellation_token: CancellationToken | None = None,
+    ):
+        self.messages: SimpleQueue[_Msg] = SimpleQueue()
+        self.token = cancellation_token or CancellationToken()
+        self.lock = RLock()
+        self.body = body
+
+        # Holds the continuation i.e the `done` callback of Async.from_continuations returned by `receive`.
+        self.continuation: Continuations[Any] | None = None
+
+    def post(self, msg: _Msg) -> None:
+        """Post a message synchronously to the mailbox processor.
+
+        This method is not asynchronous since it's very fast to execute.
+        It simply adds the message to the message queue of the mailbox
+        processor and returns.
+
+        Args:
+            msg: Message to post.
+
+        Returns:
+            None
+        """
+        self.messages.put(msg)
+        self.__process_events()
+
+    def post_and_async_reply(self, build_message: Callable[[AsyncReplyChannel[_Reply]], _Msg]) -> Async[_Reply]:
+        """Post a message asynchronously to the mailbox processor and
+        wait for the reply.
+
+        Args:
+            build_message: A function that takes a reply channel
+            (`AsyncReplyChannel[Reply]`) and returns a message to send
+            to the mailbox processor. The message should contain the
+            reply channel as e.g a tuple.
+
+        Returns:
+            The reply from mailbox processor.
+        """
+
+        result: _Reply | None = None
+        continuation: Continuations[Any] | None = (
+            None  # This is the continuation for the `done` callback of the awaiting poster.
+        )
+
+        def check_completion() -> None:
+            if result is not None and continuation is not None:
+                continuation[0](result)
+
+        def reply_callback(res: _Reply):
+            nonlocal result
+            result = res
+            check_completion()
+
+        reply_channel: AsyncReplyChannel[_Reply] = AsyncReplyChannel(reply_callback)
+        self.messages.put(build_message(reply_channel))
+        self.__process_events()
+
+        def callback(conts: Continuations[Any]) -> None:
+            nonlocal continuation
+            continuation = conts
+            check_completion()
+
+        return from_continuations(callback)
+
+    def receive(self) -> Async[_Msg]:
+        """Receive message from mailbox.
+
+        Returns:
+            An asynchronous computation which will consume the
+            first message in arrival order. No thread is blocked while
+            waiting for further messages. Raises a TimeoutException if
+            the timeout is exceeded.
+        """
+
+        def callback(conts: Continuations[Any]):
+            if self.continuation:
+                raise Exception("Receive can only be called once!")
+
+            self.continuation = conts
+
+            self.__process_events()
+
+        return from_continuations(callback)
+
+    def __process_events(self) -> None:
+        if not self.continuation:
+            return
+
+        # Cancellation of async workflows is more tricky in Python than
+        # with F# so we check the cancellation token for each process.
+        if self.token.is_cancellation_requested:
+            self.continuation, cont = None, self.continuation
+            if cont:
+                cont[2](OperationCanceledError("Mailbox was cancelled"))
+            return
+
+        with self.lock:
+            if self.messages.empty():
+                return
+            msg = self.messages.get()
+            self.continuation, cont = None, self.continuation
+
+        if cont:
+            cont[0](msg)
+
+    @classmethod
+    def start(
+        cls,
+        body: Callable[[MailboxProcessor[_Msg]], Async[None]],
+        cancellation_token: CancellationToken | None = None,
+    ) -> MailboxProcessor[_Msg]:
+        mbox: MailboxProcessor[_Msg] = MailboxProcessor(body, cancellation_token)
+        start_immediate(body(mbox))
+        return mbox
+
+
+def receive(mbox: MailboxProcessor[_Msg]) -> Async[_Msg]:
+    return mbox.receive()
+
+
+def post(mbox: MailboxProcessor[_Msg], msg: _Msg):
+    return mbox.post(msg)
+
+
+def start_instance(mbox: MailboxProcessor[Any]) -> None:
+    body = mbox.body(mbox)
+    return start_immediate(body)
+
+
+def start(
+    body: Callable[[MailboxProcessor[_Msg]], Async[None]],
+    cancellationToken: CancellationToken | None = None,
+) -> MailboxProcessor[_Msg]:
+    mbox = MailboxProcessor(body, cancellationToken)
+    start_instance(mbox)
+    return mbox
+
+
+__all__ = [
+    "AsyncReplyChannel",
+    "MailboxProcessor",
+    "receive",
+    "post",
+    "start",
+    "start_instance",
+]