arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/fable_modules/fable_library/option.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar, cast
+
+
+_T = TypeVar("_T")
+_U = TypeVar("_U")
+_V = TypeVar("_V")
+_W = TypeVar("_W")
+
+
+class Some(Generic[_T]):
+    ___slots__ = "value"
+
+    def __init__(self, value: _T):
+        self.value = value
+
+    def __eq__(self, other: Any) -> bool:
+        if self is other:
+            return True
+
+        if other is None:
+            return False
+
+        if self.value == other.value:
+            return True
+
+        return False
+
+    def __str__(self):
+        return f"Some {self.value}"
+
+    def __repr__(self):
+        return str(self)
+
+
+def default_arg(opt: _T | None, default_value: _T) -> _T:
+    return value(opt) if opt is not None else default_value
+
+
+def default_arg_with(opt: _T | None, def_thunk: Callable[[], _T]) -> _T:
+    return value(opt) if opt is not None else def_thunk()
+
+
+def filter(predicate: Callable[[_T], bool], opt: _T | None) -> _T | None:
+    if opt is not None:
+        return opt if predicate(value(opt)) else None
+    return opt
+
+
+def map(mapping: Callable[[_T], _U], opt: _T | None) -> _U | None:
+    return some(mapping(value(opt))) if opt is not None else None
+
+
+def map2(mapping: Callable[[_T, _U], _V], opt1: _T | None, opt2: _U | None) -> _V | None:
+    return mapping(value(opt1), value(opt2)) if (opt1 is not None and opt2 is not None) else None
+
+
+def map3(
+    mapping: Callable[[_T, _U, _V], _W],
+    opt1: _T | None,
+    opt2: _U | None,
+    opt3: _V | None,
+) -> _W | None:
+    return (
+        mapping(value(opt1), value(opt2), value(opt3))
+        if (opt1 is not None and opt2 is not None and opt3 is not None)
+        else None
+    )
+
+
+def some(x: Any) -> Any | None:
+    return Some[Any](x) if x is None or isinstance(x, Some) else x
+
+
+def value(x: _T | None) -> _T:
+    if x is None:
+        raise Exception("Option has no value")
+    elif isinstance(x, Some):
+        y = cast(Some[_T], x)
+        return y.value
+    return x
+
+
+def of_nullable(x: _T | None) -> _T | None:
+    return x
+
+
+def to_nullable(x: _T | None) -> _T | None:
+    return None if x is None else value(x)
+
+
+def flatten(x: _T | None | None) -> _T | None:
+    return x if x is None else value(x)
+
+
+def to_array(opt: _T | None) -> list[_T]:
+    return [] if opt is None else [value(opt)]
+
+
+def bind(binder: Callable[[_T], _U | None], opt: _T | None) -> _U | None:
+    return binder(value(opt)) if opt is not None else None
+
+
+def or_else(opt: _T | None, if_none: _T | None) -> _T | None:
+    return if_none if opt is None else opt
+
+
+def or_else_with(opt: _T | None, if_none_thunk: Callable[[], _T | None]) -> _T | None:
+    return if_none_thunk() if opt is None else opt
+
+
+__all__ = [
+    "bind",
+    "default_arg",
+    "default_arg_with",
+    "flatten",
+    "map",
+    "map2",
+    "map3",
+    "of_nullable",
+    "some",
+    "Some",
+    "to_array",
+    "to_nullable",
+    "value",
+]

arctrl/py/fable_modules/fable_library/path.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import os
+import tempfile
+
+
+def get_temp_file_name() -> str:
+    fd, name = tempfile.mkstemp()
+    os.close(fd)
+    return name
+
+
+def get_temp_path() -> str:
+    return tempfile.gettempdir()
+
+
+def get_extension(path: str) -> str:
+    return os.path.splitext(path)[1]
+
+
+def get_random_file_name() -> str:
+    name = os.urandom(4).hex()
+    ext = os.urandom(2).hex()[:3]
+    return f"{name}.{ext}"
+
+
+def get_file_name(path: str) -> str:
+    return os.path.basename(path)
+
+
+def get_directory_name(path: str) -> str:
+    return os.path.dirname(path)
+
+
+def get_file_name_without_extension(path: str) -> str:
+    return os.path.splitext(os.path.basename(path))[0]
+
+
+def get_full_path(path: str, base_path: str | None = None) -> str:
+    return os.path.join(base_path or "", path)
+
+
+def get_relative_path(relative_to: str, path: str) -> str:
+    return os.path.relpath(path, relative_to)
+
+
+def has_extension(path: str) -> bool:
+    return os.path.splitext(path)[1] != ""
+
+
+__all__ = [
+    "get_temp_file_name",
+    "get_temp_path",
+    "get_extension",
+    "get_random_file_name",
+    "get_file_name",
+    "get_directory_name",
+    "get_file_name_without_extension",
+    "get_full_path",
+    "get_relative_path",
+    "has_extension",
+]

arctrl/py/fable_modules/fable_library/range.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from decimal import Decimal
+from typing import Any, TypeVar
+
+from .big_int import from_zero, op_addition
+from .char import char_code_at
+from .decimal_ import from_parts
+from .decimal_ import op_addition as op_addition_1
+from .long import op_addition as op_addition_2
+from .seq import delay, unfold
+from .types import int64, uint8, uint64
+from .util import IEnumerable_1, compare
+
+
+_T = TypeVar("_T")
+
+
+def make_range_step_function(
+    step: Any, stop: Any, zero: Any, add: Callable[[_T, _T], _T]
+) -> Callable[[_T], tuple[_T, _T] | None]:
+    step_compared_with_zero: int = compare(step, zero) or 0
+    if step_compared_with_zero == 0:
+        raise Exception("The step of a range cannot be zero")
+
+    step_greater_than_zero: bool = step_compared_with_zero > 0
+
+    def _arrow126(
+        x: _T | None = None, step: Any = step, stop: Any = stop, zero: Any = zero, add: Any = add
+    ) -> tuple[_T, _T] | None:
+        compared_with_last: int = compare(x, stop) or 0
+        return (
+            ((x, add(x, step)))
+            if (
+                True
+                if ((compared_with_last <= 0) if step_greater_than_zero else False)
+                else ((compared_with_last >= 0) if (not step_greater_than_zero) else False)
+            )
+            else None
+        )
+
+    return _arrow126
+
+
+def integral_range_step(start: Any, step: Any, stop: Any, zero: Any, add: Callable[[_T, _T], _T]) -> IEnumerable_1[Any]:
+    step_fn: Callable[[_T], tuple[_T, _T] | None] = make_range_step_function(step, stop, zero, add)
+
+    def _arrow127(
+        __unit: None = None, start: Any = start, step: Any = step, stop: Any = stop, zero: Any = zero, add: Any = add
+    ) -> IEnumerable_1[_T]:
+        return unfold(step_fn, start)
+
+    return delay(_arrow127)
+
+
+def range_big_int(start: int, step: int, stop: int) -> IEnumerable_1[int]:
+    def _arrow128(x: int, y: int, start: Any = start, step: Any = step, stop: Any = stop) -> int:
+        return op_addition(x, y)
+
+    return integral_range_step(start, step, stop, from_zero(), _arrow128)
+
+
+def range_decimal(start: Decimal, step: Decimal, stop: Decimal) -> IEnumerable_1[Decimal]:
+    def _arrow129(x: Decimal, y: Decimal, start: Any = start, step: Any = step, stop: Any = stop) -> Decimal:
+        return op_addition_1(x, y)
+
+    return integral_range_step(start, step, stop, from_parts(0, 0, 0, False, uint8(0)), _arrow129)
+
+
+def range_double(start: float, step: float, stop: float) -> IEnumerable_1[float]:
+    def _arrow130(x: float, y: float, start: Any = start, step: Any = step, stop: Any = stop) -> float:
+        return x + y
+
+    return integral_range_step(start, step, stop, 0.0, _arrow130)
+
+
+def range_int64(start: int64, step: int64, stop: int64) -> IEnumerable_1[int64]:
+    def _arrow131(x: int64, y: int64, start: Any = start, step: Any = step, stop: Any = stop) -> int64:
+        return op_addition_2(x, y)
+
+    return integral_range_step(start, step, stop, int64(0), _arrow131)
+
+
+def range_uint64(start: uint64, step: uint64, stop: uint64) -> IEnumerable_1[uint64]:
+    def _arrow132(x: uint64, y: uint64, start: Any = start, step: Any = step, stop: Any = stop) -> uint64:
+        return op_addition_2(x, y)
+
+    return integral_range_step(start, step, stop, uint64(0), _arrow132)
+
+
+def range_char(start: str, stop: str) -> IEnumerable_1[str]:
+    int_stop: int = int(char_code_at(stop, 0)) or 0
+
+    def _arrow133(__unit: None = None, start: Any = start, stop: Any = stop) -> IEnumerable_1[str]:
+        def step_fn(c: int) -> tuple[str, int] | None:
+            if c <= int_stop:
+                return (chr(c), c + 1)
+
+            else:
+                return None
+
+        return unfold(step_fn, int(char_code_at(start, 0)))
+
+    return delay(_arrow133)
+
+
+__all__ = [
+    "make_range_step_function",
+    "integral_range_step",
+    "range_big_int",
+    "range_decimal",
+    "range_double",
+    "range_int64",
+    "range_uint64",
+    "range_char",
+]