arctrl 3.0.0__py3-none-any.whl

arctrl/py/fable_modules/fable_library/map_util.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+from enum import IntEnum
+from re import Match
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    NoReturn,
+    TypeVar,
+)
+
+from .types import FSharpRef, Union
+from .util import Array
+
+
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
+
+class CaseRules(IntEnum):
+    Ignore = 0
+    LowerFirst = 1
+    SnakeCase = 2
+    SnakeCaseAllCaps = 3
+    KebabCase = 4
+
+
+def dashify(string: str, separator: str) -> str:
+    def match(m: Match[str]) -> str:
+        s = m.string
+        if len(s) == 1:
+            return s.lower()
+        else:
+            return s[0] + separator + s[1].lower()
+
+    return re.sub(r"[a-z]?[A-Z]", match, string)
+
+
+def change_case(string: str, case_rule: CaseRules) -> str:
+    if case_rule == CaseRules.LowerFirst:
+        return string[0].lower() + string[1:]
+
+    if case_rule == CaseRules.SnakeCase:
+        return dashify(string, "_")
+    if case_rule == CaseRules.SnakeCaseAllCaps:
+        return dashify(string, "_").upper()
+    if case_rule == CaseRules.KebabCase:
+        return dashify(string, "-")
+
+    return string
+
+
+if TYPE_CHECKING:
+
+    class FSharpMap(dict[_K, _V]): ...
+
+else:
+    from .map import FSharpMap
+
+
+def add_to_set(v: _V, st: set[_V]) -> bool:
+    if v in st:
+        return False
+
+    st.add(v)
+    return True
+
+
+def add_to_dict(di: dict[_K, _V], k: _K, v: _V) -> None:
+    if k in di:
+        raise Exception("An item with the same key has already been added. Key: " + str(k))
+
+    di[k] = v
+
+
+def remove_from_dict(di: dict[_K, Any], k: _K) -> bool:
+    if k in di:
+        del di[k]
+        return True
+
+    return False
+
+
+def try_get_value(map: FSharpMap[_K, _V], key: _K, default_value: FSharpRef[_V]) -> bool:
+    if key in map.keys():
+        default_value.contents = map[key]
+        return True
+
+    return False
+
+
+def get_item_from_dict(map: dict[_K, _V], key: _K) -> _V:
+    if key in map:
+        return map[key]
+    else:
+        raise Exception(f"The given key '{key}' was not present in the dictionary.")
+
+
+def contains_value(v: _V, map: dict[Any, _V]) -> bool:
+    return v in map.values()
+
+
+def key_value_list(fields: Iterable[Any], case_rule: CaseRules = CaseRules.Ignore):
+    obj: dict[str, Any] = {}
+    defined_case_rule = case_rule
+
+    def fail(kvPair: Any) -> NoReturn:
+        raise Exception("Cannot infer key and value of " + str(kvPair))
+
+    def assign(key: str, case_rule: CaseRules, value: Any):
+        key = change_case(key, case_rule)
+        obj[key] = value
+
+    for kv_pair in fields:
+        case_rule = CaseRules.Ignore
+        if kv_pair is None:
+            fail(kv_pair)
+
+        # Deflate unions and use the defined case rule
+        if isinstance(kv_pair, Union):
+            name = kv_pair.cases()[kv_pair.tag]
+            kv_pair = name if len(kv_pair.fields) == 0 else [name, *kv_pair.fields]
+            case_rule = defined_case_rule
+
+        if isinstance(kv_pair, Array):
+            length = len(kv_pair)
+            if length == 0:
+                fail(kv_pair)
+
+            elif length == 1:
+                assign(kv_pair[0], case_rule, True)
+                break
+
+            elif length == 2:
+                value = kv_pair[1]
+                assign(kv_pair[0], case_rule, value)
+                break
+
+            assign(kv_pair[0], case_rule, kv_pair[1:])
+
+        elif isinstance(kv_pair, str):
+            assign(kv_pair, case_rule, True)
+        else:
+            fail(kv_pair)
+
+    return obj

arctrl/py/fable_modules/fable_library/mutable_map.py

@@ -0,0 +1,397 @@
+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 .reflection import TypeInfo, class_type
+from .resize_array import find_index
+from .seq import concat, delay, iterate, iterate_indexed, map, to_array
+from .string_ import format
+from .types import Array, FSharpRef
+from .util import (
+    ICollection,
+    IEnumerable_1,
+    IEnumerator,
+    IEqualityComparer_1,
+    dispose,
+    equals,
+    get_enumerator,
+    ignore,
+    to_iterator,
+)
+
+
+_KEY = TypeVar("_KEY")
+
+_VALUE = TypeVar("_VALUE")
+
+
+def _expr30(gen0: TypeInfo, gen1: TypeInfo) -> TypeInfo:
+    return class_type("Fable.Collections.Dictionary", [gen0, gen1], Dictionary)
+
+
+class Dictionary(Generic[_KEY, _VALUE]):
+    def __init__(self, pairs: IEnumerable_1[Any], comparer: IEqualityComparer_1[Any]) -> None:
+        this: FSharpRef[Dictionary[_KEY, _VALUE]] = FSharpRef(None)
+        self.comparer: IEqualityComparer_1[Any] = comparer
+        this.contents = self
+        self.hash_map: Any = dict([])
+        self.init_00409: int = 1
+        with get_enumerator(pairs) as enumerator:
+            while enumerator.System_Collections_IEnumerator_MoveNext():
+                pair: Any = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+                Dictionary__Add_5BDDA1(this.contents, pair[0], pair[1])
+
+    @property
+    def Symbol_toStringTag(self, __unit: None = None) -> str:
+        return "Dictionary"
+
+    def to_json(self, __unit: None = None) -> Any:
+        this: Dictionary[_KEY, _VALUE] = self
+        return list(this)
+
+    def System_Collections_IEnumerable_GetEnumerator(self, __unit: None = None) -> IEnumerator[Any]:
+        this: Dictionary[_KEY, _VALUE] = self
+        return get_enumerator(this)
+
+    def GetEnumerator(self, __unit: None = None) -> IEnumerator[Any]:
+        this: Dictionary[_KEY, _VALUE] = self
+        return get_enumerator(concat(this.hash_map.values()))
+
+    def __iter__(self) -> IEnumerator[Any]:
+        return to_iterator(self.GetEnumerator())
+
+    def System_Collections_Generic_ICollection_1_Add2B595(self, item: Any) -> None:
+        this: Dictionary[_KEY, _VALUE] = self
+        Dictionary__Add_5BDDA1(this, item[0], item[1])
+
+    def System_Collections_Generic_ICollection_1_Clear(self, __unit: None = None) -> None:
+        this: Dictionary[_KEY, _VALUE] = self
+        Dictionary__Clear(this)
+
+    def System_Collections_Generic_ICollection_1_Contains2B595(self, item: Any) -> bool:
+        this: Dictionary[_KEY, _VALUE] = self
+        match_value: Any | None = Dictionary__TryFind_2B595(this, item[0])
+        (pattern_matching_result,) = (None,)
+        if match_value is not None:
+            if equals(match_value[1], item[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 System_Collections_Generic_ICollection_1_CopyToZ3B4C077E(self, array: Array[Any], array_index: int) -> None:
+        this: Dictionary[_KEY, _VALUE] = self
+
+        def action(i: int, e: Any) -> None:
+            array[array_index + i] = e
+
+        iterate_indexed(action, this)
+
+    def __len__(self, __unit: None = None) -> int:
+        this: Dictionary[_KEY, _VALUE] = self
+        return Dictionary__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: Any) -> bool:
+        this: Dictionary[_KEY, _VALUE] = self
+        match_value: Any | None = Dictionary__TryFind_2B595(this, item[0])
+        if match_value is not None:
+            if equals(match_value[1], item[1]):
+                ignore(Dictionary__Remove_2B595(this, item[0]))
+
+            return True
+
+        else:
+            return False
+
+    def System_Collections_Generic_IDictionary_2_Add5BDDA1(self, key: _KEY, value: _VALUE) -> None:
+        this: Dictionary[_KEY, _VALUE] = self
+        Dictionary__Add_5BDDA1(this, key, value)
+
+    def System_Collections_Generic_IDictionary_2_ContainsKey2B595(self, key: _KEY | None = None) -> bool:
+        this: Dictionary[_KEY, _VALUE] = self
+        return Dictionary__ContainsKey_2B595(this, key)
+
+    def System_Collections_Generic_IDictionary_2_get_Item2B595(self, key: _KEY | None = None) -> _VALUE:
+        this: Dictionary[_KEY, _VALUE] = self
+        return Dictionary__get_Item_2B595(this, key)
+
+    def System_Collections_Generic_IDictionary_2_set_Item5BDDA1(self, key: _KEY, v: _VALUE) -> None:
+        this: Dictionary[_KEY, _VALUE] = self
+        Dictionary__set_Item_5BDDA1(this, key, v)
+
+    def System_Collections_Generic_IDictionary_2_get_Keys(self, __unit: None = None) -> ICollection[_KEY]:
+        this: Dictionary[_KEY, _VALUE] = self
+
+        def _arrow27(__unit: None = None) -> IEnumerable_1[_KEY]:
+            def _arrow26(pair: Any) -> _KEY:
+                return pair[0]
+
+            return map(_arrow26, this)
+
+        return to_array(delay(_arrow27))
+
+    def System_Collections_Generic_IDictionary_2_Remove2B595(self, key: _KEY | None = None) -> bool:
+        this: Dictionary[_KEY, _VALUE] = self
+        return Dictionary__Remove_2B595(this, key)
+
+    def System_Collections_Generic_IDictionary_2_TryGetValue6DC89625(self, key: _KEY, value: FSharpRef[_VALUE]) -> bool:
+        this: Dictionary[_KEY, _VALUE] = self
+        match_value: Any | None = Dictionary__TryFind_2B595(this, key)
+        if match_value is not None:
+            pair: Any = match_value
+            value.contents = pair[1]
+            return True
+
+        else:
+            return False
+
+    def System_Collections_Generic_IDictionary_2_get_Values(self, __unit: None = None) -> ICollection[_VALUE]:
+        this: Dictionary[_KEY, _VALUE] = self
+
+        def _arrow29(__unit: None = None) -> IEnumerable_1[_VALUE]:
+            def _arrow28(pair: Any) -> _VALUE:
+                return pair[1]
+
+            return map(_arrow28, this)
+
+        return to_array(delay(_arrow29))
+
+    @property
+    def size(self, __unit: None = None) -> int:
+        this: Dictionary[_KEY, _VALUE] = self
+        return Dictionary__get_Count(this)
+
+    def clear(self, __unit: None = None) -> None:
+        this: Dictionary[_KEY, _VALUE] = self
+        Dictionary__Clear(this)
+
+    def __delitem__(self, k: _KEY | None = None) -> bool:
+        this: Dictionary[_KEY, _VALUE] = self
+        return Dictionary__Remove_2B595(this, k)
+
+    def entries(self, __unit: None = None) -> IEnumerable_1[tuple[_KEY, _VALUE]]:
+        this: Dictionary[_KEY, _VALUE] = self
+
+        def mapping(p: Any) -> tuple[_KEY, _VALUE]:
+            return (p[0], p[1])
+
+        return map(mapping, this)
+
+    def __getitem__(self, k: _KEY | None = None) -> _VALUE:
+        this: Dictionary[_KEY, _VALUE] = self
+        return Dictionary__get_Item_2B595(this, k)
+
+    def __contains__(self, k: _KEY | None = None) -> bool:
+        this: Dictionary[_KEY, _VALUE] = self
+        return Dictionary__ContainsKey_2B595(this, k)
+
+    def keys(self, __unit: None = None) -> IEnumerable_1[_KEY]:
+        this: Dictionary[_KEY, _VALUE] = self
+
+        def mapping(p: Any) -> _KEY:
+            return p[0]
+
+        return map(mapping, this)
+
+    def __setitem__(self, k: _KEY, v: _VALUE) -> Map_2[_KEY, _VALUE]:
+        this: Dictionary[_KEY, _VALUE] = self
+        Dictionary__set_Item_5BDDA1(this, k, v)
+        return this
+
+    def values(self, __unit: None = None) -> IEnumerable_1[_VALUE]:
+        this: Dictionary[_KEY, _VALUE] = self
+
+        def mapping(p: Any) -> _VALUE:
+            return p[1]
+
+        return map(mapping, this)
+
+    def for_each(self, f: Callable[[_VALUE, _KEY, Map_2[_KEY, _VALUE]], None], this_arg: Any | None = None) -> None:
+        this: Dictionary[_KEY, _VALUE] = self
+
+        def action(p: Any) -> None:
+            f(p[1], p[0], this)
+
+        iterate(action, this)
+
+
+Dictionary_reflection = _expr30
+
+
+def Dictionary__ctor_6623D9B3(
+    pairs: IEnumerable_1[Any], comparer: IEqualityComparer_1[Any]
+) -> Dictionary[_KEY, _VALUE]:
+    return Dictionary(pairs, comparer)
+
+
+def Dictionary__TryFindIndex_2B595(this: Dictionary[Any, Any], k: Any) -> tuple[bool, int, int]:
+    h: int = this.comparer.GetHashCode(k) or 0
+    match_value: tuple[bool, Array[Any]]
+    out_arg: Array[Any] = None
+
+    def _arrow31(__unit: None = None, this: Any = this, k: Any = k) -> Array[Any]:
+        return out_arg
+
+    def _arrow32(v: Array[Any], this: Any = this, k: Any = k) -> None:
+        nonlocal out_arg
+        out_arg = v
+
+    match_value = (try_get_value(this.hash_map, h, FSharpRef(_arrow31, _arrow32)), out_arg)
+    if match_value[0]:
+
+        def _arrow33(pair: Any, this: Any = this, k: Any = k) -> bool:
+            return this.comparer.Equals(k, pair[0])
+
+        return (True, h, find_index(_arrow33, match_value[1]))
+
+    else:
+        return (False, h, -1)
+
+
+def Dictionary__TryFind_2B595(this: Dictionary[Any, Any], k: Any) -> Any | None:
+    match_value: tuple[bool, int, int] = Dictionary__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 get_item_from_dict(this.hash_map, match_value[1])[match_value[2]]
+
+    elif pattern_matching_result == 1:
+        return None
+
+
+def Dictionary__get_Comparer(this: Dictionary[Any, Any]) -> IEqualityComparer_1[Any]:
+    return this.comparer
+
+
+def Dictionary__Clear(this: Dictionary[Any, Any]) -> None:
+    this.hash_map.clear()
+
+
+def Dictionary__get_Count(this: Dictionary[Any, Any]) -> int:
+    count: int = 0
+    enumerator: Any = get_enumerator(this.hash_map.values())
+    try:
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            pairs: Array[Any] = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+            count = (count + len(pairs)) or 0
+
+    finally:
+        dispose(enumerator)
+
+    return count
+
+
+def Dictionary__get_Item_2B595(this: Dictionary[Any, Any], k: Any) -> Any:
+    match_value: Any | None = Dictionary__TryFind_2B595(this, k)
+    if match_value is not None:
+        return match_value[1]
+
+    else:
+        raise Exception("The item was not found in collection")
+
+
+def Dictionary__set_Item_5BDDA1(this: Dictionary[Any, Any], k: Any, v: Any) -> None:
+    match_value: tuple[bool, int, int] = Dictionary__TryFindIndex_2B595(this, k)
+    if match_value[0]:
+        if match_value[2] > -1:
+            get_item_from_dict(this.hash_map, match_value[1])[match_value[2]] = (k, v)
+
+        else:
+            value: None = get_item_from_dict(this.hash_map, match_value[1]).append((k, v))
+            ignore(None)
+
+    else:
+        this.hash_map[match_value[1]] = [(k, v)]
+
+
+def Dictionary__Add_5BDDA1(this: Dictionary[Any, Any], k: Any, v: Any) -> None:
+    match_value: tuple[bool, int, int] = Dictionary__TryFindIndex_2B595(this, k)
+    if match_value[0]:
+        if match_value[2] > -1:
+            raise Exception(format("An item with the same key has already been added. Key: {0}", k))
+
+        else:
+            value: None = get_item_from_dict(this.hash_map, match_value[1]).append((k, v))
+            ignore(None)
+
+    else:
+        this.hash_map[match_value[1]] = [(k, v)]
+
+
+def Dictionary__ContainsKey_2B595(this: Dictionary[Any, Any], k: Any) -> bool:
+    match_value: tuple[bool, int, int] = Dictionary__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 Dictionary__Remove_2B595(this: Dictionary[Any, Any], k: Any) -> bool:
+    match_value: tuple[bool, int, int] = Dictionary__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__ = [
+    "Dictionary_reflection",
+    "Dictionary__TryFindIndex_2B595",
+    "Dictionary__TryFind_2B595",
+    "Dictionary__get_Comparer",
+    "Dictionary__Clear",
+    "Dictionary__get_Count",
+    "Dictionary__get_Item_2B595",
+    "Dictionary__set_Item_5BDDA1",
+    "Dictionary__Add_5BDDA1",
+    "Dictionary__ContainsKey_2B595",
+    "Dictionary__Remove_2B595",
+]