arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/fable_modules/yamlicious/encode.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ..fable_library.date import to_string as to_string_1
+from ..fable_library.list import (of_seq, map as map_1, of_array, FSharpList)
+from ..fable_library.option import value as value_1
+from ..fable_library.seq import map
+from ..fable_library.types import (to_string, Array)
+from ..fable_library.util import (int32_to_string, IEnumerable_1)
+from .writer import write as write_1
+from .yamlicious_types import (YAMLContent_create_27AED5E3, YAMLElement, Config)
+
+_A = TypeVar("_A")
+
+def int_1(value: int) -> YAMLElement:
+    return YAMLElement(1, YAMLContent_create_27AED5E3(int32_to_string(value)))
+
+
+def float_1(value: float) -> YAMLElement:
+    return YAMLElement(1, YAMLContent_create_27AED5E3(str(value)))
+
+
+def char(value: str) -> YAMLElement:
+    return YAMLElement(1, YAMLContent_create_27AED5E3(value))
+
+
+def bool_1(value: bool) -> YAMLElement:
+    return YAMLElement(1, YAMLContent_create_27AED5E3(to_string(value)))
+
+
+def datetime(value: Any) -> YAMLElement:
+    return YAMLElement(1, YAMLContent_create_27AED5E3(to_string_1(value, "O", {})))
+
+
+def datetime_offset(value: Any) -> YAMLElement:
+    return YAMLElement(1, YAMLContent_create_27AED5E3(to_string_1(value, "O", {})))
+
+
+def string(value: str) -> YAMLElement:
+    return YAMLElement(1, YAMLContent_create_27AED5E3(value))
+
+
+def seq(encoder: Callable[[_A], YAMLElement], s: IEnumerable_1[Any]) -> YAMLElement:
+    return YAMLElement(2, of_seq(map(encoder, s)))
+
+
+def array(encoder: Callable[[_A], YAMLElement], arr: Array[Any]) -> YAMLElement:
+    return YAMLElement(2, map_1(encoder, of_array(arr)))
+
+
+def resizearray(encoder: Callable[[_A], YAMLElement], arr: Array[Any]) -> YAMLElement:
+    return YAMLElement(2, map_1(encoder, of_seq(arr)))
+
+
+def list_1(encoder: Callable[[_A], YAMLElement], l: FSharpList[Any]) -> YAMLElement:
+    return YAMLElement(2, map_1(encoder, l))
+
+
+def values(encoder: Callable[[_A], str], values_1: IEnumerable_1[Any]) -> YAMLElement:
+    def mapping(arg_1: _A | None=None, encoder: Any=encoder, values_1: Any=values_1) -> YAMLElement:
+        return YAMLElement(1, YAMLContent_create_27AED5E3(encoder(arg_1)))
+
+    return YAMLElement(3, of_seq(map(mapping, values_1)))
+
+
+def comment(string_1: str) -> YAMLElement:
+    return YAMLElement(4, string_1)
+
+
+nil: YAMLElement = YAMLElement(5)
+
+def try_include(name: str, encoder: Callable[[_A], YAMLElement], value: Any | None=None) -> tuple[str, YAMLElement]:
+    return (name, encoder(value_1(value)) if (value is not None) else nil)
+
+
+def write(whitespaces: int, ele: YAMLElement) -> str:
+    def _arrow365(c: Config, whitespaces: Any=whitespaces, ele: Any=ele) -> Config:
+        return Config(whitespaces, c.Level)
+
+    return write_1(ele, _arrow365)
+
+
+__all__ = ["int_1", "float_1", "char", "bool_1", "datetime", "datetime_offset", "string", "seq", "array", "resizearray", "list_1", "values", "comment", "nil", "try_include", "write"]
+

arctrl/py/fable_modules/yamlicious/library.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+from ..fable_library.list import of_array
+from .yamlicious_types import PreprocessorElement
+
+SequenceMappingsAST: PreprocessorElement = PreprocessorElement(0, of_array([PreprocessorElement(2, "-"), PreprocessorElement(1, of_array([PreprocessorElement(2, "My Key1: My Value1"), PreprocessorElement(2, "My Key2: My Value2"), PreprocessorElement(2, "My Key3: My Value3")])), PreprocessorElement(2, "-"), PreprocessorElement(1, of_array([PreprocessorElement(2, "My Key4: My Value4"), PreprocessorElement(2, "My Key5: My Value5"), PreprocessorElement(2, "My Key6: My Value6")]))]))
+
+StringReplaceClean: str = "\r\nMy Key: </1>\r\n"
+
+__all__ = ["SequenceMappingsAST", "StringReplaceClean"]
+

arctrl/py/fable_modules/yamlicious/persil.py

@@ -0,0 +1,57 @@
+from typing import Any
+from ..fable_library.map_util import add_to_dict
+from ..fable_library.reg_exp import (replace as replace_1, get_item, groups, create)
+from ..fable_library.string_ import (replace, to_text, printf, split)
+from ..fable_library.types import Array
+
+def encoding_clean_up(s: str) -> str:
+    return replace(s, "\r\n", "\n")
+
+
+def string_clean_up(dict_1: Any, s: str) -> str:
+    n: int = 0
+    def matcheval(m: Any, dict_1: Any=dict_1, s: Any=s) -> str:
+        nonlocal n
+        if get_item(groups(m), "iscomment") is not None:
+            return get_item(groups(m), "all") or ""
+
+        else: 
+            v: str = get_item(groups(m), "stringValue") or ""
+            current_n: int = n or 0
+            n = (n + 1) or 0
+            add_to_dict(dict_1, current_n, v)
+            return to_text(printf("<s f=%i/>"))(current_n)
+
+
+    return replace_1(create("(?P<all>(?P<iscomment>#.*?)?\"(?P<stringValue>.+)\\\")"), s, matcheval)
+
+
+def comment_clean_up(dict_1: Any, s: str) -> str:
+    n: int = 0
+    def matcheval(m: Any, dict_1: Any=dict_1, s: Any=s) -> str:
+        nonlocal n
+        v: str = get_item(groups(m), "comment") or ""
+        current_n: int = n or 0
+        n = (n + 1) or 0
+        add_to_dict(dict_1, current_n, v)
+        return to_text(printf("<c f=%i/>"))(current_n)
+
+    return replace_1(create("#(?P<comment>.*)"), s, matcheval)
+
+
+def cut(yaml_string: str) -> Array[str]:
+    return split(yaml_string, ["\n"], None, 1)
+
+
+def pipeline(yaml_string: str) -> dict[str, Any]:
+    string_map: Any = dict([])
+    comment_map: Any = dict([])
+    return {
+        "CommentMap": comment_map,
+        "Lines": cut(comment_clean_up(comment_map, string_clean_up(string_map, encoding_clean_up(yaml_string)))),
+        "StringMap": string_map
+    }
+
+
+__all__ = ["encoding_clean_up", "string_clean_up", "comment_clean_up", "cut", "pipeline"]
+

arctrl/py/fable_modules/yamlicious/preprocessing.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_library.list import (is_empty, tail, FSharpList, head, cons, take_while as take_while_1, skip_while, reverse, empty, of_array, of_seq)
+from ..fable_library.option import value as value_1
+from ..fable_library.seq import (length, take_while)
+from ..fable_library.system_text import (StringBuilder__ctor, StringBuilder__AppendLine_Z721C83C5)
+from ..fable_library.types import to_string
+from ..fable_library.util import (get_enumerator, ignore)
+from .persil import pipeline
+from .yamlicious_types import (Config, Config_init_71136F3F, Config__get_WhitespaceString, PreprocessorElement, Preprocessor)
+
+def ReadHelpers_indentLevel(line: str) -> int:
+    def predicate(c: str, line: Any=line) -> bool:
+        return c == " "
+
+    return length(take_while(predicate, line))
+
+
+def write(root_element: PreprocessorElement, fconfig: Callable[[Config], Config] | None=None) -> str:
+    config_1: Config
+    config: Config = Config_init_71136F3F()
+    config_1 = value_1(fconfig)(config) if (fconfig is not None) else config
+    sb: Any = StringBuilder__ctor()
+    def loop(current: PreprocessorElement, sb_1: Any, config_2: Config, root_element: Any=root_element, fconfig: Any=fconfig) -> None:
+        if current.tag == 1:
+            next_config: Config = Config(config_2.Whitespace, config_2.Level + 1)
+            with get_enumerator(current.fields[0]) as enumerator:
+                while enumerator.System_Collections_IEnumerator_MoveNext():
+                    loop(enumerator.System_Collections_Generic_IEnumerator_1_get_Current(), sb_1, next_config)
+
+        elif current.tag == 0:
+            with get_enumerator(current.fields[0]) as enumerator_1:
+                while enumerator_1.System_Collections_IEnumerator_MoveNext():
+                    loop(enumerator_1.System_Collections_Generic_IEnumerator_1_get_Current(), sb_1, config_2)
+
+        elif current.tag == 3:
+            pass
+
+        else: 
+            ignore(StringBuilder__AppendLine_Z721C83C5(sb_1, Config__get_WhitespaceString(config_2) + current.fields[0]))
+
+
+    loop(root_element, sb, config_1)
+    return to_string(sb)
+
+
+def read(yaml_str: str) -> Preprocessor:
+    content: dict[str, Any] = pipeline(yaml_str)
+    def loop(lines_mut: FSharpList[str], current_intendation_mut: int, acc_mut: FSharpList[PreprocessorElement], yaml_str: Any=yaml_str) -> FSharpList[PreprocessorElement]:
+        while True:
+            (lines, current_intendation, acc) = (lines_mut, current_intendation_mut, acc_mut)
+            if not is_empty(lines):
+                rest: FSharpList[str] = tail(lines)
+                line: str = head(lines)
+                line_ele: PreprocessorElement = PreprocessorElement(2, line.strip())
+                next_intendation: int = ReadHelpers_indentLevel(line) or 0
+                if next_intendation == current_intendation:
+                    lines_mut = rest
+                    current_intendation_mut = current_intendation
+                    acc_mut = cons(PreprocessorElement(2, line.strip()), acc)
+                    continue
+
+                else: 
+                    def predicate(l: str, lines: Any=lines, current_intendation: Any=current_intendation, acc: Any=acc) -> bool:
+                        return ReadHelpers_indentLevel(l) > current_intendation
+
+                    next_level_lines: FSharpList[str] = take_while_1(predicate, rest)
+                    def predicate_1(l_1: str, lines: Any=lines, current_intendation: Any=current_intendation, acc: Any=acc) -> bool:
+                        return ReadHelpers_indentLevel(l_1) > current_intendation
+
+                    lines_mut = skip_while(predicate_1, rest)
+                    current_intendation_mut = current_intendation
+                    acc_mut = cons(PreprocessorElement(1, cons(line_ele, reverse(loop(next_level_lines, next_intendation, empty())))), acc)
+                    continue
+
+
+            else: 
+                return acc
+
+            break
+
+    return Preprocessor(PreprocessorElement(0, reverse(loop(of_array(content["Lines"]), 0, empty()))), content["StringMap"], content["CommentMap"])
+
+
+def mk_line(line: str) -> PreprocessorElement:
+    return PreprocessorElement(2, line)
+
+
+def mkl_level(children: Any | None=None) -> PreprocessorElement:
+    return PreprocessorElement(0, of_seq(children))
+
+
+def mk_intendation(children: Any | None=None) -> PreprocessorElement:
+    return PreprocessorElement(1, of_seq(children))
+
+
+__all__ = ["ReadHelpers_indentLevel", "write", "read", "mk_line", "mkl_level", "mk_intendation"]
+