arctrl 3.0.0__py3-none-any.whl

arctrl/py/fable_modules/fable_library/task.py

@@ -0,0 +1,116 @@
+"""Task handling.
+
+This module implements .NET
+[tasks](https://docs.microsoft.com/en-us/dotnet/standard/async-in-depth)
+using Python async / await.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from asyncio import AbstractEventLoop, Future
+from collections.abc import Awaitable
+from typing import Any, Generic, TypeVar
+
+
+_T = TypeVar("_T")
+
+
+class TaskCompletionSource(Generic[_T]):
+    __slots__ = "loop", "future"
+
+    def __init__(self) -> None:
+        self.loop: AbstractEventLoop = asyncio.get_event_loop()
+        self.future: Future[_T] = self.loop.create_future()
+
+    def SetResult(self, value: _T) -> None:
+        """Set result.
+
+        Transitions the underlying Task[TResult] into the
+        RanToCompletion state.
+        """
+
+        def action():
+            self.future.set_result(value)
+
+        self.loop.call_soon_threadsafe(action)
+
+    def SetCancelled(self) -> None:
+        """Set cancelled.
+
+        Transitions the underlying Task[TResult] into the Canceled
+        state.
+        """
+
+        def action():
+            self.future.cancel()
+
+        self.loop.call_soon_threadsafe(action)
+
+    def SetException(self, exception: Exception) -> None:
+        """Set exception.
+
+        Transitions the underlying Task[TResult] into the Faulted state
+        and binds it to a specified exception.
+        """
+
+        def action():
+            self.future.set_exception(exception)
+
+        self.loop.call_soon_threadsafe(action)
+
+    def get_task(self) -> Awaitable[_T]:
+        return asyncio.ensure_future(self.future)
+
+
+async def zero() -> None:
+    return
+
+
+async def from_result(value: _T) -> _T:
+    return value
+
+
+def get_awaiter(value: Awaitable[_T]) -> Awaitable[_T]:
+    # Wrap awaitable in coroutine (so we can run it using create_task)
+    async def get_value() -> _T:
+        return await asyncio.ensure_future(value)
+
+    return get_value()
+
+
+def get_result(value: Awaitable[_T]) -> _T:
+    """Get the result.
+
+    Ends the wait for the completion of the asynchronous task.
+    """
+
+    async def runner() -> _T:
+        return await value
+
+    return asyncio.run(runner())
+
+
+def start(task: Awaitable[Any]) -> None:
+    async def runner():
+        return await task
+
+    asyncio.create_task(runner())
+
+
+def run_synchronously(task: Awaitable[Any]) -> None:
+    async def runner():
+        return await task
+
+    asyncio.run(runner())
+
+
+__all__ = [
+    "get_awaiter",
+    "get_result",
+    "from_result",
+    "start",
+    "TaskCompletionSource",
+    "zero",
+    "run_synchronously",
+]

arctrl/py/fable_modules/fable_library/task_builder.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable, Iterable
+from typing import (
+    Any,
+    Protocol,
+    TypeVar,
+    overload,
+)
+
+from .task import from_result, zero
+from .util import IDisposable
+
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_TD = TypeVar("_TD", bound=IDisposable)
+_U = TypeVar("_U")
+
+
+class Delayed(Protocol[_T_co]):
+    def __call__(self, __unit: None | None = None) -> Awaitable[_T_co]: ...
+
+
+class TaskBuilder:
+    def Bind(self, computation: Awaitable[_T], binder: Callable[[_T], Awaitable[_U]]) -> Awaitable[_U]:
+        async def bind() -> _U:
+            value = await computation
+            return await binder(value)
+
+        return bind()
+
+    def Combine(self, computation1: Awaitable[None], computation2: Delayed[_T]) -> Awaitable[_T]:
+        return self.Bind(computation1, computation2)
+
+    def Delay(self, generator: Callable[[], Awaitable[_T]]) -> Delayed[_T]:
+        def deferred(_: Any = None) -> Awaitable[_T]:
+            # print("Delay: deferred: ", generator)
+            return generator()
+
+        return deferred
+
+    def For(self, sequence: Iterable[_T], body: Callable[[_T], Awaitable[_U]]) -> Awaitable[_U]:
+        done = False
+        it = iter(sequence)
+        try:
+            cur = next(it)
+        except StopIteration:
+            done = True
+
+        def delay():
+            nonlocal cur, done
+            res = body(cur)
+            try:
+                cur = next(it)
+            except StopIteration:
+                done = True
+            return res
+
+        return self.While(lambda: not done, self.Delay(delay))
+
+    @overload
+    def Return(self) -> Awaitable[None]: ...
+
+    @overload
+    def Return(self, value: _T) -> Awaitable[_T]: ...
+
+    def Return(self, value: Any = None) -> Awaitable[Any]:
+        return from_result(value)
+
+    def ReturnFrom(self, computation: Awaitable[_T]) -> Awaitable[_T]:
+        return computation
+
+    def TryFinally(self, computation: Delayed[_T], compensation: Callable[[], None]) -> Awaitable[_T]:
+        async def try_finally() -> _T:
+            try:
+                t = await computation()
+            finally:
+                compensation()
+            return t
+
+        return try_finally()
+
+    def TryWith(self, computation: Delayed[_T], catchHandler: Callable[[Any], Awaitable[_T]]) -> Awaitable[_T]:
+        async def try_with() -> _T:
+            try:
+                t = await computation()
+            except Exception as exn:
+                t = await catchHandler(exn)
+            return t
+
+        return try_with()
+
+    def Using(self, resource: _TD, binder: Callable[[_TD], Awaitable[_U]]) -> Awaitable[_U]:
+        return self.TryFinally(self.Delay(lambda: binder(resource)), lambda: resource.Dispose())
+
+    @overload
+    def While(self, guard: Callable[[], bool], computation: Delayed[None]) -> Awaitable[None]: ...
+
+    @overload
+    def While(self, guard: Callable[[], bool], computation: Delayed[_T]) -> Awaitable[_T]: ...
+
+    def While(self, guard: Callable[[], bool], computation: Delayed[Any]) -> Awaitable[Any]:
+        if guard():
+            return self.Bind(computation(), lambda _: self.While(guard, computation))
+        else:
+            return self.Return()
+
+    def Zero(self) -> Awaitable[None]:
+        return zero()
+
+    def Run(self, computation: Delayed[_T]) -> Awaitable[_T]:
+        # Make sure we don't execute computation right now, so wrap in a coroutine.
+        async def run() -> _T:
+            return await computation()
+
+        return run()
+
+
+task = TaskBuilder
+
+__all__ = ["task"]

arctrl/py/fable_modules/fable_library/thread.py

@@ -0,0 +1,5 @@
+import time
+
+
+def sleep(milliseconds: int) -> None:
+    time.sleep(milliseconds / 1000.0)

arctrl/py/fable_modules/fable_library/time_span.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+import re
+from math import ceil, floor, fmod
+from typing import Any
+
+from .types import FSharpRef
+from .util import pad_left_and_right_with_zeros, pad_with_zeros
+
+
+# TimeSpan is represented as an int which is the Tick value
+# We can recompute everything from this value
+class TimeSpan(int):
+    pass
+
+
+def create(
+    days: float = 0,
+    hours: float | None = None,
+    minutes: float | None = None,
+    seconds: float | None = None,
+    milliseconds: float | None = None,
+    microseconds: float | None = None,
+) -> TimeSpan:
+    match (days, hours, minutes, seconds, milliseconds, microseconds):
+        # ticks constructor
+        case (_, None, None, None, None, None):
+            return TimeSpan(days)
+        # hours, minutes, seconds constructor
+        case (_, _, _, None, None, None):
+            seconds = minutes
+            minutes = hours
+            hours = days
+            days = 0
+        # others constructor follows the correct order of arguments
+        case _:
+            pass
+
+    return TimeSpan(
+        days * 864000000000
+        + (hours or 0) * 36000000000
+        + (minutes or 0) * 600000000
+        + (seconds or 0) * 10000000
+        + (milliseconds or 0) * 10000
+        + (microseconds or 0) * 10
+    )
+
+
+def total_nanoseconds(ts: TimeSpan) -> float:
+    # We store timespan as the Tick value so nanoseconds step is 100
+    return ts * 100
+
+
+def total_microseconds(ts: TimeSpan) -> float:
+    return ts / 10
+
+
+def total_milliseconds(ts: TimeSpan) -> float:
+    return ts / 10000
+
+
+def total_seconds(ts: TimeSpan) -> float:
+    return ts / 10000000
+
+
+def total_minutes(ts: TimeSpan) -> float:
+    return ts / 600000000
+
+
+def total_hours(ts: TimeSpan) -> float:
+    return ts / 36000000000
+
+
+def total_days(ts: TimeSpan) -> float:
+    return ts / 864000000000
+
+
+def from_microseconds(micros: float) -> TimeSpan:
+    return create(0, 0, 0, 0, 0, micros)
+
+
+def from_milliseconds(msecs: int) -> TimeSpan:
+    return create(0, 0, 0, 0, msecs)
+
+
+def from_ticks(ticks: int) -> TimeSpan:
+    return create(ticks)
+
+
+def from_seconds(s: int) -> TimeSpan:
+    return create(0, 0, s)
+
+
+def from_minutes(m: int) -> TimeSpan:
+    return create(0, m, 0)
+
+
+def from_hours(h: int) -> TimeSpan:
+    return create(h, 0, 0)
+
+
+def from_days(d: int) -> TimeSpan:
+    return create(d, 0, 0, 0)
+
+
+def ticks(ts: TimeSpan) -> int:
+    return int(ts)
+
+
+def microseconds(ts: TimeSpan) -> int:
+    return int(fmod(ts, 10000) / 10)
+
+
+def milliseconds(ts: TimeSpan) -> int:
+    return int(fmod(ts, 10000000) / 10000)
+
+
+def seconds(ts: TimeSpan) -> int:
+    return int(fmod(ts, 600000000) / 10000000)
+
+
+def minutes(ts: TimeSpan) -> int:
+    return int(fmod(ts, 36000000000) / 600000000)
+
+
+def hours(ts: TimeSpan) -> int:
+    return int(fmod(ts, 864000000000) / 36000000000)
+
+
+def days(ts: TimeSpan) -> int:
+    res = ts / 864000000000
+    return ceil(res) if res < 0 else floor(res)
+
+
+def negate(ts: TimeSpan) -> TimeSpan:
+    return TimeSpan(-ts)
+
+
+def duration(ts: TimeSpan) -> TimeSpan:
+    return TimeSpan(abs(int(ts)))
+
+
+def add(ts: TimeSpan, other: TimeSpan) -> TimeSpan:
+    return TimeSpan(ts + other)
+
+
+def subtract(ts: TimeSpan, other: TimeSpan) -> TimeSpan:
+    return TimeSpan(ts - other)
+
+
+def multiply(ts: TimeSpan, factor: float) -> TimeSpan:
+    # We represents TimeSpan as a Tick which can't be a float
+    # This also allows us
+    return TimeSpan(int(ts * factor))
+
+
+def divide(ts: TimeSpan, divisor: float) -> TimeSpan:
+    return TimeSpan(int(ts / divisor))
+
+
+def to_string(ts: TimeSpan, format: str = "c", _provider: Any | None = None) -> str:
+    if format not in ["c", "g", "G"]:
+        raise ValueError("Custom formats are not supported")
+
+    d = abs(days(ts))
+    h = abs(hours(ts))
+    m = abs(minutes(ts))
+    s = abs(seconds(ts))
+    ms = abs(milliseconds(ts))
+    sign: str = "-" if ts < 0 else ""
+
+    ms_str = (
+        ""
+        if ms == 0 and format != "G"
+        else "." + pad_left_and_right_with_zeros(ms, 3, 7)
+        if format != "g"
+        else "." + pad_with_zeros(ms, 3)
+    )
+    day_str = "" if d == 0 and format != "G" else f"{d}." if format == "c" else f"{d}:"
+    hour_str = pad_with_zeros(h, 2) if format != "g" else str(h)
+
+    return f"{sign}{day_str}{hour_str}:{pad_with_zeros(m, 2)}:{pad_with_zeros(s, 2)}{ms_str}"
+
+
+_time_span_parse_regex = re.compile(
+    r"^(-?)((\d+)\.)?(?:0*)([0-9]|0[0-9]|1[0-9]|2[0-3]):(?:0*)([0-5][0-9]|[0-9])(:(?:0*)([0-5][0-9]|[0-9]))?\.?(\d+)?$"
+)
+
+
+# Second argument is to not crash when using provides CultureInfo.InvariantCulture
+def parse(string: str, _: Any | None = None) -> TimeSpan:
+    first_dot = string.find(".")
+    first_colon = string.find(":")
+    if first_dot == -1 and first_colon == -1:
+        # There is only a day ex: 4
+        # parse as int
+        try:
+            d = int(string)
+        except Exception:
+            raise Exception("String '%s' was not recognized as a valid TimeSpan." % string)
+        return from_days(d)
+    if first_colon > 0:  # process time part
+        r = _time_span_parse_regex.match(string)
+        if r is not None and r.group(4) is not None and r.group(5) is not None:
+            d = 0
+            ms = 0
+            s = 0
+            sign = -1 if r.group(1) == "-" else 1
+            h = int(r.group(4))
+            m = int(r.group(5))
+            if r.group(3) is not None:
+                d = int(r.group(3))
+            if r.group(7) is not None:
+                s = int(r.group(7))
+            if r.group(8) is not None:
+                # Depending on the number of decimals passed, we need to adapt the numbers
+                g_8: str = r.group(8)
+                match len(g_8):
+                    case 1:
+                        ms = int(g_8) * 100
+                    case 2:
+                        ms = int(g_8) * 10
+                    case 3:
+                        ms = int(g_8)
+                    case 4:
+                        ms = int(g_8) / 10
+                    case 5:
+                        ms = int(g_8) / 100
+                    case 6:
+                        ms = int(g_8) / 1000
+                    case 7:
+                        ms = int(g_8) / 10000
+                    case _:
+                        raise Exception("String '%s' was not recognized as a valid TimeSpan." % string)
+            return multiply(create(d, h, m, s, ms), sign)
+    raise Exception("String '%s' was not recognized as a valid TimeSpan." % string)
+
+
+def try_parse(
+    string: str, def_value_or_format_provider: FSharpRef[TimeSpan] | Any, def_value: FSharpRef[TimeSpan] | None = None
+) -> bool:
+    # Find where the out_value is
+    out_value: FSharpRef[TimeSpan] = def_value_or_format_provider
+
+    # If we have 3 arguments, it means that the second argument is the format provider
+    if def_value is not None:
+        out_value = def_value
+
+    try:
+        out_value.contents = parse(string)
+    except Exception:
+        return False
+
+    return True
+
+
+__all__ = [
+    "create",
+    "total_microseconds",
+    "total_milliseconds",
+    "total_seconds",
+    "total_minutes",
+    "total_hours",
+    "total_days",
+    "from_ticks",
+    "from_microseconds",
+    "from_milliseconds",
+    "from_hours",
+    "from_minutes",
+    "from_seconds",
+    "negate",
+    "duration",
+    "total_seconds",
+    "total_days",
+    "total_minutes",
+    "total_hours",
+    "add",
+    "subtract",
+    "divide",
+    "multiply",
+    "parse",
+    "try_parse",
+]

arctrl/py/fable_modules/fable_library/timer.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Callable
+from typing import Protocol
+
+
+class ITimer(Protocol):
+    @abstractmethod
+    def Create(self, __arg0: float, __arg1: Callable[[], None]) -> ITimer: ...
+
+    @abstractmethod
+    def cancel(self) -> None: ...
+
+    @property
+    @abstractmethod
+    def daemon(self) -> bool: ...
+
+    @daemon.setter
+    @abstractmethod
+    def daemon(self, __arg0: bool) -> None: ...
+
+    @abstractmethod
+    def start(self) -> None: ...