arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/FileSystem/file_system_tree.py

@@ -0,0 +1,426 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_modules.fable_library.array_ import (try_find, exists, map, head, filter, tail, equals_with, iterate, choose, append as append_1)
+from ..fable_modules.fable_library.list import (cons, to_array as to_array_1, reverse, FSharpList, empty)
+from ..fable_modules.fable_library.option import default_arg
+from ..fable_modules.fable_library.reflection import (TypeInfo, string_type, array_type, union_type)
+from ..fable_modules.fable_library.seq import (to_array, delay, append, singleton)
+from ..fable_modules.fable_library.seq2 import (Array_groupBy, Array_distinct)
+from ..fable_modules.fable_library.types import (Array, Union)
+from ..fable_modules.fable_library.util import (IEnumerable_1, string_hash, array_hash, curry2)
+from .path import (split, combine_many)
+
+def _expr470() -> TypeInfo:
+    return union_type("ARCtrl.FileSystem.FileSystemTree", [], FileSystemTree, lambda: [[("name", string_type)], [("name", string_type), ("children", array_type(FileSystemTree_reflection()))]])
+
+
+class FileSystemTree(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 ["File", "Folder"]
+
+    @property
+    def Name(self, __unit: None=None) -> str:
+        this: FileSystemTree = self
+        (pattern_matching_result, n) = (None, None)
+        if this.tag == 1:
+            pattern_matching_result = 0
+            n = this.fields[0]
+
+        else: 
+            pattern_matching_result = 0
+            n = this.fields[0]
+
+        if pattern_matching_result == 0:
+            return n
+
+
+    @property
+    def is_folder(self, __unit: None=None) -> bool:
+        this: FileSystemTree = self
+        return True if (this.tag == 1) else False
+
+    @property
+    def is_file(self, __unit: None=None) -> bool:
+        this: FileSystemTree = self
+        return True if (this.tag == 0) else False
+
+    @staticmethod
+    def ROOT_NAME() -> str:
+        return "root"
+
+    @staticmethod
+    def create_file(name: str) -> FileSystemTree:
+        return FileSystemTree(0, name)
+
+    @staticmethod
+    def create_folder(name: str, children: Array[FileSystemTree] | None=None) -> FileSystemTree:
+        return FileSystemTree(1, name, default_arg(children, []))
+
+    @staticmethod
+    def create_root_folder(children: Array[FileSystemTree]) -> FileSystemTree:
+        return FileSystemTree(1, FileSystemTree.ROOT_NAME(), children)
+
+    def TryGetChildByName(self, name: str) -> FileSystemTree | None:
+        this: FileSystemTree = self
+        def predicate(c: FileSystemTree) -> bool:
+            return c.Name == name
+
+        return None if (this.tag == 0) else try_find(predicate, this.fields[1])
+
+    @staticmethod
+    def try_get_child_by_name(name: str) -> Callable[[FileSystemTree], FileSystemTree | None]:
+        def _arrow450(fst: FileSystemTree) -> FileSystemTree | None:
+            return fst.TryGetChildByName(name)
+
+        return _arrow450
+
+    def ContainsChildWithName(self, name: str) -> bool:
+        this: FileSystemTree = self
+        def predicate(c: FileSystemTree) -> bool:
+            return c.Name == name
+
+        return False if (this.tag == 0) else exists(predicate, this.fields[1])
+
+    @staticmethod
+    def contains_child_with_name(name: str) -> Callable[[FileSystemTree], bool]:
+        def _arrow452(fst: FileSystemTree) -> bool:
+            return fst.ContainsChildWithName(name)
+
+        return _arrow452
+
+    def AddFile(self, path: str) -> FileSystemTree:
+        this: FileSystemTree = self
+        existing_paths: Array[str] = this.ToFilePaths()
+        def _arrow454(__unit: None=None) -> IEnumerable_1[str]:
+            def _arrow453(__unit: None=None) -> IEnumerable_1[str]:
+                return existing_paths
+
+            return append(singleton(path), delay(_arrow453))
+
+        file_paths: Array[str] = to_array(delay(_arrow454))
+        return FileSystemTree.from_file_paths(file_paths)
+
+    @staticmethod
+    def add_file(path: str) -> Callable[[FileSystemTree], FileSystemTree]:
+        def _arrow455(tree: FileSystemTree) -> FileSystemTree:
+            return tree.AddFile(path)
+
+        return _arrow455
+
+    @staticmethod
+    def from_file_paths(paths: Array[str]) -> FileSystemTree:
+        def loop(paths_1: Array[Array[str]], parent: FileSystemTree) -> FileSystemTree:
+            def mapping(arg: Array[str], paths_1: Any=paths_1, parent: Any=parent) -> FileSystemTree:
+                name: str = head(arg)
+                return FileSystemTree.create_file(name)
+
+            def predicate(p: Array[str], paths_1: Any=paths_1, parent: Any=parent) -> bool:
+                return len(p) == 1
+
+            files: Array[FileSystemTree] = map(mapping, filter(predicate, paths_1), None)
+            def mapping_2(tupled_arg: tuple[str, Array[Array[str]]], paths_1: Any=paths_1, parent: Any=parent) -> FileSystemTree:
+                parent_1: FileSystemTree = FileSystemTree.create_folder(tupled_arg[0], [])
+                def mapping_1(array_7: Array[str], tupled_arg: Any=tupled_arg) -> Array[str]:
+                    return tail(array_7)
+
+                return loop(map(mapping_1, tupled_arg[1], None), parent_1)
+
+            def projection(x_2: Array[str], paths_1: Any=paths_1, parent: Any=parent) -> str:
+                return head(x_2)
+
+            def predicate_1(p_1: Array[str], paths_1: Any=paths_1, parent: Any=parent) -> bool:
+                return len(p_1) > 1
+
+            class ObjectExpr457:
+                @property
+                def Equals(self) -> Callable[[str, str], bool]:
+                    def _arrow456(x_3: str, y_2: str) -> bool:
+                        return x_3 == y_2
+
+                    return _arrow456
+
+                @property
+                def GetHashCode(self) -> Callable[[str], int]:
+                    return string_hash
+
+            folders: Array[FileSystemTree] = map(mapping_2, Array_groupBy(projection, filter(predicate_1, paths_1), ObjectExpr457()), None)
+            if parent.tag == 1:
+                def _arrow459(__unit: None=None, paths_1: Any=paths_1, parent: Any=parent) -> IEnumerable_1[FileSystemTree]:
+                    def _arrow458(__unit: None=None) -> IEnumerable_1[FileSystemTree]:
+                        return folders
+
+                    return append(files, delay(_arrow458))
+
+                return FileSystemTree.create_folder(parent.fields[0], to_array(delay(_arrow459)))
+
+            else: 
+                return parent
+
+
+        class ObjectExpr462:
+            @property
+            def Equals(self) -> Callable[[Array[str], Array[str]], bool]:
+                def _arrow461(x: Array[str], y: Array[str]) -> bool:
+                    def _arrow460(x_1: str, y_1: str) -> bool:
+                        return x_1 == y_1
+
+                    return equals_with(_arrow460, x, y)
+
+                return _arrow461
+
+            @property
+            def GetHashCode(self) -> Callable[[Array[str]], int]:
+                return array_hash
+
+        return loop(Array_distinct(map(split, paths, None), ObjectExpr462()), FileSystemTree.create_folder(FileSystemTree.ROOT_NAME(), []))
+
+    def ToFilePaths(self, remove_root: bool | None=None) -> Array[str]:
+        this: FileSystemTree = self
+        res: Array[str] = []
+        def loop(output: FSharpList[str], parent: FileSystemTree) -> None:
+            if parent.tag == 1:
+                def action(filest: FileSystemTree, output: Any=output, parent: Any=parent) -> None:
+                    loop(cons(parent.fields[0], output), filest)
+
+                iterate(action, parent.fields[1])
+
+            else: 
+                item: str = combine_many(to_array_1(reverse(cons(parent.fields[0], output))))
+                (res.append(item))
+
+
+        if default_arg(remove_root, True):
+            if this.tag == 0:
+                (res.append(this.fields[0]))
+
+            else: 
+                iterate(curry2(loop)(empty()), this.fields[1])
+
+
+        else: 
+            loop(empty(), this)
+
+        return list(res)
+
+    @staticmethod
+    def to_file_paths(remove_root: bool | None=None) -> Callable[[FileSystemTree], Array[str]]:
+        def _arrow463(root: FileSystemTree) -> Array[str]:
+            return root.ToFilePaths(remove_root)
+
+        return _arrow463
+
+    def FilterFiles(self, predicate: Callable[[str], bool]) -> FileSystemTree | None:
+        this: FileSystemTree = self
+        def loop(parent: FileSystemTree) -> FileSystemTree | None:
+            if parent.tag == 1:
+                return FileSystemTree(1, parent.fields[0], choose(loop, parent.fields[1], None))
+
+            else: 
+                n: str = parent.fields[0]
+                if predicate(n):
+                    return FileSystemTree(0, n)
+
+                else: 
+                    return None
+
+
+
+        return loop(this)
+
+    @staticmethod
+    def filter_files(predicate: Callable[[str], bool]) -> Callable[[FileSystemTree], FileSystemTree | None]:
+        def _arrow464(tree: FileSystemTree) -> FileSystemTree | None:
+            return tree.FilterFiles(predicate)
+
+        return _arrow464
+
+    def FilterFolders(self, predicate: Callable[[str], bool]) -> FileSystemTree | None:
+        this: FileSystemTree = self
+        def loop(parent: FileSystemTree) -> FileSystemTree | None:
+            if parent.tag == 1:
+                n_1: str = parent.fields[0]
+                if predicate(n_1):
+                    return FileSystemTree(1, n_1, choose(loop, parent.fields[1], None))
+
+                else: 
+                    return None
+
+
+            else: 
+                return FileSystemTree(0, parent.fields[0])
+
+
+        return loop(this)
+
+    @staticmethod
+    def filter_folders(predicate: Callable[[str], bool]) -> Callable[[FileSystemTree], FileSystemTree | None]:
+        def _arrow465(tree: FileSystemTree) -> FileSystemTree | None:
+            return tree.FilterFolders(predicate)
+
+        return _arrow465
+
+    def Filter(self, predicate: Callable[[str], bool]) -> FileSystemTree | None:
+        this: FileSystemTree = self
+        def loop(parent: FileSystemTree) -> FileSystemTree | None:
+            if parent.tag == 1:
+                n_1: str = parent.fields[0]
+                if predicate(n_1):
+                    filtered_children: Array[FileSystemTree] = choose(loop, parent.fields[1], None)
+                    if len(filtered_children) == 0:
+                        return None
+
+                    else: 
+                        return FileSystemTree(1, n_1, filtered_children)
+
+
+                else: 
+                    return None
+
+
+            else: 
+                n: str = parent.fields[0]
+                if predicate(n):
+                    return FileSystemTree(0, n)
+
+                else: 
+                    return None
+
+
+
+        return loop(this)
+
+    @staticmethod
+    def filter(predicate: Callable[[str], bool]) -> Callable[[FileSystemTree], FileSystemTree | None]:
+        def _arrow466(tree: FileSystemTree) -> FileSystemTree | None:
+            return tree.Filter(predicate)
+
+        return _arrow466
+
+    def Union(self, other_fst: FileSystemTree) -> FileSystemTree:
+        this: FileSystemTree = self
+        def _arrow467(__unit: None=None) -> Array[str]:
+            array_1: Array[str] = this.ToFilePaths()
+            return append_1(other_fst.ToFilePaths(), array_1, None)
+
+        class ObjectExpr469:
+            @property
+            def Equals(self) -> Callable[[str, str], bool]:
+                def _arrow468(x: str, y: str) -> bool:
+                    return x == y
+
+                return _arrow468
+
+            @property
+            def GetHashCode(self) -> Callable[[str], int]:
+                return string_hash
+
+        paths: Array[str] = Array_distinct(_arrow467(), ObjectExpr469())
+        return FileSystemTree.from_file_paths(paths)
+
+    def Copy(self, __unit: None=None) -> FileSystemTree:
+        this: FileSystemTree = self
+        def mapping(c: FileSystemTree) -> FileSystemTree:
+            return c.Copy()
+
+        return FileSystemTree(0, this.fields[0]) if (this.tag == 0) else FileSystemTree(1, this.fields[0], map(mapping, this.fields[1], None))
+
+    @staticmethod
+    def create_git_keep_file(__unit: None=None) -> FileSystemTree:
+        return FileSystemTree.create_file(".gitkeep")
+
+    @staticmethod
+    def create_readme_file(__unit: None=None) -> FileSystemTree:
+        return FileSystemTree.create_file("README.md")
+
+    @staticmethod
+    def create_empty_folder(name: str) -> FileSystemTree:
+        return FileSystemTree.create_folder(name, [FileSystemTree.create_git_keep_file()])
+
+    @staticmethod
+    def create_assay_folder(assay_name: str, has_data_map: bool | None=None) -> FileSystemTree:
+        has_data_map_1: bool = default_arg(has_data_map, False)
+        dataset: FileSystemTree = FileSystemTree.create_empty_folder("dataset")
+        protocols: FileSystemTree = FileSystemTree.create_empty_folder("protocols")
+        readme: FileSystemTree = FileSystemTree.create_readme_file()
+        assay_file: FileSystemTree = FileSystemTree.create_file("isa.assay.xlsx")
+        if has_data_map_1:
+            data_map_file: FileSystemTree = FileSystemTree.create_file("isa.datamap.xlsx")
+            return FileSystemTree.create_folder(assay_name, [dataset, protocols, assay_file, readme, data_map_file])
+
+        else: 
+            return FileSystemTree.create_folder(assay_name, [dataset, protocols, assay_file, readme])
+
+
+    @staticmethod
+    def create_study_folder(study_name: str, has_data_map: bool | None=None) -> FileSystemTree:
+        has_data_map_1: bool = default_arg(has_data_map, False)
+        resources: FileSystemTree = FileSystemTree.create_empty_folder("resources")
+        protocols: FileSystemTree = FileSystemTree.create_empty_folder("protocols")
+        readme: FileSystemTree = FileSystemTree.create_readme_file()
+        study_file: FileSystemTree = FileSystemTree.create_file("isa.study.xlsx")
+        if has_data_map_1:
+            data_map_file: FileSystemTree = FileSystemTree.create_file("isa.datamap.xlsx")
+            return FileSystemTree.create_folder(study_name, [resources, protocols, study_file, readme, data_map_file])
+
+        else: 
+            return FileSystemTree.create_folder(study_name, [resources, protocols, study_file, readme])
+
+
+    @staticmethod
+    def create_workflow_folder(workflow_name: str, has_data_map: bool | None=None) -> FileSystemTree:
+        has_data_map_1: bool = default_arg(has_data_map, False)
+        readme: FileSystemTree = FileSystemTree.create_readme_file()
+        workflow_file: FileSystemTree = FileSystemTree.create_file("isa.workflow.xlsx")
+        if has_data_map_1:
+            data_map_file: FileSystemTree = FileSystemTree.create_file("isa.datamap.xlsx")
+            return FileSystemTree.create_folder(workflow_name, [workflow_file, readme, data_map_file])
+
+        else: 
+            return FileSystemTree.create_folder(workflow_name, [workflow_file, readme])
+
+
+    @staticmethod
+    def create_run_folder(run_name: str, has_data_map: bool | None=None) -> FileSystemTree:
+        has_data_map_1: bool = default_arg(has_data_map, False)
+        readme: FileSystemTree = FileSystemTree.create_readme_file()
+        run_file: FileSystemTree = FileSystemTree.create_file("isa.run.xlsx")
+        if has_data_map_1:
+            data_map_file: FileSystemTree = FileSystemTree.create_file("isa.datamap.xlsx")
+            return FileSystemTree.create_folder(run_name, [run_file, readme, data_map_file])
+
+        else: 
+            return FileSystemTree.create_folder(run_name, [run_file, readme])
+
+
+    @staticmethod
+    def create_investigation_file(__unit: None=None) -> FileSystemTree:
+        return FileSystemTree.create_file("isa.investigation.xlsx")
+
+    @staticmethod
+    def create_assays_folder(assays: Array[FileSystemTree]) -> FileSystemTree:
+        return FileSystemTree.create_folder("assays", append_1([FileSystemTree.create_git_keep_file()], assays, None))
+
+    @staticmethod
+    def create_studies_folder(studies: Array[FileSystemTree]) -> FileSystemTree:
+        return FileSystemTree.create_folder("studies", append_1([FileSystemTree.create_git_keep_file()], studies, None))
+
+    @staticmethod
+    def create_workflows_folder(workflows: Array[FileSystemTree]) -> FileSystemTree:
+        return FileSystemTree.create_folder("workflows", append_1([FileSystemTree.create_git_keep_file()], workflows, None))
+
+    @staticmethod
+    def create_runs_folder(runs: Array[FileSystemTree]) -> FileSystemTree:
+        return FileSystemTree.create_folder("runs", append_1([FileSystemTree.create_git_keep_file()], runs, None))
+
+
+FileSystemTree_reflection = _expr470
+
+__all__ = ["FileSystemTree_reflection"]
+

arctrl/py/FileSystem/path.py

@@ -0,0 +1,64 @@
+from typing import Any
+from ..fable_modules.fable_library.array_ import (filter, map_indexed, last)
+from ..fable_modules.fable_library.string_ import (split as split_1, trim_end, trim_start, join, trim)
+from ..fable_modules.fable_library.types import Array
+
+seperators: Array[str] = ["/", "\\"]
+
+def split(path: str) -> Array[str]:
+    def predicate(p: str, path: Any=path) -> bool:
+        if p != "":
+            return p != "."
+
+        else: 
+            return False
+
+
+    return filter(predicate, split_1(path, seperators, None, 3))
+
+
+def combine(path1: str, path2: str) -> str:
+    return (trim_end(path1, *seperators) + "/") + trim_start(path2, *seperators)
+
+
+def combine_many(paths: Array[str]) -> str:
+    def mapping(i: int, p: str, paths: Any=paths) -> str:
+        if i == 0:
+            return trim_end(p, *seperators)
+
+        elif i == (len(paths) - 1):
+            return trim_start(p, *seperators)
+
+        else: 
+            return trim(p, *seperators)
+
+
+    return join("/", map_indexed(mapping, paths, None))
+
+
+def get_file_name(path: str) -> str:
+    return last(split(path))
+
+
+def is_file(file_name: str, path: str) -> bool:
+    return get_file_name(path) == file_name
+
+
+def get_assay_folder_path(assay_identifier: str) -> str:
+    return combine("assays", assay_identifier)
+
+
+def get_study_folder_path(study_identifier: str) -> str:
+    return combine("studies", study_identifier)
+
+
+def get_workflow_folder_path(workflow_identifier: str) -> str:
+    return combine("workflows", workflow_identifier)
+
+
+def get_run_folder_path(run_identifier: str) -> str:
+    return combine("runs", run_identifier)
+
+
+__all__ = ["seperators", "split", "combine", "combine_many", "get_file_name", "is_file", "get_assay_folder_path", "get_study_folder_path", "get_workflow_folder_path", "get_run_folder_path"]
+

arctrl/py/Json/DataMap/data_context.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.list import (choose, of_array, FSharpList)
+from ...fable_modules.fable_library.option import map
+from ...fable_modules.fable_library.seq import map as map_1
+from ...fable_modules.fable_library.util import IEnumerable_1
+from ...fable_modules.thoth_json_core.decode import (object, IRequiredGetter, IOptionalGetter, string, IGetters)
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ...Core.data import Data
+from ...Core.data_context import (DataContext__get_Explication, DataContext__get_Unit, DataContext__get_ObjectType, DataContext__get_Description, DataContext__get_GeneratedBy, DataContext__get_Label, DataContext, DataContext__ctor_Z780A8A2A)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ..data import (encoder as encoder_1, decoder as decoder_1)
+from ..encode import try_include
+from ..ontology_annotation import (OntologyAnnotation_encoder, OntologyAnnotation_decoder)
+
+__A_ = TypeVar("__A_")
+
+def encoder(dc: DataContext) -> IEncodable:
+    def chooser(tupled_arg: tuple[str, IEncodable | None], dc: Any=dc) -> tuple[str, IEncodable] | None:
+        def mapping(v_1: IEncodable, tupled_arg: Any=tupled_arg) -> tuple[str, IEncodable]:
+            return (tupled_arg[0], v_1)
+
+        return map(mapping, tupled_arg[1])
+
+    def _arrow2808(oa: OntologyAnnotation, dc: Any=dc) -> IEncodable:
+        return OntologyAnnotation_encoder(oa)
+
+    def _arrow2809(oa_1: OntologyAnnotation, dc: Any=dc) -> IEncodable:
+        return OntologyAnnotation_encoder(oa_1)
+
+    def _arrow2810(oa_2: OntologyAnnotation, dc: Any=dc) -> IEncodable:
+        return OntologyAnnotation_encoder(oa_2)
+
+    def _arrow2812(value: str, dc: Any=dc) -> IEncodable:
+        class ObjectExpr2811(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr2811()
+
+    def _arrow2816(value_2: str, dc: Any=dc) -> IEncodable:
+        class ObjectExpr2815(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_1.encode_string(value_2)
+
+        return ObjectExpr2815()
+
+    def _arrow2819(value_4: str, dc: Any=dc) -> IEncodable:
+        class ObjectExpr2818(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_2.encode_string(value_4)
+
+        return ObjectExpr2818()
+
+    values: FSharpList[tuple[str, IEncodable]] = choose(chooser, of_array([("data", encoder_1(dc)), try_include("explication", _arrow2808, DataContext__get_Explication(dc)), try_include("unit", _arrow2809, DataContext__get_Unit(dc)), try_include("objectType", _arrow2810, DataContext__get_ObjectType(dc)), try_include("description", _arrow2812, DataContext__get_Description(dc)), try_include("generatedBy", _arrow2816, DataContext__get_GeneratedBy(dc)), try_include("label", _arrow2819, DataContext__get_Label(dc))]))
+    class ObjectExpr2826(IEncodable):
+        def Encode(self, helpers_3: IEncoderHelpers_1[Any], dc: Any=dc) -> Any:
+            def mapping_1(tupled_arg_1: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg_1[0], tupled_arg_1[1].Encode(helpers_3))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map_1(mapping_1, values)
+            return helpers_3.encode_object(arg)
+
+    return ObjectExpr2826()
+
+
+def _arrow2837(get: IGetters) -> DataContext:
+    data: Data
+    object_arg: IRequiredGetter = get.Required
+    data = object_arg.Field("data", decoder_1)
+    def _arrow2829(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_1: IOptionalGetter = get.Optional
+        return object_arg_1.Field("explication", OntologyAnnotation_decoder)
+
+    def _arrow2830(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_2: IOptionalGetter = get.Optional
+        return object_arg_2.Field("unit", OntologyAnnotation_decoder)
+
+    def _arrow2831(__unit: None=None) -> OntologyAnnotation | None:
+        object_arg_3: IOptionalGetter = get.Optional
+        return object_arg_3.Field("objectType", OntologyAnnotation_decoder)
+
+    def _arrow2833(__unit: None=None) -> str | None:
+        object_arg_4: IOptionalGetter = get.Optional
+        return object_arg_4.Field("label", string)
+
+    def _arrow2835(__unit: None=None) -> str | None:
+        object_arg_5: IOptionalGetter = get.Optional
+        return object_arg_5.Field("description", string)
+
+    def _arrow2836(__unit: None=None) -> str | None:
+        object_arg_6: IOptionalGetter = get.Optional
+        return object_arg_6.Field("generatedBy", string)
+
+    return DataContext__ctor_Z780A8A2A(data.ID, data.Name, data.DataType, data.Format, data.SelectorFormat, _arrow2829(), _arrow2830(), _arrow2831(), _arrow2833(), _arrow2835(), _arrow2836(), data.Comments)
+
+
+decoder: Decoder_1[DataContext] = object(_arrow2837)
+
+__all__ = ["encoder", "decoder"]
+

arctrl/py/Json/DataMap/data_map.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.seq import map
+from ...fable_modules.fable_library.types import Array
+from ...fable_modules.fable_library.util import (to_enumerable, IEnumerable_1)
+from ...fable_modules.thoth_json_core.decode import (object, resize_array, IRequiredGetter, IGetters)
+from ...fable_modules.thoth_json_core.encode import seq
+from ...fable_modules.thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ...Core.data_context import DataContext
+from ...Core.data_map import (DataMap__get_DataContexts, DataMap, DataMap__ctor_4E3220A7)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Table.composite_cell import CompositeCell
+from .data_context import (encoder as encoder_1, decoder as decoder_1)
+
+__A_ = TypeVar("__A_")
+
+def encoder(dm: DataMap) -> IEncodable:
+    def mapping(dc: DataContext, dm: Any=dm) -> IEncodable:
+        return encoder_1(dc)
+
+    values_1: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("dataContexts", seq(map(mapping, DataMap__get_DataContexts(dm))))])
+    class ObjectExpr2859(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], dm: Any=dm) -> Any:
+            def mapping_1(tupled_arg: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map(mapping_1, values_1)
+            return helpers.encode_object(arg)
+
+    return ObjectExpr2859()
+
+
+def _arrow2865(get: IGetters) -> DataMap:
+    def _arrow2863(__unit: None=None) -> Array[DataContext]:
+        arg_1: Decoder_1[Array[DataContext]] = resize_array(decoder_1)
+        object_arg: IRequiredGetter = get.Required
+        return object_arg.Field("dataContexts", arg_1)
+
+    return DataMap__ctor_4E3220A7(_arrow2863())
+
+
+decoder: Decoder_1[DataMap] = object(_arrow2865)
+
+def encoder_compressed(string_table: Any, oa_table: Any, cell_table: Any, dm: DataMap) -> IEncodable:
+    return encoder(dm)
+
+
+def decoder_compressed(string_table: Array[str], oa_table: Array[OntologyAnnotation], cell_table: Array[CompositeCell]) -> Decoder_1[DataMap]:
+    return decoder
+
+
+__all__ = ["encoder", "decoder", "encoder_compressed", "decoder_compressed"]
+