arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/ValidationPackages/validation_packages_config.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_modules.fable_library.array_ import sort_by
+from ..fable_modules.fable_library.option import value
+from ..fable_modules.fable_library.range import range_big_int
+from ..fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..fable_modules.fable_library.seq import (to_list, delay, append, singleton, empty, map, length, fold, item)
+from ..fable_modules.fable_library.string_ import join
+from ..fable_modules.fable_library.types import (Array, to_string)
+from ..fable_modules.fable_library.util import (IEnumerable_1, compare_arrays, equals)
+from ..Core.Helper.hash_codes import (box_hash_array, box_hash_option, box_hash_seq)
+from .validation_package import ValidationPackage
+
+def _expr3327() -> TypeInfo:
+    return class_type("ARCtrl.ValidationPackages.ValidationPackagesConfig", None, ValidationPackagesConfig)
+
+
+class ValidationPackagesConfig:
+    def __init__(self, validation_packages: Array[ValidationPackage], arc_specification: str | None=None) -> None:
+        self._arc_specification: str | None = arc_specification
+        self._validation_packages: Array[ValidationPackage] = validation_packages
+
+    @property
+    def ValidationPackages(self, __unit: None=None) -> Array[ValidationPackage]:
+        this: ValidationPackagesConfig = self
+        return this._validation_packages
+
+    @ValidationPackages.setter
+    def ValidationPackages(self, validation_packages: Array[ValidationPackage]) -> None:
+        this: ValidationPackagesConfig = self
+        this._validation_packages = validation_packages
+
+    @property
+    def ARCSpecification(self, __unit: None=None) -> str | None:
+        this: ValidationPackagesConfig = self
+        return this._arc_specification
+
+    @ARCSpecification.setter
+    def ARCSpecification(self, arc_specification: str | None=None) -> None:
+        this: ValidationPackagesConfig = self
+        this._arc_specification = arc_specification
+
+    @staticmethod
+    def make(validation_packages: Array[ValidationPackage], arc_specification: str | None=None) -> ValidationPackagesConfig:
+        return ValidationPackagesConfig(validation_packages, arc_specification)
+
+    def Copy(self, __unit: None=None) -> ValidationPackagesConfig:
+        this: ValidationPackagesConfig = self
+        validation_packages: Array[ValidationPackage] = this.ValidationPackages
+        arc_specification: str | None = this.ARCSpecification
+        return ValidationPackagesConfig.make(validation_packages, arc_specification)
+
+    def __str__(self, __unit: None=None) -> str:
+        this: ValidationPackagesConfig = self
+        def _arrow3323(__unit: None=None) -> IEnumerable_1[str]:
+            def _arrow3322(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow3321(__unit: None=None) -> IEnumerable_1[str]:
+                    def _arrow3320(__unit: None=None) -> IEnumerable_1[str]:
+                        def _arrow3319(__unit: None=None) -> IEnumerable_1[str]:
+                            def _arrow3318(__unit: None=None) -> IEnumerable_1[str]:
+                                return singleton("}")
+
+                            return append(singleton("]"), delay(_arrow3318))
+
+                        return append(singleton(join((";" + "\n") + "", map(to_string, this.ValidationPackages))), delay(_arrow3319))
+
+                    return append(singleton(" ValidationPackages = ["), delay(_arrow3320))
+
+                return append(singleton((" ARCSpecification = " + value(this.ARCSpecification)) + "") if (this.ARCSpecification is not None) else empty(), delay(_arrow3321))
+
+            return append(singleton("{"), delay(_arrow3322))
+
+        return join("\n", to_list(delay(_arrow3323)))
+
+    def StructurallyEquals(self, other: ValidationPackagesConfig) -> bool:
+        this: ValidationPackagesConfig = self
+        def sort(arg: Array[ValidationPackage]) -> Array[ValidationPackage]:
+            def projection(vp: ValidationPackage, arg: Any=arg) -> tuple[str, str | None]:
+                return (vp.Name, vp.Version)
+
+            class ObjectExpr3324:
+                @property
+                def Compare(self) -> Callable[[tuple[str, str | None], tuple[str, str | None]], int]:
+                    return compare_arrays
+
+            return sort_by(projection, list(arg), ObjectExpr3324())
+
+        if equals(this.ARCSpecification, other.ARCSpecification):
+            a: IEnumerable_1[ValidationPackage] = sort(this.ValidationPackages)
+            b: IEnumerable_1[ValidationPackage] = sort(other.ValidationPackages)
+            def folder(acc: bool, e: bool) -> bool:
+                if acc:
+                    return e
+
+                else: 
+                    return False
+
+
+            def _arrow3326(__unit: None=None) -> IEnumerable_1[bool]:
+                def _arrow3325(i: int) -> bool:
+                    return equals(item(i, a), item(i, b))
+
+                return map(_arrow3325, range_big_int(0, 1, length(a) - 1))
+
+            return fold(folder, True, to_list(delay(_arrow3326))) if (length(a) == length(b)) else False
+
+        else: 
+            return False
+
+
+    def ReferenceEquals(self, other: ValidationPackagesConfig) -> bool:
+        this: ValidationPackagesConfig = self
+        return this is other
+
+    def __eq__(self, other: Any=None) -> bool:
+        this: ValidationPackagesConfig = self
+        return this.StructurallyEquals(other) if isinstance(other, ValidationPackagesConfig) else False
+
+    def __hash__(self, __unit: None=None) -> Any:
+        this: ValidationPackagesConfig = self
+        return box_hash_array([box_hash_option(this.ARCSpecification), box_hash_seq(this.ValidationPackages)])
+
+
+ValidationPackagesConfig_reflection = _expr3327
+
+def ValidationPackagesConfig__ctor_376974AD(validation_packages: Array[ValidationPackage], arc_specification: str | None=None) -> ValidationPackagesConfig:
+    return ValidationPackagesConfig(validation_packages, arc_specification)
+
+
+__all__ = ["ValidationPackagesConfig_reflection"]
+

arctrl/py/WebRequest/web_request.py

@@ -0,0 +1,9 @@
+from ..fable_modules.fable_library.async_builder import Async
+from .web_request_py import download_file as download_file_1
+
+def download_file(url: str) -> Async[str]:
+    return download_file_1(url)
+
+
+__all__ = ["download_file"]
+

arctrl/py/WebRequest/web_request_py.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+from abc import abstractmethod
+from collections.abc import Callable
+from dataclasses import dataclass
+import requests
+from typing import (Any, Protocol)
+from ..fable_modules.fable_library.async_builder import (singleton as singleton_1, Async)
+from ..fable_modules.fable_library.map import of_list
+from ..fable_modules.fable_library.option import map
+from ..fable_modules.fable_library.reflection import (TypeInfo, int32_type, string_type, class_type, record_type)
+from ..fable_modules.fable_library.seq import (to_list, delay, map as map_1, collect, singleton)
+from ..fable_modules.fable_library.types import Record
+from ..fable_modules.fable_library.util import (create_obj, IEnumerable_1, compare_primitives)
+
+class InteropResponseType(Protocol):
+    @property
+    @abstractmethod
+    def encoding(self) -> str:
+        ...
+
+    @property
+    @abstractmethod
+    def headers(self) -> Any:
+        ...
+
+    @property
+    @abstractmethod
+    def status_code(self) -> int:
+        ...
+
+    @property
+    @abstractmethod
+    def text(self) -> str:
+        ...
+
+
+def _expr3610() -> TypeInfo:
+    return record_type("ARCtrl.WebRequestHelpers.Py.Response", [], Response, lambda: [("status_code", int32_type), ("text", string_type), ("headers", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, string_type])), ("encoding", string_type)])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class Response(Record):
+    status_code: int
+    text: str
+    headers: Any
+    encoding: str
+
+Response_reflection = _expr3610
+
+def _expr3611() -> TypeInfo:
+    return class_type("ARCtrl.WebRequestHelpers.Py.Requests", None, Requests)
+
+
+class Requests:
+    def __init__(self, __unit: None=None) -> None:
+        pass
+
+
+Requests_reflection = _expr3611
+
+def Requests__ctor(__unit: None=None) -> Requests:
+    return Requests(__unit)
+
+
+def Requests_createHeadersDict_9F3777D(headers: Any | None=None) -> Any | None:
+    def mapping(values: Any, headers: Any=headers) -> Any:
+        def _arrow3613(__unit: None=None, values: Any=values) -> IEnumerable_1[tuple[str, Any]]:
+            def _arrow3612(pair: Any) -> tuple[str, Any]:
+                return (pair[0], pair[1])
+
+            return map_1(_arrow3612, values)
+
+        return create_obj(to_list(delay(_arrow3613)))
+
+    return map(mapping, headers)
+
+
+def Requests_mapResponseType_Z730CA7D4(response: InteropResponseType) -> Response:
+    status_code: int = response.status_code or 0
+    text: str = response.text
+    encoding: str = response.text
+    def _arrow3615(__unit: None=None, response: Any=response) -> IEnumerable_1[tuple[str, str]]:
+        def _arrow3614(header_name: str) -> IEnumerable_1[tuple[str, str]]:
+            return singleton((header_name, response.headers[header_name]))
+
+        return collect(_arrow3614, list(response.headers.keys()))
+
+    class ObjectExpr3616:
+        @property
+        def Compare(self) -> Callable[[str, str], int]:
+            return compare_primitives
+
+    return Response(status_code, text, of_list(to_list(delay(_arrow3615)), ObjectExpr3616()), encoding)
+
+
+def Requests_get_43A074E6(url: str, headers: Any | None=None) -> Response:
+    headers_dict: Any | None = Requests_createHeadersDict_9F3777D(headers)
+    return Requests_mapResponseType_Z730CA7D4(requests.get(url, headers=headers_dict))
+
+
+def Requests_post_147AE53E(url: str, data: str | None=None, headers: Any | None=None) -> Response:
+    headers_dict: Any | None = Requests_createHeadersDict_9F3777D(headers)
+    return Requests_mapResponseType_Z730CA7D4(requests.post(url, data=data, headers=headers_dict))
+
+
+def Requests_put_147AE53E(url: str, data: str | None=None, headers: Any | None=None) -> Response:
+    headers_dict: Any | None = Requests_createHeadersDict_9F3777D(headers)
+    return Requests_mapResponseType_Z730CA7D4(requests.put(url, data=data, headers=headers_dict))
+
+
+def Requests_delete_147AE53E(url: str, data: str | None=None, headers: Any | None=None) -> Response:
+    headers_dict: Any | None = Requests_createHeadersDict_9F3777D(headers)
+    return Requests_mapResponseType_Z730CA7D4(requests.delete(url, data=data, headers=headers_dict))
+
+
+def Requests_head_147AE53E(url: str, data: str | None=None, headers: Any | None=None) -> Response:
+    headers_dict: Any | None = Requests_createHeadersDict_9F3777D(headers)
+    return Requests_mapResponseType_Z730CA7D4(requests.head(url, data=data, headers=headers_dict))
+
+
+def Requests_options_147AE53E(url: str, data: str | None=None, headers: Any | None=None) -> Response:
+    headers_dict: Any | None = Requests_createHeadersDict_9F3777D(headers)
+    return Requests_mapResponseType_Z730CA7D4(requests.head(url, data=data, headers=headers_dict))
+
+
+def download_file(url: str) -> Async[str]:
+    def _arrow3617(__unit: None=None, url: Any=url) -> Async[str]:
+        response: Response = Requests_get_43A074E6(url)
+        return singleton_1.Return(response.text)
+
+    return singleton_1.Delay(_arrow3617)
+
+
+__all__ = ["Response_reflection", "Requests_reflection", "Requests_createHeadersDict_9F3777D", "Requests_mapResponseType_Z730CA7D4", "Requests_get_43A074E6", "Requests_post_147AE53E", "Requests_put_147AE53E", "Requests_delete_147AE53E", "Requests_head_147AE53E", "Requests_options_147AE53E", "download_file"]
+

arctrl/py/Yaml/decode.py

@@ -0,0 +1 @@
+

arctrl/py/Yaml/encode.py

@@ -0,0 +1,10 @@
+from ..fable_modules.fable_library.option import default_arg
+
+DefaultWhitespace: int = 2
+
+def default_whitespace(spaces: int | None=None) -> int:
+    return default_arg(spaces, DefaultWhitespace)
+
+
+__all__ = ["DefaultWhitespace", "default_whitespace"]
+

arctrl/py/Yaml/validation_package.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_modules.fable_library.list import (choose, of_array, FSharpList)
+from ..fable_modules.fable_library.seq import (to_list, delay, collect, singleton)
+from ..fable_modules.fable_library.util import (equals, IEnumerable_1)
+from ..fable_modules.yamlicious.yamlicious_types import YAMLContent_create_27AED5E3
+from ..fable_modules.yamlicious.decode import (object, IRequiredGetter, string as string_1, IOptionalGetter, IGetters)
+from ..fable_modules.yamlicious.encode import (string, try_include)
+from ..fable_modules.yamlicious.reader import read
+from ..fable_modules.yamlicious.writer import write
+from ..fable_modules.yamlicious.yamlicious_types import (YAMLElement, Config)
+from ..ValidationPackages.validation_package import ValidationPackage
+from .encode import default_whitespace
+
+def ValidationPackage_encoder(validationpackage: ValidationPackage) -> YAMLElement:
+    def chooser(tupled_arg: tuple[str, YAMLElement], validationpackage: Any=validationpackage) -> tuple[str, YAMLElement] | None:
+        v: YAMLElement = tupled_arg[1]
+        if equals(v, YAMLElement(5)):
+            return None
+
+        else: 
+            return (tupled_arg[0], v)
+
+
+    def _arrow3328(value: str, validationpackage: Any=validationpackage) -> YAMLElement:
+        return string(value)
+
+    obj_seq: FSharpList[tuple[str, YAMLElement]] = choose(chooser, of_array([("name", string(validationpackage.Name)), try_include("version", _arrow3328, validationpackage.Version)]))
+    def _arrow3330(__unit: None=None, validationpackage: Any=validationpackage) -> IEnumerable_1[YAMLElement]:
+        def _arrow3329(match_value: tuple[str, YAMLElement]) -> IEnumerable_1[YAMLElement]:
+            return singleton(YAMLElement(0, YAMLContent_create_27AED5E3(match_value[0]), match_value[1]))
+
+        return collect(_arrow3329, obj_seq)
+
+    return YAMLElement(3, to_list(delay(_arrow3330)))
+
+
+def _arrow3333(value_2: YAMLElement) -> ValidationPackage:
+    def getter(get: IGetters) -> ValidationPackage:
+        def _arrow3331(__unit: None=None, get: Any=get) -> str:
+            object_arg: IRequiredGetter = get.Required
+            return object_arg.Field("name", string_1)
+
+        def _arrow3332(__unit: None=None, get: Any=get) -> str | None:
+            object_arg_1: IOptionalGetter = get.Optional
+            return object_arg_1.Field("version", string_1)
+
+        return ValidationPackage(_arrow3331(), _arrow3332())
+
+    return object(getter, value_2)
+
+
+ValidationPackage_decoder: Callable[[YAMLElement], ValidationPackage] = _arrow3333
+
+def ARCtrl_ValidationPackages_ValidationPackage__ValidationPackage_fromYamlString_Static_Z721C83C5(s: str) -> ValidationPackage:
+    return ValidationPackage_decoder(read(s))
+
+
+def ARCtrl_ValidationPackages_ValidationPackage__ValidationPackage_toYamlString_Static_71136F3F(whitespace: int | None=None) -> Callable[[ValidationPackage], str]:
+    def _arrow3335(vp: ValidationPackage, whitespace: Any=whitespace) -> str:
+        element: YAMLElement = ValidationPackage_encoder(vp)
+        whitespace_1: int = default_whitespace(whitespace) or 0
+        def _arrow3334(c: Config) -> Config:
+            return Config(whitespace_1, c.Level)
+
+        return write(element, _arrow3334)
+
+    return _arrow3335
+
+
+def ARCtrl_ValidationPackages_ValidationPackage__ValidationPackage_toYamlString_71136F3F(this: ValidationPackage, whitespace: int | None=None) -> str:
+    return ARCtrl_ValidationPackages_ValidationPackage__ValidationPackage_toYamlString_Static_71136F3F(whitespace)(this)
+
+
+__all__ = ["ValidationPackage_encoder", "ValidationPackage_decoder", "ARCtrl_ValidationPackages_ValidationPackage__ValidationPackage_fromYamlString_Static_Z721C83C5", "ARCtrl_ValidationPackages_ValidationPackage__ValidationPackage_toYamlString_Static_71136F3F", "ARCtrl_ValidationPackages_ValidationPackage__ValidationPackage_toYamlString_71136F3F"]
+

arctrl/py/Yaml/validation_packages_config.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_modules.fable_library.list import (choose, of_array, FSharpList)
+from ..fable_modules.fable_library.seq import (to_list, delay, collect, singleton)
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import (equals, IEnumerable_1)
+from ..fable_modules.yamlicious.yamlicious_types import YAMLContent_create_27AED5E3
+from ..fable_modules.yamlicious.decode import (object, IRequiredGetter, resizearray as resizearray_1, IOptionalGetter, string as string_1, IGetters)
+from ..fable_modules.yamlicious.encode import (try_include, string, resizearray)
+from ..fable_modules.yamlicious.reader import read
+from ..fable_modules.yamlicious.writer import write
+from ..fable_modules.yamlicious.yamlicious_types import (YAMLElement, Config)
+from ..ValidationPackages.validation_package import ValidationPackage
+from ..ValidationPackages.validation_packages_config import ValidationPackagesConfig
+from .encode import default_whitespace
+from .validation_package import (ValidationPackage_encoder, ValidationPackage_decoder)
+
+def ValidationPackagesConfig_encoder(validationpackage: ValidationPackagesConfig) -> YAMLElement:
+    def chooser(tupled_arg: tuple[str, YAMLElement], validationpackage: Any=validationpackage) -> tuple[str, YAMLElement] | None:
+        v: YAMLElement = tupled_arg[1]
+        if equals(v, YAMLElement(5)):
+            return None
+
+        else: 
+            return (tupled_arg[0], v)
+
+
+    def _arrow3337(value: str, validationpackage: Any=validationpackage) -> YAMLElement:
+        return string(value)
+
+    def _arrow3338(validationpackage_1: ValidationPackage, validationpackage: Any=validationpackage) -> YAMLElement:
+        return ValidationPackage_encoder(validationpackage_1)
+
+    obj_seq: FSharpList[tuple[str, YAMLElement]] = choose(chooser, of_array([try_include("arc_specification", _arrow3337, validationpackage.ARCSpecification), ("validation_packages", resizearray(_arrow3338, validationpackage.ValidationPackages))]))
+    def _arrow3340(__unit: None=None, validationpackage: Any=validationpackage) -> IEnumerable_1[YAMLElement]:
+        def _arrow3339(match_value: tuple[str, YAMLElement]) -> IEnumerable_1[YAMLElement]:
+            return singleton(YAMLElement(0, YAMLContent_create_27AED5E3(match_value[0]), match_value[1]))
+
+        return collect(_arrow3339, obj_seq)
+
+    return YAMLElement(3, to_list(delay(_arrow3340)))
+
+
+def _arrow3343(value_2: YAMLElement) -> ValidationPackagesConfig:
+    def getter(get: IGetters) -> ValidationPackagesConfig:
+        def _arrow3341(__unit: None=None, get: Any=get) -> Array[ValidationPackage]:
+            object_arg: IRequiredGetter = get.Required
+            def arg_1(value: YAMLElement) -> Array[ValidationPackage]:
+                return resizearray_1(ValidationPackage_decoder, value)
+
+            return object_arg.Field("validation_packages", arg_1)
+
+        def _arrow3342(__unit: None=None, get: Any=get) -> str | None:
+            object_arg_1: IOptionalGetter = get.Optional
+            return object_arg_1.Field("arc_specification", string_1)
+
+        return ValidationPackagesConfig(_arrow3341(), _arrow3342())
+
+    return object(getter, value_2)
+
+
+ValidationPackagesConfig_decoder: Callable[[YAMLElement], ValidationPackagesConfig] = _arrow3343
+
+def ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_fromYamlString_Static_Z721C83C5(s: str) -> ValidationPackagesConfig:
+    return ValidationPackagesConfig_decoder(read(s))
+
+
+def ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toYamlString_Static_71136F3F(whitespace: int | None=None) -> Callable[[ValidationPackagesConfig], str]:
+    def _arrow3345(vp: ValidationPackagesConfig, whitespace: Any=whitespace) -> str:
+        element: YAMLElement = ValidationPackagesConfig_encoder(vp)
+        whitespace_1: int = default_whitespace(whitespace) or 0
+        def _arrow3344(c: Config) -> Config:
+            return Config(whitespace_1, c.Level)
+
+        return write(element, _arrow3344)
+
+    return _arrow3345
+
+
+def ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toYamlString_71136F3F(this: ValidationPackagesConfig, whitespace: int | None=None) -> str:
+    return ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toYamlString_Static_71136F3F(whitespace)(this)
+
+
+__all__ = ["ValidationPackagesConfig_encoder", "ValidationPackagesConfig_decoder", "ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_fromYamlString_Static_Z721C83C5", "ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toYamlString_Static_71136F3F", "ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toYamlString_71136F3F"]
+