arctrl 3.0.0__py3-none-any.whl

arctrl/py/ContractIO/file_system_helper.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+from collections.abc import Callable
+from pathlib import Path
+import shutil
+import os
+from typing import Any
+from ..cross_async import all
+from ..fable_modules.fable_library.array_ import map
+from ..fable_modules.fable_library.async_builder import (singleton, Async)
+from ..fable_modules.fable_library.seq import (is_empty, empty, map as map_1, concat, append, to_array)
+from ..fable_modules.fable_library.string_ import (starts_with_exact, trim as trim_1, replace, substring)
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import (IEnumerable_1, to_enumerable)
+from ..fable_modules.fs_spreadsheet.fs_workbook import FsWorkbook
+from ..fable_modules.fs_spreadsheet_py.fs_extension import (FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5, FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static)
+
+shutil
+
+os
+
+Path
+
+def directory_exists_async(path: str) -> Async[bool]:
+    def _arrow4426(__unit: None=None, path: Any=path) -> Async[bool]:
+        return singleton.Return(Path(path).is_dir())
+
+    return singleton.Delay(_arrow4426)
+
+
+def create_directory_async(path: str) -> Async[None]:
+    def _arrow4427(__unit: None=None, path: Any=path) -> Async[None]:
+        Path(path).mkdir(parents=True, exist_ok=True)
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow4427)
+
+
+def ensure_directory_async(path: str) -> Async[None]:
+    def _arrow4429(__unit: None=None, path: Any=path) -> Async[None]:
+        def _arrow4428(_arg: bool) -> Async[None]:
+            return singleton.ReturnFrom(create_directory_async(path)) if (not _arg) else singleton.Zero()
+
+        return singleton.Bind(directory_exists_async(path), _arrow4428)
+
+    return singleton.Delay(_arrow4429)
+
+
+def ensure_directory_of_file_async(file_path: str) -> Async[None]:
+    def _arrow4430(__unit: None=None, file_path: Any=file_path) -> Async[None]:
+        return singleton.ReturnFrom(ensure_directory_async(Path(file_path).parent))
+
+    return singleton.Delay(_arrow4430)
+
+
+def file_exists_async(path: str) -> Async[bool]:
+    def _arrow4431(__unit: None=None, path: Any=path) -> Async[bool]:
+        return singleton.Return(Path(path).is_file())
+
+    return singleton.Delay(_arrow4431)
+
+
+def read_file_text_async(path: str) -> Async[str]:
+    def _arrow4433(__unit: None=None, path: Any=path) -> Async[str]:
+        def _arrow4432(__unit: None=None) -> str:
+            with open(path, 'r', encoding='utf-8') as f: return f.read()
+
+        return singleton.Return(_arrow4432())
+
+    return singleton.Delay(_arrow4433)
+
+
+def read_file_binary_async(path: str) -> Async[bytearray]:
+    def _arrow4435(__unit: None=None, path: Any=path) -> Async[bytearray]:
+        def _arrow4434(__unit: None=None) -> bytearray:
+            with open(path, 'rb') as f: return f.read()
+
+        return singleton.Return(_arrow4434())
+
+    return singleton.Delay(_arrow4435)
+
+
+def read_file_xlsx_async(path: str) -> Async[FsWorkbook]:
+    def _arrow4436(__unit: None=None, path: Any=path) -> Async[FsWorkbook]:
+        return singleton.Return(FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5(path))
+
+    return singleton.Delay(_arrow4436)
+
+
+def move_file_async(old_path: str, new_path: str) -> Async[None]:
+    def _arrow4437(__unit: None=None, old_path: Any=old_path, new_path: Any=new_path) -> Async[None]:
+        shutil.move(old_path, new_path)
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow4437)
+
+
+def move_directory_async(old_path: str, new_path: str) -> Async[None]:
+    return move_file_async(old_path, new_path)
+
+
+def delete_file_async(path: str) -> Async[None]:
+    def _arrow4438(__unit: None=None, path: Any=path) -> Async[None]:
+        try:
+            os.remove(path)
+        except FileNotFoundError:
+            pass
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow4438)
+
+
+def delete_directory_async(path: str) -> Async[None]:
+    def _arrow4439(__unit: None=None, path: Any=path) -> Async[None]:
+        shutil.rmtree(path, ignore_errors=True)
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow4439)
+
+
+def write_file_text_async(path: str, text: str) -> Async[None]:
+    def _arrow4440(__unit: None=None, path: Any=path, text: Any=text) -> Async[None]:
+        with open(path, 'w') as f: f.write(text)
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow4440)
+
+
+def write_file_binary_async(path: str, bytes: bytearray) -> Async[None]:
+    def _arrow4441(__unit: None=None, path: Any=path, bytes: Any=bytes) -> Async[None]:
+        with open(path, 'wb') as f: f.write(bytes)
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow4441)
+
+
+def write_file_xlsx_async(path: str, wb: FsWorkbook) -> Async[None]:
+    def _arrow4442(__unit: None=None, path: Any=path, wb: Any=wb) -> Async[None]:
+        FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static(path, wb)
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow4442)
+
+
+def trim(path: str) -> str:
+    if starts_with_exact(path, "./"):
+        return trim_1(replace(path, "./", ""), "/")
+
+    else: 
+        return trim_1(path, "/")
+
+
+
+def make_relative(directory_path: str, path: str) -> str:
+    if True if (True if (directory_path == ".") else (directory_path == "/")) else (directory_path == ""):
+        return path
+
+    else: 
+        directory_path_1: str = trim(directory_path)
+        path_1: str = trim(path)
+        if starts_with_exact(path_1, directory_path_1):
+            return substring(path_1, len(directory_path_1))
+
+        else: 
+            return path_1
+
+
+
+
+def standardize_slashes(path: str) -> str:
+    return replace(path, "\\", "/")
+
+
+def get_sub_directories_async(path: str) -> Async[Array[str]]:
+    def _arrow4443(__unit: None=None, path: Any=path) -> Async[Array[str]]:
+        paths: Array[str] = [str(entry) for entry in Path(path).iterdir() if entry.is_dir()]
+        return singleton.Return(map(standardize_slashes, paths, None))
+
+    return singleton.Delay(_arrow4443)
+
+
+def get_sub_files_async(path: str) -> Async[Array[str]]:
+    def _arrow4444(__unit: None=None, path: Any=path) -> Async[Array[str]]:
+        paths: Array[str] = [str(entry) for entry in Path(path).iterdir() if entry.is_file()]
+        return singleton.Return(map(standardize_slashes, paths, None))
+
+    return singleton.Delay(_arrow4444)
+
+
+def get_all_file_paths_async(directory_path: str) -> Async[Array[str]]:
+    directory_path_1: str = standardize_slashes(directory_path)
+    def _arrow4450(__unit: None=None, directory_path: Any=directory_path) -> Async[Array[str]]:
+        def all_files(dirs: IEnumerable_1[str]) -> Async[IEnumerable_1[str]]:
+            def _arrow4448(__unit: None=None, dirs: Any=dirs) -> Async[IEnumerable_1[str]]:
+                def _arrow4447(_arg: Array[Array[str]]) -> Async[IEnumerable_1[str]]:
+                    sub_files_1: IEnumerable_1[str] = concat(_arg)
+                    def _arrow4446(_arg_1: Array[Array[str]]) -> Async[IEnumerable_1[str]]:
+                        def _arrow4445(_arg_2: Array[IEnumerable_1[str]]) -> Async[IEnumerable_1[str]]:
+                            sub_dir_contents_1: IEnumerable_1[str] = concat(_arg_2)
+                            return singleton.Return(append(sub_dir_contents_1, sub_files_1))
+
+                        return singleton.Bind(all(map_1(all_files, _arg_1)), _arrow4445)
+
+                    return singleton.Bind(all(map_1(get_sub_directories_async, dirs)), _arrow4446)
+
+                return singleton.Return(empty()) if is_empty(dirs) else singleton.Bind(all(map_1(get_sub_files_async, dirs)), _arrow4447)
+
+            return singleton.Delay(_arrow4448)
+
+        def _arrow4449(_arg_3: IEnumerable_1[str]) -> Async[Array[str]]:
+            def mapping_1(arg_2: str) -> str:
+                return standardize_slashes(make_relative(directory_path_1, arg_2))
+
+            all_files_relative: Array[str] = map(mapping_1, to_array(_arg_3), None)
+            return singleton.Return(all_files_relative)
+
+        return singleton.Bind(all_files(to_enumerable([directory_path_1])), _arrow4449)
+
+    return singleton.Delay(_arrow4450)
+
+
+def rename_file_or_directory_async(old_path: str, new_path: str) -> Async[None]:
+    def _arrow4453(__unit: None=None, old_path: Any=old_path, new_path: Any=new_path) -> Async[None]:
+        def _arrow4452(_arg: bool) -> Async[None]:
+            def _arrow4451(_arg_1: bool) -> Async[None]:
+                if _arg:
+                    return singleton.ReturnFrom(move_file_async(old_path, new_path))
+
+                elif _arg_1:
+                    return singleton.ReturnFrom(move_directory_async(old_path, new_path))
+
+                else: 
+                    return singleton.Zero()
+
+
+            return singleton.Bind(directory_exists_async(old_path), _arrow4451)
+
+        return singleton.Bind(file_exists_async(old_path), _arrow4452)
+
+    return singleton.Delay(_arrow4453)
+
+
+def delete_file_or_directory_async(path: str) -> Async[None]:
+    def _arrow4456(__unit: None=None, path: Any=path) -> Async[None]:
+        def _arrow4455(_arg: bool) -> Async[None]:
+            def _arrow4454(_arg_1: bool) -> Async[None]:
+                if _arg:
+                    return singleton.ReturnFrom(delete_file_async(path))
+
+                elif _arg_1:
+                    return singleton.ReturnFrom(delete_directory_async(path))
+
+                else: 
+                    return singleton.Zero()
+
+
+            return singleton.Bind(directory_exists_async(path), _arrow4454)
+
+        return singleton.Bind(file_exists_async(path), _arrow4455)
+
+    return singleton.Delay(_arrow4456)
+
+
+__all__ = ["directory_exists_async", "create_directory_async", "ensure_directory_async", "ensure_directory_of_file_async", "file_exists_async", "read_file_text_async", "read_file_binary_async", "read_file_xlsx_async", "move_file_async", "move_directory_async", "delete_file_async", "delete_directory_async", "write_file_text_async", "write_file_binary_async", "write_file_xlsx_async", "trim", "make_relative", "standardize_slashes", "get_sub_directories_async", "get_sub_files_async", "get_all_file_paths_async", "rename_file_or_directory_async", "delete_file_or_directory_async"]
+

arctrl/py/Conversion/assay.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+from typing import Any
+from ..Core.arc_types import ArcAssay
+from ..Core.comment import Comment
+from ..Core.data import DataAux_pathAndSelectorFromName
+from ..Core.datamap import Datamap
+from ..Core.Helper.collections_ import (ResizeArray_distinct, ResizeArray_append, ResizeArray_choose, ResizeArray_collect, ResizeArray_filter, ResizeArray_map, ResizeArray_tryFind, Option_fromSeq, ResizeArray_groupBy, ResizeArray_singleton, ResizeArray_appendSingleton, Option_fromValueWithDefault)
+from ..Core.ontology_annotation import OntologyAnnotation
+from ..Core.person import Person
+from ..Core.Table.arc_tables import ArcTables
+from ..FileSystem.file_system import FileSystem
+from ..ROCrate.ldcontext import LDContext
+from ..ROCrate.ldobject import (LDNode, LDGraph)
+from ..ROCrate.LDTypes.dataset import LDDataset
+from ..ROCrate.LDTypes.file import LDFile
+from ..ROCrate.LDTypes.lab_process import LDLabProcess
+from ..ROCrate.LDTypes.property_value import LDPropertyValue
+from ..fable_modules.fable_library.list import of_seq
+from ..fable_modules.fable_library.option import (default_arg, map)
+from ..fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..fable_modules.fable_library.types import Array
+from .basic import (BaseTypes_composeDefinedTerm_ZDED3A0F, BaseTypes_composePropertyValueFromOA_ZDED3A0F, BaseTypes_composeComment_Z13201A7E, BaseTypes_decomposeDefinedTerm_Z2F770004, BaseTypes_decomposePropertyValueToOA_Z2F770004, BaseTypes_decomposeComment_Z2F770004)
+from .datamap import (DatamapConversion_composeFragmentDescriptors_Z892BFC3, DatamapConversion_decomposeFragmentDescriptors_Z6E59645F)
+from .person import (PersonConversion_composePerson_Z64D846DC, PersonConversion_decomposePerson_Z6839B9E8)
+from .table import (ARCtrl_ArcTables__ArcTables_GetProcesses_5E660E5C, ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586)
+
+def _expr4382() -> TypeInfo:
+    return class_type("ARCtrl.Conversion.AssayConversion", None, AssayConversion)
+
+
+class AssayConversion:
+    ...
+
+AssayConversion_reflection = _expr4382
+
+def AssayConversion_getDataFilesFromProcesses_6BABD1B0(processes: Array[LDNode], fragment_descriptors: Array[LDNode] | None=None, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+    def f(df: LDNode, processes: Any=processes, fragment_descriptors: Any=fragment_descriptors, graph: Any=graph, context: Any=context) -> LDNode | None:
+        return LDPropertyValue.try_get_subject_of(df, graph, context)
+
+    def f_1(p: LDNode, processes: Any=processes, fragment_descriptors: Any=fragment_descriptors, graph: Any=graph, context: Any=context) -> Array[LDNode]:
+        return ResizeArray_append(LDLabProcess.get_objects_as_data(p, graph, context), LDLabProcess.get_results_as_data(p, graph, context))
+
+    data: Array[LDNode] = ResizeArray_distinct(ResizeArray_append(ResizeArray_choose(f, default_arg(fragment_descriptors, [])), ResizeArray_collect(f_1, processes)))
+    def f_2(d: LDNode, processes: Any=processes, fragment_descriptors: Any=fragment_descriptors, graph: Any=graph, context: Any=context) -> bool:
+        return DataAux_pathAndSelectorFromName(d.Id)[1] is None
+
+    files: Array[LDNode] = ResizeArray_filter(f_2, data)
+    def f_7(tupled_arg: tuple[str, Array[LDNode]], processes: Any=processes, fragment_descriptors: Any=fragment_descriptors, graph: Any=graph, context: Any=context) -> LDNode:
+        path: str = tupled_arg[0]
+        fragments: Array[LDNode] = tupled_arg[1]
+        file: LDNode
+        def f_5(d_3: LDNode, tupled_arg: Any=tupled_arg) -> bool:
+            return d_3.Id == path
+
+        match_value: LDNode | None = ResizeArray_tryFind(f_5, files)
+        if match_value is None:
+            comments: Array[LDNode] | None = Option_fromSeq(LDFile.get_comments(fragments[0], graph, context))
+            file = LDFile.create(path, path, comments, LDFile.try_get_disambiguating_description_as_string(fragments[0], context), LDFile.try_get_encoding_format_as_string(fragments[0], context), None, fragments[0].TryGetContext())
+
+        else: 
+            file = match_value
+
+        LDDataset.set_has_parts(file, fragments, context)
+        return file
+
+    def f_4(d_2: LDNode, processes: Any=processes, fragment_descriptors: Any=fragment_descriptors, graph: Any=graph, context: Any=context) -> str:
+        return DataAux_pathAndSelectorFromName(d_2.Id)[0]
+
+    def f_3(d_1: LDNode, processes: Any=processes, fragment_descriptors: Any=fragment_descriptors, graph: Any=graph, context: Any=context) -> bool:
+        return DataAux_pathAndSelectorFromName(d_1.Id)[1] is not None
+
+    return ResizeArray_append(files, ResizeArray_map(f_7, ResizeArray_groupBy(f_4, ResizeArray_filter(f_3, data))))
+
+
+def AssayConversion_composeAssay_Z5C53FD5C(assay: ArcAssay, fs: FileSystem | None=None) -> LDNode:
+    def mapping(term: OntologyAnnotation, assay: Any=assay, fs: Any=fs) -> LDNode:
+        return BaseTypes_composeDefinedTerm_ZDED3A0F(term)
+
+    measurement_method: LDNode | None = map(mapping, assay.TechnologyType)
+    def mapping_1(term_1: OntologyAnnotation, assay: Any=assay, fs: Any=fs) -> LDNode:
+        return BaseTypes_composeDefinedTerm_ZDED3A0F(term_1)
+
+    measurement_technique: LDNode | None = map(mapping_1, assay.TechnologyPlatform)
+    def mapping_2(term_2: OntologyAnnotation, assay: Any=assay, fs: Any=fs) -> LDNode:
+        return BaseTypes_composePropertyValueFromOA_ZDED3A0F(term_2)
+
+    variable_measured: LDNode | None = map(mapping_2, assay.MeasurementType)
+    def f(c: Person, assay: Any=assay, fs: Any=fs) -> LDNode:
+        return PersonConversion_composePerson_Z64D846DC(c)
+
+    creators: Array[LDNode] | None = Option_fromSeq(ResizeArray_map(f, assay.Performers))
+    process_sequence: Array[LDNode] | None = Option_fromSeq(list(ARCtrl_ArcTables__ArcTables_GetProcesses_5E660E5C(ArcTables(assay.Tables), assay.Identifier, None, fs)))
+    def mapping_3(datamap: Datamap, assay: Any=assay, fs: Any=fs) -> Array[LDNode]:
+        return DatamapConversion_composeFragmentDescriptors_Z892BFC3(datamap)
+
+    fragment_descriptors: Array[LDNode] | None = map(mapping_3, assay.Datamap)
+    def mapping_4(ps: Array[LDNode], assay: Any=assay, fs: Any=fs) -> Array[LDNode]:
+        return AssayConversion_getDataFilesFromProcesses_6BABD1B0(ps, fragment_descriptors)
+
+    data_files: Array[LDNode] | None = map(mapping_4, process_sequence)
+    def _arrow4383(__unit: None=None, assay: Any=assay, fs: Any=fs) -> Array[LDNode] | None:
+        fds_1: Array[LDNode] = fragment_descriptors
+        return fds_1
+
+    def _arrow4384(__unit: None=None, assay: Any=assay, fs: Any=fs) -> Array[LDNode] | None:
+        vm_1: LDNode = variable_measured
+        return ResizeArray_singleton(vm_1)
+
+    def _arrow4385(__unit: None=None, assay: Any=assay, fs: Any=fs) -> Array[LDNode] | None:
+        fds: Array[LDNode] = fragment_descriptors
+        vm: LDNode = variable_measured
+        return ResizeArray_appendSingleton(vm, fds)
+
+    variable_measureds: Array[LDNode] | None = (None if (fragment_descriptors is None) else _arrow4383()) if (variable_measured is None) else (_arrow4384() if (fragment_descriptors is None) else _arrow4385())
+    def f_1(c_1: Comment, assay: Any=assay, fs: Any=fs) -> LDNode:
+        return BaseTypes_composeComment_Z13201A7E(c_1)
+
+    comments: Array[LDNode] | None = Option_fromSeq(ResizeArray_map(f_1, assay.Comments))
+    return LDDataset.create_assay(assay.Identifier, None, assay.Title, assay.Description, creators, data_files, measurement_method, measurement_technique, variable_measureds, process_sequence, comments)
+
+
+def AssayConversion_decomposeAssay_Z6839B9E8(assay: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> ArcAssay:
+    def mapping(m: LDNode, assay: Any=assay, graph: Any=graph, context: Any=context) -> OntologyAnnotation:
+        return BaseTypes_decomposeDefinedTerm_Z2F770004(m, context)
+
+    measurement_method: OntologyAnnotation | None = map(mapping, LDDataset.try_get_measurement_method_as_defined_term(assay, graph, context))
+    def mapping_1(m_1: LDNode, assay: Any=assay, graph: Any=graph, context: Any=context) -> OntologyAnnotation:
+        return BaseTypes_decomposeDefinedTerm_Z2F770004(m_1, context)
+
+    measurement_technique: OntologyAnnotation | None = map(mapping_1, LDDataset.try_get_measurement_technique_as_defined_term(assay, graph, context))
+    def mapping_2(v: LDNode, assay: Any=assay, graph: Any=graph, context: Any=context) -> OntologyAnnotation:
+        return BaseTypes_decomposePropertyValueToOA_Z2F770004(v, context)
+
+    variable_measured: OntologyAnnotation | None = map(mapping_2, LDDataset.try_get_variable_measured_as_measurement_type(assay, graph, context))
+    def f(c: LDNode, assay: Any=assay, graph: Any=graph, context: Any=context) -> Person:
+        return PersonConversion_decomposePerson_Z6839B9E8(c, graph, context)
+
+    perfomers: Array[Person] = ResizeArray_map(f, LDDataset.get_creators(assay, graph, context))
+    datamap: Datamap | None
+    v_1: Datamap = DatamapConversion_decomposeFragmentDescriptors_Z6E59645F(LDDataset.get_variable_measured_as_fragment_descriptors(assay, graph, context), graph, context)
+    datamap = Option_fromValueWithDefault(Datamap.init(), v_1)
+    tables: ArcTables = ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586(of_seq(LDDataset.get_abouts_as_lab_process(assay, graph, context)), graph, context)
+    def f_1(c_1: LDNode, assay: Any=assay, graph: Any=graph, context: Any=context) -> Comment:
+        return BaseTypes_decomposeComment_Z2F770004(c_1, context)
+
+    comments: Array[Comment] = ResizeArray_map(f_1, LDDataset.get_comments(assay, graph, context))
+    return ArcAssay.create(LDDataset.get_identifier_as_string(assay, context), LDDataset.try_get_name_as_string(assay, context), LDDataset.try_get_description_as_string(assay, context), variable_measured, measurement_method, measurement_technique, tables.Tables, datamap, perfomers, comments)
+
+
+__all__ = ["AssayConversion_reflection", "AssayConversion_getDataFilesFromProcesses_6BABD1B0", "AssayConversion_composeAssay_Z5C53FD5C", "AssayConversion_decomposeAssay_Z6839B9E8"]
+