arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/fable_modules/fable_library/date_offset.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+
+from . import time_span
+from .time_span import TimeSpan
+from .types import FSharpRef
+
+
+def timedelta_total_microseconds(td: timedelta) -> int:
+    # timedelta doesn't expose total_microseconds
+    # so we need to calculate it ourselves
+    return td.days * (24 * 3600) + td.seconds * 10**6 + td.microseconds
+
+
+def add(d: datetime, ts: timedelta) -> datetime:
+    return d + ts
+
+
+def parse(string: str, detectUTC: bool = False) -> datetime:
+    from dateutil import parser
+
+    return parser.parse(string)
+
+
+def try_parse(string: str, style: int, unsigned: bool, bitsize: int, defValue: FSharpRef[datetime]) -> bool:
+    try:
+        defValue.contents = parse(string)
+        return True
+    except Exception:
+        return False
+
+
+def create(
+    year: int,
+    month: int,
+    day: int,
+    h: int,
+    m: int,
+    s: int,
+    ms: int | TimeSpan,
+    offset: TimeSpan | None = None,
+) -> datetime:
+    python_offset: timedelta | None = None
+    if isinstance(ms, TimeSpan):
+        python_offset = timedelta(microseconds=time_span.total_microseconds(ms))
+        ms = 0
+
+    if python_offset is None:
+        return datetime(year, month, day, h, m, s, ms)
+
+    tzinfo = timezone(python_offset)
+    return datetime(year, month, day, h, m, s, ms, tzinfo=tzinfo)
+
+
+def now() -> datetime:
+    return datetime.now()
+
+
+def utc_now() -> datetime:
+    return datetime.utcnow()
+
+
+def op_addition(x: datetime, y: timedelta) -> datetime:
+    return x + y
+
+
+def op_subtraction(x: datetime, y: datetime | TimeSpan) -> datetime | TimeSpan:
+    if isinstance(y, TimeSpan):
+        return x - timedelta(microseconds=time_span.total_microseconds(y))
+
+    return time_span.create(0, 0, 0, 0, 0, timedelta_total_microseconds(x - y))
+
+
+def min_value() -> datetime:
+    return datetime.min
+
+
+__all__ = ["now", "op_addition", "op_subtraction", "parse", "try_parse", "utc_now"]

arctrl/py/fable_modules/fable_library/decimal_.py

@@ -0,0 +1,190 @@
+from decimal import MAX_EMAX, MIN_EMIN, Decimal, getcontext
+
+from .types import FSharpRef
+
+
+getcontext().prec = 29
+
+get_zero = Decimal(0)
+get_one = Decimal(1)
+
+get_minus_one = Decimal(-1)
+get_max_value = MAX_EMAX
+get_min_value = MIN_EMIN
+
+
+def compare(x: Decimal, y: Decimal) -> int:
+    return -1 if x < y else 1 if x > y else 0
+
+
+def equals(a: Decimal, b: Decimal) -> bool:
+    return a == b
+
+
+def abs(x: Decimal) -> Decimal:
+    return -x if x < 0 else x
+
+
+def sign(x: Decimal) -> int:
+    return -1 if x < 0 else 1 if x > 0 else 0
+
+
+def max(x: Decimal, y: Decimal) -> Decimal:
+    return x if x > y else y
+
+
+def min(x: Decimal, y: Decimal) -> Decimal:
+    return x if x < y else y
+
+
+def add(a: Decimal, b: Decimal) -> Decimal:
+    return a + b
+
+
+def subtract(a: Decimal, b: Decimal) -> Decimal:
+    return a - b
+
+
+def multiply(a: Decimal, b: Decimal) -> Decimal:
+    return a * b
+
+
+def divide(a: Decimal, b: Decimal) -> Decimal:
+    return a / b
+
+
+def remainder(a: Decimal, b: Decimal) -> Decimal:
+    return a % b
+
+
+def negate(a: Decimal) -> Decimal:
+    return -a
+
+
+def op_unary_negation(a: Decimal) -> Decimal:
+    return -a
+
+
+def op_unary_plus(a: Decimal) -> Decimal:
+    return +a
+
+
+def op_addition(a: Decimal, b: Decimal) -> Decimal:
+    return a + b
+
+
+def op_subtraction(a: Decimal, b: Decimal) -> Decimal:
+    return a - b
+
+
+def op_multiply(a: Decimal, b: Decimal) -> Decimal:
+    return a * b
+
+
+def op_division(a: Decimal, b: Decimal) -> Decimal:
+    return a / b
+
+
+def op_modulus(a: Decimal, b: Decimal) -> Decimal:
+    return a % b
+
+
+def op_less_than(a: Decimal, b: Decimal) -> bool:
+    return a < b
+
+
+def op_less_than_or_equal(a: Decimal, b: Decimal) -> bool:
+    return a <= b
+
+
+def op_greater_than(a: Decimal, b: Decimal) -> bool:
+    return a > b
+
+
+def op_greater_than_or_equal(a: Decimal, b: Decimal) -> bool:
+    return a >= b
+
+
+def op_equality(a: Decimal, b: Decimal) -> bool:
+    return a == b
+
+
+def op_inequality(a: Decimal, b: Decimal) -> bool:
+    return a != b
+
+
+def from_parts(low: int, mid: int, high: int, isNegative: bool, scale: int) -> Decimal:
+    sign = -1 if isNegative else 1
+
+    if low < 0:
+        low = 0x100000000 + low
+
+    if mid < 0:
+        mid = 0xFFFFFFFF00000000 + mid + 1
+    else:
+        mid = mid << 32
+
+    if high < 0:
+        high = 0xFFFFFFFF0000000000000000 + high + 1
+    else:
+        high = high << 64
+
+    value = Decimal((low + mid + high) * sign)
+    if scale:
+        dscale = Decimal(pow(10, scale))
+        return value / dscale
+    return value
+
+
+def to_string(x: Decimal) -> str:
+    return str(x)
+
+
+def to_number(x: Decimal) -> float:
+    return float(x)
+
+
+def parse(string: str) -> Decimal:
+    return Decimal(string)
+
+
+def try_parse(string: str, def_value: FSharpRef[Decimal]) -> bool:
+    try:
+        def_value.contents = parse(string)
+        return True
+    except Exception:
+        return False
+
+
+__all__ = [
+    "compare",
+    "equals",
+    "abs",
+    "sign",
+    "max",
+    "min",
+    "add",
+    "subtract",
+    "multiply",
+    "divide",
+    "remainder",
+    "negate",
+    "op_unary_negation",
+    "op_unary_plus",
+    "op_addition",
+    "op_subtraction",
+    "op_multiply",
+    "op_division",
+    "op_modulus",
+    "op_less_than",
+    "op_less_than_or_equal",
+    "op_greater_than",
+    "op_greater_than_or_equal",
+    "op_equality",
+    "op_inequality",
+    "from_parts",
+    "to_string",
+    "to_number",
+    "try_parse",
+    "parse",
+]

arctrl/py/fable_modules/fable_library/diagnostics.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import time
+
+
+class TimerError(Exception):
+    """A custom exception used to report errors in use of Timer class"""
+
+
+class StopWatch:
+    def __init__(self) -> None:
+        self._start_time: float | None = None
+        self._elapsed_time: float | None = None
+
+    def is_running(self) -> bool:
+        """Return True if timer is running"""
+        return self._start_time is not None
+
+    def start(self) -> None:
+        """Start a new timer"""
+        if self._start_time is not None:
+            raise TimerError("Timer is running. Use .stop() to stop it")
+
+        self._start_time = time.perf_counter()
+
+    def stop(self) -> None:
+        """Stop the timer, and report the elapsed time"""
+        if self._start_time is None:
+            raise TimerError("Timer is not running. Use .start() to start it")
+
+        self._elapsed_time = time.perf_counter() - self._start_time
+        self._start_time = None
+
+    def elapsed_milliseconds(self) -> int:
+        """Return the elapsed time in milliseconds"""
+        if self._elapsed_time is None:
+            raise TimerError("Timer is not running. Use .start() to start it")
+
+        return int(self._elapsed_time * 1000)
+
+    def elapsed_ticks(self) -> int:
+        """Return the elapsed time in ticks"""
+        if self._elapsed_time is None:
+            raise TimerError("Timer is not running. Use .start() to start it")
+
+        return int(self._elapsed_time * 10000000)
+
+
+def frequency() -> int:
+    return 1000000000
+
+
+def get_timestamp() -> int:
+    return time.perf_counter_ns()

arctrl/py/fable_modules/fable_library/double.py

@@ -0,0 +1,87 @@
+import math
+from math import copysign
+from typing import Any
+
+from .types import FSharpRef
+
+
+def abs(x: float) -> float:
+    return -x if x < 0 else x
+
+
+def sign(x: float) -> float:
+    return -1 if x < 0 else 1 if x > 0 else 0
+
+
+def max(x: float, y: float) -> float:
+    return x if x > y else y
+
+
+def min(x: float, y: float) -> float:
+    return x if x < y else y
+
+
+def divide(x: float, y: float) -> float:
+    """Divide two numbers.
+
+    Returns nan if y is 0.
+    """
+    if y == 0:
+        if x == 0:
+            return float("nan")
+        return float("inf") if copysign(1, x) == copysign(1, y) else float("-inf")
+
+    return x / y
+
+
+def log(x: float) -> float:
+    if x == 0:
+        return float("-inf")
+    elif x < 0:
+        return float("nan")
+    return math.log(x)
+
+
+def sqrt(x: float) -> float:
+    try:
+        return math.sqrt(x)
+    except ValueError:
+        return float("nan")
+
+
+def is_positive_inf(value: float) -> bool:
+    return math.isinf(value) and value > 0
+
+
+def is_negative_inf(value: float) -> bool:
+    return math.isinf(value) and value < 0
+
+
+def parse(value: Any) -> float:
+    try:
+        return float(value)
+    except Exception:
+        raise ValueError(f"The input string {value} was not in a correct format.")
+
+
+def try_parse(string: str, def_value: FSharpRef[float]) -> bool:
+    try:
+        def_value.contents = parse(string)
+        return True
+    except Exception:
+        return False
+
+
+__all__ = [
+    "abs",
+    "sign",
+    "max",
+    "min",
+    "parse",
+    "try_parse",
+    "divide",
+    "log",
+    "sqrt",
+    "is_negative_inf",
+    "is_positive_inf",
+]

arctrl/py/fable_modules/fable_library/encoding.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+
+class UTF16LE:
+    def get_bytes(self, string: str, index: int | None = None, count: int | None = None) -> bytes:
+        return string.encode("utf-16le")
+
+    def get_string(self, bytes: bytes, index: int | None = None, count: int | None = None) -> str:
+        if index is None:
+            return bytes.decode("utf-8")
+        else:
+            return bytes.decode("utf-8")[index:count]
+
+
+class UTF8:
+    def get_bytes(self, string: str, index: int | None = None, count: int | None = None) -> bytes:
+        if index is None:
+            return string.encode("utf-8")
+        else:
+            return string.encode("utf-8")[index:count]
+
+    def get_string(self, bytes: bytes, index: int | None = None, count: int | None = None) -> str:
+        if index is None:
+            return bytes.decode("utf-8")
+        else:
+            return bytes.decode("utf-8")[index:count]
+
+
+_UTF8 = UTF8()
+_UTF16 = UTF16LE()
+
+
+def get_unicode():
+    return _UTF16
+
+
+def get_utf8() -> UTF8:
+    return _UTF8
+
+
+__all__ = ["UTF8", "UTF16LE", "get_utf8", "get_unicode"]

arctrl/py/fable_modules/fable_library/event.py

@@ -0,0 +1,206 @@
+import inspect
+from abc import abstractmethod
+from collections.abc import Callable
+from typing import (
+    Any,
+    Generic,
+    Protocol,
+    TypeVar,
+    overload,
+)
+
+from .choice import (
+    Choice_tryValueIfChoice1Of2,
+    Choice_tryValueIfChoice2Of2,
+    FSharpChoice_2,
+)
+from .observable import IObservable, IObserver, Observer
+from .option import some, value
+from .util import IDisposable
+
+
+_T = TypeVar("_T")
+_U = TypeVar("_U")
+_V = TypeVar("_V")
+_Args = TypeVar("_Args", covariant=True)
+_Delegate = TypeVar("_Delegate", covariant=True)
+_T_co = TypeVar("_T_co", covariant=True)
+
+Delegate = Callable[[_T], None]
+DotNetDelegate = Callable[[Any, _T], None]
+EventDelegate = Delegate[_T] | DotNetDelegate[_T]
+
+
+class IDelegateEvent(Generic[_T_co], Protocol):
+    @abstractmethod
+    def AddHandler(self, d: DotNetDelegate[_T]) -> None: ...
+
+    @abstractmethod
+    def RemoveHandler(self, d: DotNetDelegate[_T]) -> None: ...
+
+
+class IEvent_2(IObservable[_Args], IDelegateEvent[_Delegate], Protocol): ...
+
+
+IEvent = IEvent_2[_T, _T]
+
+
+class Event(IEvent[_T]):
+    def __init__(self) -> None:
+        self.delegates: list[EventDelegate[_T]] = []
+
+    def Add(self, f: Delegate[_T]) -> None:
+        self._addHandler(f)
+
+    @property
+    def Publish(self) -> IEvent[_T]:
+        return self
+
+    @overload
+    def Trigger(self, value: _T) -> None: ...
+
+    @overload
+    def Trigger(self, sender: Any, value: _T) -> None: ...
+
+    def Trigger(self, sender_or_value: Any, value_or_undefined: _T | None = None) -> None:
+        if value_or_undefined is None:
+            value = sender_or_value
+            sender = None
+        else:
+            sender = sender_or_value
+            value = value_or_undefined
+
+        for f in self.delegates:
+            if len(inspect.signature(f).parameters) == 1:
+                f(value)
+            else:
+                f(sender, value)
+
+    # IDelegateEvent<T> methods
+
+    def AddHandler(self, handler: DotNetDelegate[_T]) -> None:
+        self._addHandler(handler)
+
+    def RemoveHandler(self, handler: DotNetDelegate[_T]) -> None:
+        self._removeHandler(handler)
+
+    # IObservable<T> methods
+
+    def Subscribe(self, __obs: IObserver[_T] | Delegate[_T]) -> IDisposable:
+        if callable(__obs):
+            callback = __obs
+        else:
+            callback = __obs.OnNext
+
+        self._addHandler(callback)
+
+        def dispose() -> None:
+            self._removeHandler(callback)
+
+        return IDisposable.create(dispose)
+
+    def _addHandler(self, f: Delegate[_T]) -> None:
+        self.delegates.append(f)
+
+    def _removeHandler(self, f: EventDelegate[_T]) -> None:
+        if f in self.delegates:
+            self.delegates.remove(f)
+
+
+def add(callback: Delegate[_T], source_event: IEvent[_T]) -> None:
+    if isinstance(source_event, Event):
+        source_event.Add(callback)
+    else:
+        source_event.Subscribe(Observer(callback))
+
+
+def choose(chooser: Callable[[_T], _U | None], source_event: IEvent[_T]) -> IEvent[_U]:
+    ev = Event[_U]()
+
+    def callback(t):
+        u = chooser(t)
+        if u is not None:
+            ev.Trigger(value(u))
+
+    add(callback, source_event)
+    return ev
+
+
+def filter(predicate: Callable[[_T], bool], source_event: IEvent[_T]) -> IEvent[_T]:
+    return choose(lambda t: some(t) if predicate(t) else None, source_event)
+
+
+def map(mapping: Callable[[_T], _U], source_event: IEvent[_T]) -> IEvent[_U]:
+    return choose(lambda t: mapping(t), source_event)
+
+
+def merge(event1: IEvent[_T], event2: IEvent[_T]) -> IEvent[_T]:
+    ev = Event[_T]()
+
+    def fn(t):
+        ev.Trigger(t)
+
+    add(fn, event1)
+    add(fn, event2)
+    return ev
+
+
+def pairwise(source_event: IEvent[_T]) -> IEvent[list[_T]]:
+    ev = Event[list[_T]]()
+    last = None
+
+    def fn(next):
+        nonlocal last
+        if last is not None:
+            ev.Trigger([last, next])
+        last = next
+
+    add(fn, source_event)
+    return ev
+
+
+def partition(predicate: Callable[[_T], bool], source_event: IEvent[_T]) -> list[IEvent[_T]]:
+    return [
+        filter(predicate, source_event),
+        filter(lambda x: not predicate(x), source_event),
+    ]
+
+
+def scan(
+    collector: Callable[[_U, _T], _U],
+    state: _U,
+    source_event: IEvent[_T],
+) -> IEvent[_U]:
+    return map(lambda t: collector(state, t), source_event)
+
+
+def split(splitter: Callable[[_T], FSharpChoice_2[_U, _V]], source_event: IEvent[_T]) -> list[IEvent[_U | _V]]:
+    return [
+        choose(lambda t: Choice_tryValueIfChoice1Of2(splitter(t)), source_event),
+        choose(lambda t: Choice_tryValueIfChoice2Of2(splitter(t)), source_event),
+    ]
+
+
+def create_event(
+    add_handler: Callable[[DotNetDelegate[_T]], None],
+    remove_handler: Callable[[DotNetDelegate[_T]], None],
+) -> IEvent[_T]:
+    class AnonymousEvent(IEvent[_U]):
+        def AddHandler(self, handler: DotNetDelegate[_T]) -> None:
+            add_handler(handler)
+
+        def RemoveHandler(self, handler: DotNetDelegate[_T]) -> None:
+            remove_handler(handler)
+
+        def Subscribe(self, observer: IObserver[_T]) -> IDisposable:
+            def h(sender, value):
+                observer.OnNext(value)
+
+            add_handler(h)
+
+            def dispose() -> None:
+                remove_handler(h)
+
+            return IDisposable.create(dispose)
+
+    return AnonymousEvent[_T]()