arctrl 3.0.0__py3-none-any.whl

arctrl/py/Core/template.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+from typing import Any
+from ..fable_modules.fable_library.date import now
+from ..fable_modules.fable_library.guid import new_guid
+from ..fable_modules.fable_library.option import default_arg
+from ..fable_modules.fable_library.reflection import (TypeInfo, string_type, union_type, class_type)
+from ..fable_modules.fable_library.types import (Array, Union)
+from ..fable_modules.fable_library.util import (equals, safe_hash)
+from .Helper.collections_ import ResizeArray_map
+from .Helper.hash_codes import (box_hash_array, box_hash_seq, hash_date_time)
+from .Helper.sem_ver import (SemVer_tryOfString_Z721C83C5, SemVer)
+from .ontology_annotation import OntologyAnnotation
+from .person import Person
+from .Table.arc_table import ArcTable
+
+def _expr1301() -> TypeInfo:
+    return union_type("ARCtrl.Organisation", [], Organisation, lambda: [[], [("Item", string_type)]])
+
+
+class Organisation(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 ["DataPLANT", "Other"]
+
+    @staticmethod
+    def of_string(str_1: str) -> Organisation:
+        return Organisation(0) if (str_1.lower() == "dataplant") else Organisation(1, str_1)
+
+    def __str__(self, __unit: None=None) -> str:
+        this: Organisation = self
+        return this.fields[0] if (this.tag == 1) else "DataPLANT"
+
+    def IsOfficial(self, __unit: None=None) -> bool:
+        this: Organisation = self
+        return equals(this, Organisation(0))
+
+
+Organisation_reflection = _expr1301
+
+def _expr1303() -> TypeInfo:
+    return class_type("ARCtrl.Template", None, Template)
+
+
+class Template:
+    def __init__(self, id: str, table: ArcTable, name: str | None=None, description: str | None=None, organisation: Organisation | None=None, version: str | None=None, authors: Array[Person] | None=None, repos: Array[OntologyAnnotation] | None=None, tags: Array[OntologyAnnotation] | None=None, last_updated: Any | None=None) -> None:
+        name_1: str = default_arg(name, "")
+        description_1: str = default_arg(description, "")
+        organisation_1: Organisation = default_arg(organisation, Organisation(1, "Custom Organisation"))
+        version_1: str = default_arg(version, "0.0.0")
+        authors_1: Array[Person] = default_arg(authors, [])
+        repos_1: Array[OntologyAnnotation] = default_arg(repos, [])
+        tags_1: Array[OntologyAnnotation] = default_arg(tags, [])
+        last_updated_1: Any = default_arg(last_updated, now())
+        self._Id: str = id
+        self._Table: ArcTable = table
+        self._Name: str = name_1
+        self._Description: str = description_1
+        self._Organisation: Organisation = organisation_1
+        self._Version: str = version_1
+        self._Authors: Array[Person] = authors_1
+        self._EndpointRepositories: Array[OntologyAnnotation] = repos_1
+        self._Tags: Array[OntologyAnnotation] = tags_1
+        self._LastUpdated: Any = last_updated_1
+
+    @property
+    def Id(self, __unit: None=None) -> str:
+        __: Template = self
+        return __._Id
+
+    @Id.setter
+    def Id(self, v: str) -> None:
+        __: Template = self
+        __._Id = v
+
+    @property
+    def Table(self, __unit: None=None) -> ArcTable:
+        __: Template = self
+        return __._Table
+
+    @Table.setter
+    def Table(self, v: ArcTable) -> None:
+        __: Template = self
+        __._Table = v
+
+    @property
+    def Name(self, __unit: None=None) -> str:
+        __: Template = self
+        return __._Name
+
+    @Name.setter
+    def Name(self, v: str) -> None:
+        __: Template = self
+        __._Name = v
+
+    @property
+    def Description(self, __unit: None=None) -> str:
+        __: Template = self
+        return __._Description
+
+    @Description.setter
+    def Description(self, v: str) -> None:
+        __: Template = self
+        __._Description = v
+
+    @property
+    def Organisation(self, __unit: None=None) -> Organisation:
+        __: Template = self
+        return __._Organisation
+
+    @Organisation.setter
+    def Organisation(self, v: Organisation) -> None:
+        __: Template = self
+        __._Organisation = v
+
+    @property
+    def Version(self, __unit: None=None) -> str:
+        __: Template = self
+        return __._Version
+
+    @Version.setter
+    def Version(self, v: str) -> None:
+        __: Template = self
+        __._Version = v
+
+    @property
+    def Authors(self, __unit: None=None) -> Array[Person]:
+        __: Template = self
+        return __._Authors
+
+    @Authors.setter
+    def Authors(self, v: Array[Person]) -> None:
+        __: Template = self
+        __._Authors = v
+
+    @property
+    def EndpointRepositories(self, __unit: None=None) -> Array[OntologyAnnotation]:
+        __: Template = self
+        return __._EndpointRepositories
+
+    @EndpointRepositories.setter
+    def EndpointRepositories(self, v: Array[OntologyAnnotation]) -> None:
+        __: Template = self
+        __._EndpointRepositories = v
+
+    @property
+    def Tags(self, __unit: None=None) -> Array[OntologyAnnotation]:
+        __: Template = self
+        return __._Tags
+
+    @Tags.setter
+    def Tags(self, v: Array[OntologyAnnotation]) -> None:
+        __: Template = self
+        __._Tags = v
+
+    @property
+    def LastUpdated(self, __unit: None=None) -> Any:
+        __: Template = self
+        return __._LastUpdated
+
+    @LastUpdated.setter
+    def LastUpdated(self, v: Any) -> None:
+        __: Template = self
+        __._LastUpdated = v
+
+    @staticmethod
+    def make(id: str, table: ArcTable, name: str, description: str, organisation: Organisation, version: str, authors: Array[Person], repos: Array[OntologyAnnotation], tags: Array[OntologyAnnotation], last_updated: Any) -> Template:
+        return Template(id, table, name, description, organisation, version, authors, repos, tags, last_updated)
+
+    @staticmethod
+    def create(id: str, table: ArcTable, name: str | None=None, description: str | None=None, organisation: Organisation | None=None, version: str | None=None, authors: Array[Person] | None=None, repos: Array[OntologyAnnotation] | None=None, tags: Array[OntologyAnnotation] | None=None, last_updated: Any | None=None) -> Template:
+        return Template(id, table, name, description, organisation, version, authors, repos, tags, last_updated)
+
+    @staticmethod
+    def init(template_name: str) -> Template:
+        return Template(new_guid(), ArcTable.init(template_name), template_name)
+
+    @property
+    def SemVer(self, __unit: None=None) -> SemVer | None:
+        this: Template = self
+        return SemVer_tryOfString_Z721C83C5(this.Version)
+
+    def ReferenceEquals(self, other: Template) -> bool:
+        this: Template = self
+        return this is other
+
+    def StructurallyEquals(self, other: Template) -> bool:
+        this: Template = self
+        return safe_hash(this) == safe_hash(other)
+
+    def Copy(self, __unit: None=None) -> Template:
+        this: Template = self
+        def f(c: Person) -> Person:
+            return c.Copy()
+
+        next_authors: Array[Person] = ResizeArray_map(f, this.Authors)
+        def f_1(c_1: OntologyAnnotation) -> OntologyAnnotation:
+            return c_1.Copy()
+
+        next_repos: Array[OntologyAnnotation] = ResizeArray_map(f_1, this.EndpointRepositories)
+        def f_2(c_2: OntologyAnnotation) -> OntologyAnnotation:
+            return c_2.Copy()
+
+        next_tags: Array[OntologyAnnotation] = ResizeArray_map(f_2, this.Tags)
+        return Template.create(this.Id, this.Table.Copy(), this.Name, this.Description, this.Organisation, this.Version, next_authors, next_repos, next_tags, this.LastUpdated)
+
+    def __eq__(self, other: Any=None) -> bool:
+        this: Template = self
+        return this.StructurallyEquals(other) if isinstance(other, Template) else False
+
+    def __hash__(self, __unit: None=None) -> Any:
+        this: Template = self
+        def _arrow1302(__unit: None=None) -> str:
+            copy_of_struct: str = this.Id
+            return str(copy_of_struct)
+
+        return box_hash_array([_arrow1302(), safe_hash(this.Table), this.Name, safe_hash(this.Organisation), this.Version, box_hash_seq(this.Authors), box_hash_seq(this.EndpointRepositories), box_hash_seq(this.Tags), hash_date_time(this.LastUpdated)])
+
+
+Template_reflection = _expr1303
+
+def Template__ctor_Z17EA765C(id: str, table: ArcTable, name: str | None=None, description: str | None=None, organisation: Organisation | None=None, version: str | None=None, authors: Array[Person] | None=None, repos: Array[OntologyAnnotation] | None=None, tags: Array[OntologyAnnotation] | None=None, last_updated: Any | None=None) -> Template:
+    return Template(id, table, name, description, organisation, version, authors, repos, tags, last_updated)
+
+
+__all__ = ["Organisation_reflection", "Template_reflection"]
+

arctrl/py/Core/templates.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_modules.fable_library.array_ import add_range_in_place
+from ..fable_modules.fable_library.option import default_arg
+from ..fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..fable_modules.fable_library.seq import contains as contains_1
+from ..fable_modules.fable_library.seq2 import Array_distinct
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import (get_enumerator, dispose, equals, safe_hash, uncurry2)
+from .Helper.collections_ import (ResizeArray_filter, ResizeArray_distinct, ResizeArray_collect, ResizeArray_append)
+from .ontology_annotation import OntologyAnnotation
+from .template import Template
+
+def TemplatesAux_getComparer(match_all: bool | None=None) -> Callable[[bool, bool], bool]:
+    if default_arg(match_all, False):
+        def _arrow1305(e: bool, match_all: Any=match_all) -> Callable[[bool], bool]:
+            def _arrow1304(e_1: bool) -> bool:
+                return e and e_1
+
+            return _arrow1304
+
+        return _arrow1305
+
+    else: 
+        def _arrow1307(e_2: bool, match_all: Any=match_all) -> Callable[[bool], bool]:
+            def _arrow1306(e_3: bool) -> bool:
+                return e_2 or e_3
+
+            return _arrow1306
+
+        return _arrow1307
+
+
+
+def TemplatesAux_filterOnTags(tag_getter: Callable[[Template], Array[OntologyAnnotation]], query_tags: Array[OntologyAnnotation], comparer: Callable[[bool, bool], bool], templates: Array[Template]) -> Array[Template]:
+    def f(t: Template, tag_getter: Any=tag_getter, query_tags: Any=query_tags, comparer: Any=comparer, templates: Any=templates) -> bool:
+        template_tags: Array[OntologyAnnotation] = tag_getter(t)
+        is_valid: bool | None = None
+        enumerator: Any = get_enumerator(query_tags)
+        try: 
+            while enumerator.System_Collections_IEnumerator_MoveNext():
+                class ObjectExpr1308:
+                    @property
+                    def Equals(self) -> Callable[[OntologyAnnotation, OntologyAnnotation], bool]:
+                        return equals
+
+                    @property
+                    def GetHashCode(self) -> Callable[[OntologyAnnotation], int]:
+                        return safe_hash
+
+                contains: bool = contains_1(enumerator.System_Collections_Generic_IEnumerator_1_get_Current(), template_tags, ObjectExpr1308())
+                is_valid_1: bool | None = is_valid
+                if is_valid_1 is not None:
+                    maybe: bool = is_valid_1
+                    is_valid = comparer(maybe, contains)
+
+                else: 
+                    is_valid = contains
+
+
+        finally: 
+            dispose(enumerator)
+
+        return default_arg(is_valid, False)
+
+    return ResizeArray_filter(f, templates)
+
+
+def _expr1316() -> TypeInfo:
+    return class_type("ARCtrl.Templates", None, Templates)
+
+
+class Templates:
+    @staticmethod
+    def get_distinct_tags(templates: Array[Template]) -> Array[OntologyAnnotation]:
+        def f(t: Template) -> Array[OntologyAnnotation]:
+            return t.Tags
+
+        return ResizeArray_distinct(ResizeArray_collect(f, templates))
+
+    @staticmethod
+    def get_distinct_endpoint_repositories(templates: Array[Template]) -> Array[OntologyAnnotation]:
+        def f(t: Template) -> Array[OntologyAnnotation]:
+            return t.EndpointRepositories
+
+        return ResizeArray_distinct(ResizeArray_collect(f, templates))
+
+    @staticmethod
+    def get_distinct_ontology_annotations(templates: Array[Template]) -> Array[OntologyAnnotation]:
+        oas: Array[OntologyAnnotation] = []
+        for idx in range(0, (len(templates) - 1) + 1, 1):
+            t: Template = templates[idx]
+            add_range_in_place(t.Tags, oas)
+            add_range_in_place(t.EndpointRepositories, oas)
+        class ObjectExpr1309:
+            @property
+            def Equals(self) -> Callable[[OntologyAnnotation, OntologyAnnotation], bool]:
+                return equals
+
+            @property
+            def GetHashCode(self) -> Callable[[OntologyAnnotation], int]:
+                return safe_hash
+
+        return Array_distinct(list(oas), ObjectExpr1309())
+
+    @staticmethod
+    def filter_by_tags(query_tags: Array[OntologyAnnotation], match_all: bool | None=None) -> Callable[[Array[Template]], Array[Template]]:
+        def _arrow1311(templates: Array[Template]) -> Array[Template]:
+            def _arrow1310(t: Template) -> Array[OntologyAnnotation]:
+                return t.Tags
+
+            return TemplatesAux_filterOnTags(_arrow1310, query_tags, uncurry2(TemplatesAux_getComparer(match_all)), templates)
+
+        return _arrow1311
+
+    @staticmethod
+    def filter_by_endpoint_repositories(query_tags: Array[OntologyAnnotation], match_all: bool | None=None) -> Callable[[Array[Template]], Array[Template]]:
+        def _arrow1313(templates: Array[Template]) -> Array[Template]:
+            def _arrow1312(t: Template) -> Array[OntologyAnnotation]:
+                return t.EndpointRepositories
+
+            return TemplatesAux_filterOnTags(_arrow1312, query_tags, uncurry2(TemplatesAux_getComparer(match_all)), templates)
+
+        return _arrow1313
+
+    @staticmethod
+    def filter_by_ontology_annotation(query_tags: Array[OntologyAnnotation], match_all: bool | None=None) -> Callable[[Array[Template]], Array[Template]]:
+        def _arrow1315(templates: Array[Template]) -> Array[Template]:
+            def _arrow1314(t: Template) -> Array[OntologyAnnotation]:
+                return ResizeArray_append(t.Tags, t.EndpointRepositories)
+
+            return TemplatesAux_filterOnTags(_arrow1314, query_tags, uncurry2(TemplatesAux_getComparer(match_all)), templates)
+
+        return _arrow1315
+
+    @staticmethod
+    def filter_by_data_plant(templates: Array[Template]) -> Array[Template]:
+        def f(t: Template) -> bool:
+            return t.Organisation.IsOfficial()
+
+        return ResizeArray_filter(f, templates)
+
+
+Templates_reflection = _expr1316
+
+__all__ = ["TemplatesAux_getComparer", "TemplatesAux_filterOnTags", "Templates_reflection"]
+

arctrl/py/Core/uri.py

@@ -0,0 +1,11 @@
+
+def URIModule_fromString(s: str) -> str:
+    return s
+
+
+def URIModule_toString(s: str) -> str:
+    return s
+
+
+__all__ = ["URIModule_fromString", "URIModule_toString"]
+

arctrl/py/Core/value.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+from typing import Any
+from ..fable_modules.fable_library.double import try_parse as try_parse_1
+from ..fable_modules.fable_library.int32 import try_parse
+from ..fable_modules.fable_library.option import default_arg
+from ..fable_modules.fable_library.reflection import (TypeInfo, int32_type, float64_type, string_type, union_type)
+from ..fable_modules.fable_library.string_ import (to_text, printf)
+from ..fable_modules.fable_library.types import (FSharpRef, to_string, Array, Union)
+from ..fable_modules.fable_library.util import int32_to_string
+from .ontology_annotation import (OntologyAnnotation, OntologyAnnotation_reflection)
+
+def _expr983() -> TypeInfo:
+    return union_type("ARCtrl.Value", [], Value, lambda: [[("Item", OntologyAnnotation_reflection())], [("Item", int32_type)], [("Item", float64_type)], [("Item", string_type)]])
+
+
+class Value(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 ["Ontology", "Int", "Float", "Name"]
+
+    @staticmethod
+    def from_string(value: str) -> Value:
+        match_value: tuple[bool, int]
+        out_arg: int = 0
+        def _arrow978(__unit: None=None) -> int:
+            return out_arg
+
+        def _arrow979(v: int) -> None:
+            nonlocal out_arg
+            out_arg = v or 0
+
+        match_value = (try_parse(value, 511, False, 32, FSharpRef(_arrow978, _arrow979)), out_arg)
+        if match_value[0]:
+            return Value(1, match_value[1])
+
+        else: 
+            match_value_1: tuple[bool, float]
+            out_arg_1: float = 0.0
+            def _arrow980(__unit: None=None) -> float:
+                return out_arg_1
+
+            def _arrow981(v_2: float) -> None:
+                nonlocal out_arg_1
+                out_arg_1 = v_2
+
+            match_value_1 = (try_parse_1(value, FSharpRef(_arrow980, _arrow981)), out_arg_1)
+            return Value(2, match_value_1[1]) if match_value_1[0] else Value(3, value)
+
+
+    @staticmethod
+    def from_options(value: str | None=None, term_source: str | None=None, term_accesssion: str | None=None) -> Value | None:
+        def _arrow982(__unit: None=None) -> Value | None:
+            value_1: str = value
+            return Value.from_string(value_1)
+
+        return ((None if (term_accesssion is None) else Value(0, OntologyAnnotation.create(default_arg(value, ""), term_source, term_accesssion))) if (term_source is None) else Value(0, OntologyAnnotation.create(default_arg(value, ""), term_source, term_accesssion))) if (value is None) else ((_arrow982() if (term_accesssion is None) else Value(0, OntologyAnnotation.create(default_arg(value, ""), term_source, term_accesssion))) if (term_source is None) else Value(0, OntologyAnnotation.create(default_arg(value, ""), term_source, term_accesssion)))
+
+    @staticmethod
+    def to_options(value: Value) -> tuple[str | None, str | None, str | None]:
+        if value.tag == 1:
+            return (int32_to_string(value.fields[0]), None, None)
+
+        elif value.tag == 2:
+            return (to_string(value.fields[0]), None, None)
+
+        elif value.tag == 3:
+            return (value.fields[0], None, None)
+
+        else: 
+            oa: OntologyAnnotation = value.fields[0]
+            return (oa.Name, oa.TermAccessionNumber, oa.TermSourceREF)
+
+
+    @property
+    def Text(self, __unit: None=None) -> str:
+        this: Value = self
+        if this.tag == 2:
+            return to_string(this.fields[0])
+
+        elif this.tag == 1:
+            return int32_to_string(this.fields[0])
+
+        elif this.tag == 3:
+            return this.fields[0]
+
+        else: 
+            return this.fields[0].NameText
+
+
+    def AsName(self, __unit: None=None) -> str:
+        this: Value = self
+        if this.tag == 3:
+            return this.fields[0]
+
+        else: 
+            raise Exception(("Value " + str(this)) + " is not of case name")
+
+
+    def AsInt(self, __unit: None=None) -> int:
+        this: Value = self
+        if this.tag == 1:
+            return this.fields[0]
+
+        else: 
+            raise Exception(("Value " + str(this)) + " is not of case int")
+
+
+    def AsFloat(self, __unit: None=None) -> float:
+        this: Value = self
+        if this.tag == 2:
+            return this.fields[0]
+
+        else: 
+            raise Exception(("Value " + str(this)) + " is not of case float")
+
+
+    def AsOntology(self, __unit: None=None) -> OntologyAnnotation:
+        this: Value = self
+        if this.tag == 0:
+            return this.fields[0]
+
+        else: 
+            raise Exception(("Value " + str(this)) + " is not of case ontology")
+
+
+    @property
+    def IsAnOntology(self, __unit: None=None) -> bool:
+        this: Value = self
+        return True if (this.tag == 0) else False
+
+    @property
+    def IsNumerical(self, __unit: None=None) -> bool:
+        this: Value = self
+        if (this.tag == 1) or (this.tag == 2):
+            return True
+
+        else: 
+            return False
+
+
+    @property
+    def IsAnInt(self, __unit: None=None) -> bool:
+        this: Value = self
+        return True if (this.tag == 1) else False
+
+    @property
+    def IsAFloat(self, __unit: None=None) -> bool:
+        this: Value = self
+        return True if (this.tag == 2) else False
+
+    @property
+    def IsAText(self, __unit: None=None) -> bool:
+        this: Value = self
+        return True if (this.tag == 3) else False
+
+    @staticmethod
+    def get_text(v: Value) -> str:
+        return v.Text
+
+    def Print(self, __unit: None=None) -> str:
+        this: Value = self
+        return to_string(this)
+
+    def PrintCompact(self, __unit: None=None) -> str:
+        this: Value = self
+        if this.tag == 1:
+            return to_text(printf("%i"))(this.fields[0])
+
+        elif this.tag == 2:
+            return to_text(printf("%f"))(this.fields[0])
+
+        elif this.tag == 3:
+            return this.fields[0]
+
+        else: 
+            return this.fields[0].NameText
+
+
+
+Value_reflection = _expr983
+
+__all__ = ["Value_reflection"]
+

arctrl/py/FileSystem/commit.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import Any
+from ..fable_modules.fable_library.reflection import (TypeInfo, string_type, class_type, record_type)
+from ..fable_modules.fable_library.types import Record
+
+def _expr669() -> TypeInfo:
+    return record_type("ARCtrl.FileSystem.Commit", [], Commit, lambda: [("Hash", string_type), ("UserName", string_type), ("UserEmail", string_type), ("Date", class_type("System.DateTime")), ("Message", string_type)])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class Commit(Record):
+    Hash: str
+    UserName: str
+    UserEmail: str
+    Date: Any
+    Message: str
+
+Commit_reflection = _expr669
+
+__all__ = ["Commit_reflection"]
+

arctrl/py/FileSystem/default_gitattributes.py

@@ -0,0 +1 @@
+

arctrl/py/FileSystem/default_gitignore.py

@@ -0,0 +1 @@
+

arctrl/py/FileSystem/default_license.py

@@ -0,0 +1 @@
+

arctrl/py/FileSystem/file_system.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass
+from ..fable_modules.fable_library.array_ import (append, map)
+from ..fable_modules.fable_library.option import default_arg
+from ..fable_modules.fable_library.reflection import (TypeInfo, array_type, record_type)
+from ..fable_modules.fable_library.types import (Array, Record)
+from .commit import (Commit, Commit_reflection)
+from .file_system_tree import (FileSystemTree, FileSystemTree_reflection)
+
+def _expr694() -> TypeInfo:
+    return record_type("ARCtrl.FileSystem.FileSystem", [], FileSystem, lambda: [("Tree", FileSystemTree_reflection()), ("History", array_type(Commit_reflection()))])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class FileSystem(Record):
+    Tree: FileSystemTree
+    History: Array[Commit]
+    @staticmethod
+    def create(tree: FileSystemTree, history: Array[Commit] | None=None) -> FileSystem:
+        return FileSystem(tree, default_arg(history, []))
+
+    def AddFile(self, path: str) -> FileSystem:
+        this: FileSystem = self
+        return FileSystem(this.Tree.AddFile(path), this.History)
+
+    @staticmethod
+    def add_file(path: str) -> Callable[[FileSystem], FileSystem]:
+        def _arrow693(fs: FileSystem) -> FileSystem:
+            return fs.AddFile(path)
+
+        return _arrow693
+
+    @staticmethod
+    def from_file_paths(paths: Array[str]) -> FileSystem:
+        tree: FileSystemTree = FileSystemTree.from_file_paths(paths)
+        return FileSystem.create(tree = tree)
+
+    def Union(self, other: FileSystem) -> FileSystem:
+        this: FileSystem = self
+        tree: FileSystemTree = this.Tree.Union(other.Tree)
+        history: Array[Commit] = append(this.History, other.History, None)
+        return FileSystem.create(tree = tree, history = history)
+
+    def Copy(self, __unit: None=None) -> FileSystem:
+        this: FileSystem = self
+        fst_copy: FileSystemTree = this.Tree.Copy()
+        def mapping(x: Commit) -> Commit:
+            return x
+
+        history_copy: Array[Commit] = map(mapping, this.History, None)
+        return FileSystem.create(tree = fst_copy, history = history_copy)
+
+
+FileSystem_reflection = _expr694
+
+__all__ = ["FileSystem_reflection"]
+