arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/fable_modules/fable_library/mutable_set.py

@@ -0,0 +1,279 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar
+
+from .map_util import get_item_from_dict, try_get_value
+from .option import some
+from .reflection import TypeInfo, class_type
+from .resize_array import find_index
+from .seq import concat, iterate, iterate_indexed, map
+from .types import Array, FSharpRef
+from .util import IEnumerable_1, IEnumerator, IEqualityComparer_1, dispose, get_enumerator, ignore, to_iterator
+
+
+_T = TypeVar("_T")
+
+
+def _expr22(gen0: TypeInfo) -> TypeInfo:
+    return class_type("Fable.Collections.HashSet", [gen0], HashSet)
+
+
+class HashSet(Generic[_T]):
+    def __init__(self, items: IEnumerable_1[Any], comparer: IEqualityComparer_1[Any]) -> None:
+        this: FSharpRef[HashSet[_T]] = FSharpRef(None)
+        self.comparer: IEqualityComparer_1[Any] = comparer
+        this.contents = self
+        self.hash_map: Any = dict([])
+        self.init_00409: int = 1
+        with get_enumerator(items) as enumerator:
+            while enumerator.System_Collections_IEnumerator_MoveNext():
+                item: _T = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+                ignore(HashSet__Add_2B595(this.contents, item))
+
+    @property
+    def Symbol_toStringTag(self, __unit: None = None) -> str:
+        return "HashSet"
+
+    def to_json(self, __unit: None = None) -> Any:
+        this: HashSet[_T] = self
+        return list(this)
+
+    def System_Collections_IEnumerable_GetEnumerator(self, __unit: None = None) -> IEnumerator[Any]:
+        this: HashSet[_T] = self
+        return get_enumerator(this)
+
+    def GetEnumerator(self, __unit: None = None) -> IEnumerator[_T]:
+        this: HashSet[_T] = self
+        return get_enumerator(concat(this.hash_map.values()))
+
+    def __iter__(self) -> IEnumerator[_T]:
+        return to_iterator(self.GetEnumerator())
+
+    def System_Collections_Generic_ICollection_1_Add2B595(self, item: _T | None = None) -> None:
+        this: HashSet[_T] = self
+        ignore(HashSet__Add_2B595(this, item))
+
+    def System_Collections_Generic_ICollection_1_Clear(self, __unit: None = None) -> None:
+        this: HashSet[_T] = self
+        HashSet__Clear(this)
+
+    def System_Collections_Generic_ICollection_1_Contains2B595(self, item: _T | None = None) -> bool:
+        this: HashSet[_T] = self
+        return HashSet__Contains_2B595(this, item)
+
+    def System_Collections_Generic_ICollection_1_CopyToZ3B4C077E(self, array: Array[_T], array_index: int) -> None:
+        this: HashSet[_T] = self
+
+        def action(i: int, e: _T) -> None:
+            array[array_index + i] = e
+
+        iterate_indexed(action, this)
+
+    def __len__(self, __unit: None = None) -> int:
+        this: HashSet[_T] = self
+        return HashSet__get_Count(this)
+
+    def System_Collections_Generic_ICollection_1_get_IsReadOnly(self, __unit: None = None) -> bool:
+        return False
+
+    def System_Collections_Generic_ICollection_1_Remove2B595(self, item: _T | None = None) -> bool:
+        this: HashSet[_T] = self
+        return HashSet__Remove_2B595(this, item)
+
+    @property
+    def size(self, __unit: None = None) -> int:
+        this: HashSet[_T] = self
+        return HashSet__get_Count(this)
+
+    def add(self, k: _T | None = None) -> Set_1[_T]:
+        this: HashSet[_T] = self
+        ignore(HashSet__Add_2B595(this, k))
+        return this
+
+    def clear(self, __unit: None = None) -> None:
+        this: HashSet[_T] = self
+        HashSet__Clear(this)
+
+    def __delitem__(self, k: _T | None = None) -> bool:
+        this: HashSet[_T] = self
+        return HashSet__Remove_2B595(this, k)
+
+    def __contains__(self, k: _T | None = None) -> bool:
+        this: HashSet[_T] = self
+        return HashSet__Contains_2B595(this, k)
+
+    def keys(self, __unit: None = None) -> IEnumerable_1[_T]:
+        this: HashSet[_T] = self
+
+        def mapping(x: _T | None = None) -> _T | None:
+            return x
+
+        return map(mapping, this)
+
+    def values(self, __unit: None = None) -> IEnumerable_1[_T]:
+        this: HashSet[_T] = self
+
+        def mapping(x: _T | None = None) -> _T | None:
+            return x
+
+        return map(mapping, this)
+
+    def entries(self, __unit: None = None) -> IEnumerable_1[tuple[_T, _T]]:
+        this: HashSet[_T] = self
+
+        def mapping(v: _T | None = None) -> tuple[_T, _T]:
+            return (v, v)
+
+        return map(mapping, this)
+
+    def for_each(self, f: Callable[[_T, _T, Set_1[_T]], None], this_arg: Any | None = None) -> None:
+        this: HashSet[_T] = self
+
+        def action(x: _T | None = None) -> None:
+            f(x, x, this)
+
+        iterate(action, this)
+
+
+HashSet_reflection = _expr22
+
+
+def HashSet__ctor_Z6150332D(items: IEnumerable_1[Any], comparer: IEqualityComparer_1[Any]) -> HashSet[_T]:
+    return HashSet(items, comparer)
+
+
+def HashSet__TryFindIndex_2B595(this: HashSet[Any], k: Any) -> tuple[bool, int, int]:
+    h: int = this.comparer.GetHashCode(k) or 0
+    match_value: tuple[bool, Array[_T]]
+    out_arg: Array[_T] = None
+
+    def _arrow23(__unit: None = None, this: Any = this, k: Any = k) -> Array[_T]:
+        return out_arg
+
+    def _arrow24(v: Array[_T], this: Any = this, k: Any = k) -> None:
+        nonlocal out_arg
+        out_arg = v
+
+    match_value = (try_get_value(this.hash_map, h, FSharpRef(_arrow23, _arrow24)), out_arg)
+    if match_value[0]:
+
+        def _arrow25(v_1: _T | None = None, this: Any = this, k: Any = k) -> bool:
+            return this.comparer.Equals(k, v_1)
+
+        return (True, h, find_index(_arrow25, match_value[1]))
+
+    else:
+        return (False, h, -1)
+
+
+def HashSet__TryFind_2B595(this: HashSet[Any], k: Any) -> Any | None:
+    match_value: tuple[bool, int, int] = HashSet__TryFindIndex_2B595(this, k)
+    (pattern_matching_result,) = (None,)
+    if match_value[0]:
+        if match_value[2] > -1:
+            pattern_matching_result = 0
+
+        else:
+            pattern_matching_result = 1
+
+    else:
+        pattern_matching_result = 1
+
+    if pattern_matching_result == 0:
+        return some(get_item_from_dict(this.hash_map, match_value[1])[match_value[2]])
+
+    elif pattern_matching_result == 1:
+        return None
+
+
+def HashSet__get_Comparer(this: HashSet[Any]) -> IEqualityComparer_1[Any]:
+    return this.comparer
+
+
+def HashSet__Clear(this: HashSet[Any]) -> None:
+    this.hash_map.clear()
+
+
+def HashSet__get_Count(this: HashSet[Any]) -> int:
+    count: int = 0
+    enumerator: Any = get_enumerator(this.hash_map.values())
+    try:
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            items: Array[_T] = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+            count = (count + len(items)) or 0
+
+    finally:
+        dispose(enumerator)
+
+    return count
+
+
+def HashSet__Add_2B595(this: HashSet[Any], k: Any) -> bool:
+    match_value: tuple[bool, int, int] = HashSet__TryFindIndex_2B595(this, k)
+    if match_value[0]:
+        if match_value[2] > -1:
+            return False
+
+        else:
+            value: None = get_item_from_dict(this.hash_map, match_value[1]).append(k)
+            ignore(None)
+            return True
+
+    else:
+        this.hash_map[match_value[1]] = [k]
+        return True
+
+
+def HashSet__Contains_2B595(this: HashSet[Any], k: Any) -> bool:
+    match_value: tuple[bool, int, int] = HashSet__TryFindIndex_2B595(this, k)
+    (pattern_matching_result,) = (None,)
+    if match_value[0]:
+        if match_value[2] > -1:
+            pattern_matching_result = 0
+
+        else:
+            pattern_matching_result = 1
+
+    else:
+        pattern_matching_result = 1
+
+    if pattern_matching_result == 0:
+        return True
+
+    elif pattern_matching_result == 1:
+        return False
+
+
+def HashSet__Remove_2B595(this: HashSet[Any], k: Any) -> bool:
+    match_value: tuple[bool, int, int] = HashSet__TryFindIndex_2B595(this, k)
+    (pattern_matching_result,) = (None,)
+    if match_value[0]:
+        if match_value[2] > -1:
+            pattern_matching_result = 0
+
+        else:
+            pattern_matching_result = 1
+
+    else:
+        pattern_matching_result = 1
+
+    if pattern_matching_result == 0:
+        get_item_from_dict(this.hash_map, match_value[1]).pop(match_value[2])
+        return True
+
+    elif pattern_matching_result == 1:
+        return False
+
+
+__all__ = [
+    "HashSet_reflection",
+    "HashSet__TryFindIndex_2B595",
+    "HashSet__TryFind_2B595",
+    "HashSet__get_Comparer",
+    "HashSet__Clear",
+    "HashSet__get_Count",
+    "HashSet__Add_2B595",
+    "HashSet__Contains_2B595",
+    "HashSet__Remove_2B595",
+]

arctrl/py/fable_modules/fable_library/native.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import Any, Generic, Protocol, TypeVar
+
+from .types import Array
+
+
+_T = TypeVar("_T")
+
+
+class Cons_1(Protocol, Generic[_T]):
+    @abstractmethod
+    def Allocate(self, len: int) -> Array[_T]: ...
+
+
+def Helpers_allocateArrayFromCons(cons: Cons_1[Any], len_1: int) -> Array[Any]:
+    if cons is None:
+        return (list)([None] * len_1)
+
+    else:
+        return cons([0] * len_1)
+
+
+def Helpers_fillImpl(array: Array[Any], value: Any, start: int, count: int) -> Array[Any]:
+    for i in range(0, (count - 1) + 1, 1):
+        array[i + start] = value
+    return array
+
+
+def Helpers_spliceImpl(array: Array[Any], start: int, delete_count: int) -> Array[Any]:
+    for _ in range(1, delete_count + 1, 1):
+        array.pop(start)
+    return array
+
+
+def Helpers_indexOfImpl(array: Array[Any], item: Any, start: int) -> Any:
+    try:
+        return array.index(item, start)
+
+    except Exception as ex:
+        return -1
+
+
+__all__ = ["Helpers_allocateArrayFromCons", "Helpers_fillImpl", "Helpers_spliceImpl", "Helpers_indexOfImpl"]

arctrl/py/fable_modules/fable_library/numeric.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from .types import int64
+
+
+def to_fixed(x: float, dp: int | None = None) -> str:
+    x = int(x) if int(x) == x else x
+
+    if dp is not None:
+        fmt = "{:.%sf}" % dp
+        return fmt.format(x)
+
+    return f"{x}"
+
+
+def to_precision(x: float, sd: int | None = None) -> str:
+    x = int(x) if int(x) == x else x
+
+    if sd is not None:
+        fmt = "{:.%se}" % sd
+        return fmt.format(x)
+
+    return f"{x}"
+
+
+def to_exponential(x: float, dp: int | None = None) -> str:
+    if dp is not None:
+        fmt = "{:.%se}" % dp
+        return fmt.format(x)
+
+    return f"{x}"
+
+
+def to_hex(x: int) -> str:
+    def rshift(val: int, n: int) -> int:
+        sign = 0x10000000000000000 if isinstance(val, int64) else 0x100000000
+        return val >> n if val >= 0 else (val + sign) >> n
+
+    return f"{rshift(x, 0):x}"
+
+
+def multiply(x: float, y: float) -> float:
+    return x * y
+
+
+__all__ = ["to_fixed", "to_precision", "to_exponential", "to_hex", "multiply"]

arctrl/py/fable_modules/fable_library/observable.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Callable
+from typing import Any, Generic, Protocol, TypeVar
+
+from .choice import (
+    Choice_tryValueIfChoice1Of2,  # type: ignore
+    Choice_tryValueIfChoice2Of2,  # type: ignore
+    FSharpChoice_2,  # type: ignore
+)
+from .option import value
+from .util import IDisposable
+
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_T_contra = TypeVar("_T_contra", contravariant=True)
+_U = TypeVar("_U")
+
+
+class IObserver(Protocol, Generic[_T_contra]):
+    __slots__ = ()
+
+    @abstractmethod
+    def OnNext(self, __value: _T_contra) -> None: ...
+
+    @abstractmethod
+    def OnError(self, __error: Exception) -> None: ...
+
+    @abstractmethod
+    def OnCompleted(self) -> None: ...
+
+
+def _noop(__arg: Any = None) -> None:
+    pass
+
+
+class Observer(IObserver[_T]):
+    __slots__ = "_on_error", "_on_next", "_on_completed"
+
+    def __init__(
+        self,
+        on_next: Callable[[_T], None],
+        on_error: Callable[[Exception], None] | None = None,
+        on_completed: Callable[[], None] | None = None,
+    ) -> None:
+        self._on_next = on_next
+        self._on_error = on_error or _noop
+        self._on_completed = on_completed or _noop
+
+    def OnError(self, error: Exception) -> None:
+        return self._on_error(error)
+
+    def OnNext(self, value: _T) -> None:
+        return self._on_next(value)
+
+    def OnCompleted(self) -> None:
+        return self._on_completed()
+
+
+class IObservable(Protocol, Generic[_T_co]):
+    __slots__ = ()
+
+    @abstractmethod
+    def Subscribe(self, __obs: IObserver[_T_co]) -> IDisposable: ...
+
+
+class Observable(IObservable[_T]):
+    __slots__ = "subscribe"
+
+    def __init__(self, subscribe: Callable[[IObserver[_T]], IDisposable]) -> None:
+        self.subscribe = subscribe
+
+    def Subscribe(self, obv: IObserver[_T]) -> IDisposable:
+        return self.subscribe(obv)
+
+
+def subscribe(callback: Callable[[_T], None], source: IObservable[_T]) -> IDisposable:
+    return source.Subscribe(Observer(callback))
+
+
+def add(callback: Callable[[_T], None], source: IObservable[_T]) -> IDisposable:
+    return source.Subscribe(Observer(callback))
+
+
+def protect(
+    f: Callable[[], _T],
+    succeed: Callable[[_T], None],
+    fail: Callable[[Exception], None],
+):
+    try:
+        return succeed(f())
+    except Exception as e:
+        fail(e)
+
+
+def choose(chooser: Callable[[_T], _U | None], source: IObservable[_T]) -> IObservable[_U]:
+    def subscribe(observer: IObserver[_U]):
+        def on_next(t: _T) -> None:
+            def success(u: _U | None) -> None:
+                if u is not None:
+                    observer.OnNext(value(u))
+
+            return protect(lambda: chooser(t), success, observer.OnError)
+
+        obv = Observer(on_next, observer.OnError, observer.OnCompleted)
+        return source.Subscribe(obv)
+
+    return Observable(subscribe)
+
+
+def filter(predicate: Callable[[_T], bool], source: IObservable[_T]) -> IObservable[_T]:
+    return choose(lambda x: x if predicate(x) else None, source)
+
+
+def map(mapping: Callable[[_T], _U], source: IObservable[_T]) -> IObservable[_U]:
+    def subscribe(observer: IObserver[_U]) -> IDisposable:
+        def on_next(value: _T) -> None:
+            return protect(lambda: mapping(value), observer.OnNext, observer.OnError)
+
+        obv = Observer(on_next, observer.OnError, observer.OnCompleted)
+        return source.Subscribe(obv)
+
+    return Observable(subscribe)
+
+
+def merge(source1: IObservable[_T], source2: IObservable[_T]) -> IObservable[_T]:
+    def subscribe(observer: IObserver[_T]) -> IDisposable:
+        stopped = False
+        completed1 = False
+        completed2 = False
+
+        def on_next(value: _T) -> None:
+            if stopped:
+                return
+            observer.OnNext(value)
+
+        def on_error(error: Exception) -> None:
+            nonlocal stopped
+            if stopped:
+                return
+            stopped = True
+            observer.OnError(error)
+
+        def on_completed1() -> None:
+            nonlocal completed1, stopped
+            if stopped:
+                return
+
+            completed1 = True
+            if completed2:
+                stopped = True
+                observer.OnCompleted()
+
+        obv1 = Observer(on_next, on_error, on_completed1)
+        h1 = source1.Subscribe(obv1)
+
+        def on_completed2() -> None:
+            nonlocal completed2, stopped
+            if stopped:
+                return
+
+            completed2 = True
+            if completed1:
+                stopped = True
+                observer.OnCompleted()
+
+        obv2 = Observer(on_next, on_error, on_completed2)
+        h2 = source2.Subscribe(obv2)
+
+        def dispose() -> None:
+            h1.Dispose()
+            h2.Dispose()
+
+        return IDisposable.create(dispose)
+
+    return Observable(subscribe)
+
+
+def pairwise(source: IObservable[_T]) -> IObservable[tuple[_T, _T]]:
+    def subscribe(observer: IObserver[tuple[_T, _T]]) -> IDisposable:
+        last: _T | None = None
+
+        def on_next(value: _T) -> None:
+            nonlocal last
+            if last is not None:
+                observer.OnNext((last, value))
+
+            last = value
+
+        obv = Observer(on_next, observer.OnError, observer.OnCompleted)
+        return source.Subscribe(obv)
+
+    return Observable(subscribe)
+
+
+def partition(predicate: Callable[[_T], bool], source: IObservable[_T]) -> tuple[IObservable[_T], IObservable[_T]]:
+    return (filter(predicate, source), filter(lambda x: not predicate(x), source))
+
+
+def scan(collector: Callable[[_U, _T], _U], state: _U, source: IObservable[_T]) -> IObservable[_U]:
+    def subscribe(observer: IObserver[_U]) -> IDisposable:
+        def on_next(t: _T) -> None:
+            def success(u: _U) -> None:
+                nonlocal state
+                state = u
+                observer.OnNext(u)
+
+            protect(lambda: collector(state, t), success, observer.OnError)
+
+        obv = Observer(on_next, observer.OnError, observer.OnCompleted)
+        return source.Subscribe(obv)
+
+    return Observable(subscribe)
+
+
+def split(splitter: Callable[[_T], FSharpChoice_2], source: IObservable[_T]) -> tuple[IObservable[_T], IObservable[_T]]:
+    return (
+        choose(lambda v: Choice_tryValueIfChoice1Of2(splitter(v)), source),
+        choose(lambda v: Choice_tryValueIfChoice2Of2(splitter(v)), source),
+    )