arctrl 3.0.0__py3-none-any.whl

arctrl/py/fable_modules/yamlicious/regex.py

@@ -0,0 +1,29 @@
+
+KeyPattern: str = ("^(?P<key>[^\\{\\[]+):\\s*(" + "\\<c f=(?P<comment>\\d+)\\/\\>") + ")?$"
+
+LineCommentPattern: str = ("^" + "\\<c f=(?P<comment>\\d+)\\/\\>") + "$"
+
+ValuePattern: str = ("^(?P<value>.*?)\\s*?(" + "\\<c f=(?P<comment>\\d+)\\/\\>") + ")?$"
+
+FlowStyleArrayPattern: str = ("^\\[(?P<inlineSequence>.+)\\]\\s*?(" + "\\<c f=(?P<comment>\\d+)\\/\\>") + ")?$"
+
+InlineSequencePattern: str = FlowStyleArrayPattern
+
+FlowStyleObjectPattern: str = ("^\\{(?P<inlineSequence>.*)\\}\\s*?(" + "\\<c f=(?P<comment>\\d+)\\/\\>") + ")?$"
+
+InlineJSONPattern: str = FlowStyleObjectPattern
+
+SequenceOpenerPattern: str = ("^\\[\\s*(" + "\\<c f=(?P<comment>\\d+)\\/\\>") + ")?$"
+
+SequenceCloserPattern: str = ("^\\]\\s*(" + "\\<c f=(?P<comment>\\d+)\\/\\>") + ")?$"
+
+FlowStyleObjectOpenerPattern: str = ("^(?P<key>[^\\{\\[]+):\\s+\\{\\s*(" + "\\<c f=(?P<comment>\\d+)\\/\\>") + ")?$"
+
+JSONOpenerPattern: str = FlowStyleObjectOpenerPattern
+
+FlowStyleObjectCloserPattern: str = ("^\\}\\s*(" + "\\<c f=(?P<comment>\\d+)\\/\\>") + ")?$"
+
+JSONCloserPattern: str = FlowStyleObjectCloserPattern
+
+__all__ = ["KeyPattern", "LineCommentPattern", "ValuePattern", "FlowStyleArrayPattern", "InlineSequencePattern", "FlowStyleObjectPattern", "InlineJSONPattern", "SequenceOpenerPattern", "SequenceCloserPattern", "FlowStyleObjectOpenerPattern", "JSONOpenerPattern", "FlowStyleObjectCloserPattern", "JSONCloserPattern"]
+

arctrl/py/fable_modules/yamlicious/regex_active_patterns.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_library.int32 import parse
+from ..fable_library.reg_exp import (match, create, get_item, groups)
+from .regex import (KeyPattern, ValuePattern, LineCommentPattern, FlowStyleArrayPattern, SequenceOpenerPattern, SequenceCloserPattern, FlowStyleObjectPattern, FlowStyleObjectOpenerPattern, FlowStyleObjectCloserPattern)
+from .yamlicious_types import PreprocessorElement
+
+def _007CKey_007C__007C(input: PreprocessorElement) -> dict[str, Any] | None:
+    if input.tag == 2:
+        m: Any = match(create(KeyPattern), input.fields[0])
+        if m is not None:
+            def _arrow574(__unit: None=None, input: Any=input) -> int | None:
+                v: str = get_item(groups(m), "comment") or ""
+                return None if (v == "") else parse(v, 511, False, 32)
+
+            return {
+                "Comment": _arrow574(),
+                "Key": get_item(groups(m), "key") or ""
+            }
+
+        else: 
+            return None
+
+
+    else: 
+        return None
+
+
+
+def _007CKeyValue_007C__007C(input: PreprocessorElement) -> dict[str, Any] | None:
+    if input.tag == 2:
+        m: Any = match(create("^(?P<key>[^\\{{\\[]+):\\s+(?P<value>.*)$"), input.fields[0])
+        if m is not None:
+            v: str = get_item(groups(m), "value") or "".strip()
+            return {
+                "Key": get_item(groups(m), "key") or "",
+                "Value": v
+            }
+
+        else: 
+            return None
+
+
+    else: 
+        return None
+
+
+
+def _007CYamlValue_007C__007C(input: PreprocessorElement) -> dict[str, Any] | None:
+    if input.tag == 2:
+        m: Any = match(create(ValuePattern), input.fields[0])
+        if m is not None:
+            def _arrow575(__unit: None=None, input: Any=input) -> int | None:
+                v: str = get_item(groups(m), "comment") or ""
+                return None if (v == "") else parse(v, 511, False, 32)
+
+            return {
+                "Comment": _arrow575(),
+                "Value": get_item(groups(m), "value") or "".strip()
+            }
+
+        else: 
+            return None
+
+
+    else: 
+        return None
+
+
+
+def _007CYamlComment_007C__007C(input: PreprocessorElement) -> dict[str, Any] | None:
+    if input.tag == 2:
+        m: Any = match(create(LineCommentPattern), input.fields[0])
+        if m is not None:
+            return {
+                "Comment": parse(get_item(groups(m), "comment") or "", 511, False, 32)
+            }
+
+        else: 
+            return None
+
+
+    else: 
+        return None
+
+
+
+def _007CSequenceMinusOpener_007C__007C(input: PreprocessorElement) -> dict[str, Any] | None:
+    if input.tag == 2:
+        m: Any = match(create("^-(\\s+(?P<value>.*))?$"), input.fields[0])
+        if m is not None:
+            def _arrow576(__unit: None=None, input: Any=input) -> str | None:
+                v: str = get_item(groups(m), "value") or "".strip()
+                return None if (v == "") else v
+
+            return {
+                "Value": _arrow576()
+            }
+
+        else: 
+            return None
+
+
+    else: 
+        return None
+
+
+
+def _007CFlowStyleArray_007C__007C(input: PreprocessorElement) -> dict[str, Any] | None:
+    if input.tag == 2:
+        m: Any = match(create(FlowStyleArrayPattern), input.fields[0])
+        if m is not None:
+            def _arrow577(__unit: None=None, input: Any=input) -> int | None:
+                v: str = get_item(groups(m), "comment") or ""
+                return None if (v == "") else parse(v, 511, False, 32)
+
+            return {
+                "Comment": _arrow577(),
+                "Value": get_item(groups(m), "inlineSequence") or ""
+            }
+
+        else: 
+            return None
+
+
+    else: 
+        return None
+
+
+
+_007CInlineSequence_007C__007C: Callable[[PreprocessorElement], dict[str, Any] | None] = _007CFlowStyleArray_007C__007C
+
+def _007CSequenceSquareOpener_007C__007C(input: PreprocessorElement) -> dict[str, Any] | None:
+    if input.tag == 2:
+        m: Any = match(create(SequenceOpenerPattern), input.fields[0])
+        if m is not None:
+            def _arrow578(__unit: None=None, input: Any=input) -> int | None:
+                v: str = get_item(groups(m), "comment") or ""
+                return None if (v == "") else parse(v, 511, False, 32)
+
+            return {
+                "Comment": _arrow578()
+            }
+
+        else: 
+            return None
+
+
+    else: 
+        return None
+
+
+
+def _007CSequenceSquareCloser_007C__007C(input: PreprocessorElement) -> dict[str, Any] | None:
+    if input.tag == 2:
+        m: Any = match(create(SequenceCloserPattern), input.fields[0])
+        if m is not None:
+            def _arrow579(__unit: None=None, input: Any=input) -> int | None:
+                v: str = get_item(groups(m), "comment") or ""
+                return None if (v == "") else parse(v, 511, False, 32)
+
+            return {
+                "Comment": _arrow579()
+            }
+
+        else: 
+            return None
+
+
+    else: 
+        return None
+
+
+
+def _007CFlowStyleObject_007C__007C(input: PreprocessorElement) -> dict[str, Any] | None:
+    if input.tag == 2:
+        m: Any = match(create(FlowStyleObjectPattern), input.fields[0])
+        if m is not None:
+            def _arrow580(__unit: None=None, input: Any=input) -> int | None:
+                v: str = get_item(groups(m), "comment") or ""
+                return None if (v == "") else parse(v, 511, False, 32)
+
+            return {
+                "Comment": _arrow580(),
+                "Value": get_item(groups(m), "inlineSequence") or ""
+            }
+
+        else: 
+            return None
+
+
+    else: 
+        return None
+
+
+
+_007CInlineJSON_007C__007C: Callable[[PreprocessorElement], dict[str, Any] | None] = _007CFlowStyleObject_007C__007C
+
+def _007CFlowStyleObjectOpener_007C__007C(input: PreprocessorElement) -> dict[str, Any] | None:
+    if input.tag == 2:
+        m: Any = match(create(FlowStyleObjectOpenerPattern), input.fields[0])
+        if m is not None:
+            def _arrow581(__unit: None=None, input: Any=input) -> int | None:
+                v: str = get_item(groups(m), "comment") or ""
+                return None if (v == "") else parse(v, 511, False, 32)
+
+            return {
+                "Comment": _arrow581(),
+                "Key": get_item(groups(m), "key") or ""
+            }
+
+        else: 
+            return None
+
+
+    else: 
+        return None
+
+
+
+_007CJSONKeyOpener_007C__007C: Callable[[PreprocessorElement], dict[str, Any] | None] = _007CFlowStyleObjectOpener_007C__007C
+
+def _007CFlowStyleObjectCloser_007C__007C(input: PreprocessorElement) -> dict[str, Any] | None:
+    if input.tag == 2:
+        m: Any = match(create(FlowStyleObjectCloserPattern), input.fields[0])
+        if m is not None:
+            def _arrow582(__unit: None=None, input: Any=input) -> int | None:
+                v: str = get_item(groups(m), "comment") or ""
+                return None if (v == "") else parse(v, 511, False, 32)
+
+            return {
+                "Comment": _arrow582()
+            }
+
+        else: 
+            return None
+
+
+    else: 
+        return None
+
+
+
+_007CJSONCloser_007C__007C: Callable[[PreprocessorElement], dict[str, Any] | None] = _007CFlowStyleObjectCloser_007C__007C
+
+def _007CSchemaNamespace_007C__007C(input: PreprocessorElement) -> dict[str, Any] | None:
+    if input.tag == 2:
+        m: Any = match(create("^\\$(?P<key>[a-zA-Z0-9\\s:]+):$"), input.fields[0])
+        if m is not None:
+            return {
+                "Key": get_item(groups(m), "key") or ""
+            }
+
+        else: 
+            return None
+
+
+    else: 
+        return None
+
+
+
+__all__ = ["_007CKey_007C__007C", "_007CKeyValue_007C__007C", "_007CYamlValue_007C__007C", "_007CYamlComment_007C__007C", "_007CSequenceMinusOpener_007C__007C", "_007CFlowStyleArray_007C__007C", "_007CInlineSequence_007C__007C", "_007CSequenceSquareOpener_007C__007C", "_007CSequenceSquareCloser_007C__007C", "_007CFlowStyleObject_007C__007C", "_007CInlineJSON_007C__007C", "_007CFlowStyleObjectOpener_007C__007C", "_007CJSONKeyOpener_007C__007C", "_007CFlowStyleObjectCloser_007C__007C", "_007CJSONCloser_007C__007C", "_007CSchemaNamespace_007C__007C"]
+

arctrl/py/fable_modules/yamlicious/writer.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_library.list import (FSharpList, map as map_1, singleton, of_array)
+from ..fable_library.option import (default_arg, map)
+from ..fable_library.seq import (for_all, to_list, delay, map as map_2, collect, singleton as singleton_1)
+from ..fable_library.string_ import join
+from ..fable_library.util import IEnumerable_1
+from .preprocessing import write as write_1
+from .yamlicious_types import (YAMLElement, YAMLContent, PreprocessorElement, Config)
+
+def StyleVerifier_checkInlineSequence(ele: FSharpList[YAMLElement]) -> bool:
+    def predicate(x: YAMLElement, ele: Any=ele) -> bool:
+        (pattern_matching_result,) = (None,)
+        if x.tag == 1:
+            if x.fields[0].Comment is None:
+                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
+
+
+    return for_all(predicate, ele)
+
+
+def Formatting_mkComment(comment: str) -> str:
+    return "#" + comment
+
+
+def Formatting_mkKey(key: str) -> str:
+    return key + ":"
+
+
+def Formatting_mkContent(content: YAMLContent) -> str:
+    def mapping(s: str, content: Any=content) -> str:
+        return " " + Formatting_mkComment(s)
+
+    return content.Value + default_arg(map(mapping, content.Comment), "")
+
+
+def Formatting_mkInlineSequence(seq: FSharpList[YAMLElement]) -> str:
+    def mapping(x: YAMLElement, seq: Any=seq) -> str:
+        (pattern_matching_result, v) = (None, None)
+        if x.tag == 1:
+            if x.fields[0].Comment is None:
+                pattern_matching_result = 0
+                v = x.fields[0].Value
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return v
+
+        elif pattern_matching_result == 1:
+            raise Exception("Invalid sequence element")
+
+
+    return ("[" + join(", ", map_1(mapping, seq))) + "]"
+
+
+def Formatting_mkMinusLine(c: str) -> str:
+    return "- " + c
+
+
+def detokenize(ele: YAMLElement) -> PreprocessorElement:
+    def loop(ele_1: YAMLElement, ele: Any=ele) -> PreprocessorElement:
+        if ele_1.tag == 0:
+            v: YAMLElement = ele_1.fields[1]
+            key: YAMLContent = ele_1.fields[0]
+            (pattern_matching_result, v_1, seq_1, any_else) = (None, None, None, None)
+            if v.tag == 1:
+                pattern_matching_result = 0
+                v_1 = v.fields[0]
+
+            elif v.tag == 2:
+                if StyleVerifier_checkInlineSequence(v.fields[0]):
+                    pattern_matching_result = 1
+                    seq_1 = v.fields[0]
+
+                else: 
+                    pattern_matching_result = 2
+                    any_else = v
+
+
+            else: 
+                pattern_matching_result = 2
+                any_else = v
+
+            if pattern_matching_result == 0:
+                return PreprocessorElement(2, (Formatting_mkKey(key.Value) + " ") + Formatting_mkContent(v_1))
+
+            elif pattern_matching_result == 1:
+                return PreprocessorElement(2, (Formatting_mkKey(key.Value) + " ") + Formatting_mkInlineSequence(seq_1))
+
+            elif pattern_matching_result == 2:
+                return PreprocessorElement(0, of_array([PreprocessorElement(2, Formatting_mkKey(Formatting_mkContent(key))), PreprocessorElement(1, singleton(loop(any_else)))]))
+
+
+        elif ele_1.tag == 1:
+            return PreprocessorElement(2, Formatting_mkContent(ele_1.fields[0]))
+
+        elif ele_1.tag == 3:
+            def _arrow583(__unit: None=None, ele_1: Any=ele_1) -> IEnumerable_1[PreprocessorElement]:
+                return map_2(loop, ele_1.fields[0])
+
+            return PreprocessorElement(0, to_list(delay(_arrow583)))
+
+        elif ele_1.tag == 2:
+            def _arrow585(__unit: None=None, ele_1: Any=ele_1) -> IEnumerable_1[PreprocessorElement]:
+                def _arrow584(ele_3: YAMLElement) -> IEnumerable_1[PreprocessorElement]:
+                    match_value: YAMLElement = ele_3
+                    (pattern_matching_result_1, v_3, seq_5, any_else_1) = (None, None, None, None)
+                    if match_value.tag == 1:
+                        pattern_matching_result_1 = 0
+                        v_3 = match_value.fields[0]
+
+                    elif match_value.tag == 2:
+                        if StyleVerifier_checkInlineSequence(match_value.fields[0]):
+                            pattern_matching_result_1 = 1
+                            seq_5 = match_value.fields[0]
+
+                        else: 
+                            pattern_matching_result_1 = 2
+                            any_else_1 = match_value
+
+
+                    else: 
+                        pattern_matching_result_1 = 2
+                        any_else_1 = match_value
+
+                    if pattern_matching_result_1 == 0:
+                        return singleton_1(PreprocessorElement(2, Formatting_mkMinusLine(Formatting_mkContent(v_3))))
+
+                    elif pattern_matching_result_1 == 1:
+                        return singleton_1(PreprocessorElement(2, Formatting_mkMinusLine(Formatting_mkInlineSequence(seq_5))))
+
+                    elif pattern_matching_result_1 == 2:
+                        return singleton_1(PreprocessorElement(0, of_array([PreprocessorElement(2, "-"), PreprocessorElement(1, singleton(loop(any_else_1)))])))
+
+
+                return collect(_arrow584, ele_1.fields[0])
+
+            return PreprocessorElement(0, to_list(delay(_arrow585)))
+
+        elif ele_1.tag == 4:
+            return PreprocessorElement(2, Formatting_mkComment(ele_1.fields[0]))
+
+        else: 
+            return PreprocessorElement(3)
+
+
+    return loop(ele)
+
+
+def write(ele: YAMLElement, fconfig: Callable[[Config], Config] | None=None) -> str:
+    return write_1(detokenize(ele), fconfig)
+
+
+__all__ = ["StyleVerifier_checkInlineSequence", "Formatting_mkComment", "Formatting_mkKey", "Formatting_mkContent", "Formatting_mkInlineSequence", "Formatting_mkMinusLine", "detokenize", "write"]
+

arctrl/py/fable_modules/yamlicious/yamlicious_types.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+from ..fable_library.option import default_arg
+from ..fable_library.reflection import (TypeInfo, int32_type, record_type, string_type, class_type, list_type, union_type, option_type)
+from ..fable_library.string_ import initialize
+from ..fable_library.system_text import (StringBuilder__ctor, StringBuilder__AppendLine_Z721C83C5)
+from ..fable_library.types import (Record, to_string, Array, Union)
+from ..fable_library.util import (ignore, get_enumerator)
+
+def _expr567() -> TypeInfo:
+    return record_type("YAMLicious.YAMLiciousTypes.Config", [], Config, lambda: [("Whitespace", int32_type), ("Level", int32_type)])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class Config(Record):
+    Whitespace: int
+    Level: int
+
+Config_reflection = _expr567
+
+def Config_init_71136F3F(whitespace: int | None=None) -> Config:
+    return Config(default_arg(whitespace, 4), 0)
+
+
+def Config__get_WhitespaceString(this: Config) -> str:
+    def _arrow568(_arg: int, this: Any=this) -> str:
+        return " "
+
+    return initialize(this.Level * this.Whitespace, _arrow568)
+
+
+def _expr569() -> TypeInfo:
+    return record_type("YAMLicious.YAMLiciousTypes.Preprocessor", [], Preprocessor, lambda: [("AST", PreprocessorElement_reflection()), ("StringMap", class_type("System.Collections.Generic.Dictionary`2", [int32_type, string_type])), ("CommentMap", class_type("System.Collections.Generic.Dictionary`2", [int32_type, string_type]))])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class Preprocessor(Record):
+    AST: PreprocessorElement
+    StringMap: Any
+    CommentMap: Any
+
+Preprocessor_reflection = _expr569
+
+def _expr571() -> TypeInfo:
+    return union_type("YAMLicious.YAMLiciousTypes.PreprocessorElement", [], PreprocessorElement, lambda: [[("Item", list_type(PreprocessorElement_reflection()))], [("Item", list_type(PreprocessorElement_reflection()))], [("Item", string_type)], []])
+
+
+class PreprocessorElement(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Level", "Intendation", "Line", "Nil"]
+
+    def __str__(self, __unit: None=None) -> str:
+        this: PreprocessorElement = self
+        sb: Any = StringBuilder__ctor()
+        def innerprint(next_1: PreprocessorElement, level: int) -> None:
+            def _arrow570(_arg: int, next_1: Any=next_1, level: Any=level) -> str:
+                return " "
+
+            indent: str = initialize(level * 2, _arrow570)
+            if next_1.tag == 1:
+                ignore(StringBuilder__AppendLine_Z721C83C5(sb, indent + "Intendation ["))
+                with get_enumerator(next_1.fields[0]) as enumerator:
+                    while enumerator.System_Collections_IEnumerator_MoveNext():
+                        innerprint(enumerator.System_Collections_Generic_IEnumerator_1_get_Current(), level + 1)
+                ignore(StringBuilder__AppendLine_Z721C83C5(sb, indent + "]"))
+
+            elif next_1.tag == 0:
+                ignore(StringBuilder__AppendLine_Z721C83C5(sb, indent + "Level ["))
+                with get_enumerator(next_1.fields[0]) as enumerator_1:
+                    while enumerator_1.System_Collections_IEnumerator_MoveNext():
+                        innerprint(enumerator_1.System_Collections_Generic_IEnumerator_1_get_Current(), level + 1)
+                ignore(StringBuilder__AppendLine_Z721C83C5(sb, indent + "]"))
+
+            elif next_1.tag == 3:
+                pass
+
+            else: 
+                ignore(StringBuilder__AppendLine_Z721C83C5(sb, indent + (("Line \"" + next_1.fields[0]) + "\"")))
+
+
+        innerprint(this, 0)
+        return to_string(sb)
+
+
+PreprocessorElement_reflection = _expr571
+
+def _expr572() -> TypeInfo:
+    return record_type("YAMLicious.YAMLiciousTypes.YAMLContent", [], YAMLContent, lambda: [("Value", string_type), ("Comment", option_type(string_type))])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class YAMLContent(Record):
+    Value: str
+    Comment: str | None
+
+YAMLContent_reflection = _expr572
+
+def YAMLContent_create_27AED5E3(value: str, comment: str | None=None) -> YAMLContent:
+    return YAMLContent(value, comment)
+
+
+def _expr573() -> TypeInfo:
+    return union_type("YAMLicious.YAMLiciousTypes.YAMLElement", [], YAMLElement, lambda: [[("Item1", YAMLContent_reflection()), ("Item2", YAMLElement_reflection())], [("Item", YAMLContent_reflection())], [("Item", list_type(YAMLElement_reflection()))], [("Item", list_type(YAMLElement_reflection()))], [("Item", string_type)], []])
+
+
+class YAMLElement(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Mapping", "Value", "Sequence", "Object", "Comment", "Nil"]
+
+
+YAMLElement_reflection = _expr573
+
+__all__ = ["Config_reflection", "Config_init_71136F3F", "Config__get_WhitespaceString", "Preprocessor_reflection", "PreprocessorElement_reflection", "YAMLContent_reflection", "YAMLContent_create_27AED5E3", "YAMLElement_reflection"]
+