arctrl 3.0.0__py3-none-any.whl

arctrl/py/Conversion/date_time.py

@@ -0,0 +1,32 @@
+from typing import Any
+from ..Json.decode import Decode_datetime
+from ..Json.encode import date_time
+from ..fable_modules.thoth_json_python.decode import Decode_fromString
+from ..fable_modules.thoth_json_python.encode import to_string as to_string_1
+from ..fable_modules.fable_library.result import FSharpResult_2
+from ..fable_modules.fable_library.string_ import (to_text, printf)
+
+def try_from_string(s: str) -> Any | None:
+    try: 
+        def _arrow4298(__unit: None=None) -> Any:
+            match_value: FSharpResult_2[Any, str] = Decode_fromString(Decode_datetime, s)
+            if match_value.tag == 1:
+                raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+            else: 
+                return match_value.fields[0]
+
+
+        return _arrow4298()
+
+    except Exception as match_value_1:
+        return None
+
+
+
+def to_string(d: Any) -> str:
+    return to_string_1(0, date_time(d))
+
+
+__all__ = ["try_from_string", "to_string"]
+

arctrl/py/Conversion/investigation.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+from typing import Any
+from ..Core.arc_types import (ArcAssay, ArcStudy, ArcWorkflow, ArcRun, ArcInvestigation)
+from ..Core.comment import Comment
+from ..Core.Helper.collections_ import (Option_fromSeq, ResizeArray_map, ResizeArray_choose, ResizeArray_filter)
+from ..Core.person import Person
+from ..Core.publication import Publication
+from ..FileSystem.file_system import FileSystem
+from ..ROCrate.ldcontext import LDContext
+from ..ROCrate.ldobject import (LDNode, LDGraph)
+from ..ROCrate.LDTypes.dataset import LDDataset
+from ..fable_modules.fable_library.date import now
+from ..fable_modules.fable_library.option import (bind, default_arg, value as value_1, map)
+from ..fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..fable_modules.fable_library.seq import (to_list, delay, append)
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import IEnumerable_1
+from .assay import (AssayConversion_composeAssay_Z5C53FD5C, AssayConversion_decomposeAssay_Z6839B9E8)
+from .basic import (BaseTypes_composeComment_Z13201A7E, BaseTypes_decomposeComment_Z2F770004)
+from .date_time import (try_from_string, to_string)
+from .person import (PersonConversion_composePerson_Z64D846DC, PersonConversion_decomposePerson_Z6839B9E8)
+from .run import (RunConversion_composeRun_Z8CC08AC, RunConversion_decomposeRun_Z6839B9E8)
+from .scholarly_article import (ScholarlyArticleConversion_composeScholarlyArticle_D324A6D, ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8)
+from .study import (StudyConversion_composeStudy_ZFE0E38E, StudyConversion_decomposeStudy_Z6839B9E8)
+from .workflow import (WorkflowConversion_composeWorkflow_42450E6E, WorkflowConversion_decomposeWorkflow_Z6839B9E8)
+
+def _expr4414() -> TypeInfo:
+    return class_type("ARCtrl.Conversion.InvestigationConversion", None, InvestigationConversion)
+
+
+class InvestigationConversion:
+    ...
+
+InvestigationConversion_reflection = _expr4414
+
+def InvestigationConversion_composeInvestigation_Z284BC0AC(investigation: ArcInvestigation, fs: FileSystem | None=None, ignore_broken_wr: bool | None=None) -> LDNode:
+    name: str
+    match_value: str | None = investigation.Title
+    if match_value is None:
+        raise Exception("Investigation must have a title")
+
+    else: 
+        name = match_value
+
+    def _arrow4416(s: str, investigation: Any=investigation, fs: Any=fs, ignore_broken_wr: Any=ignore_broken_wr) -> Any | None:
+        return try_from_string(s)
+
+    date_created: Any | None = bind(_arrow4416, investigation.SubmissionDate)
+    def _arrow4417(s_1: str, investigation: Any=investigation, fs: Any=fs, ignore_broken_wr: Any=ignore_broken_wr) -> Any | None:
+        return try_from_string(s_1)
+
+    date_published: Any = default_arg(bind(_arrow4417, investigation.PublicReleaseDate), now())
+    def f(p: Publication, investigation: Any=investigation, fs: Any=fs, ignore_broken_wr: Any=ignore_broken_wr) -> LDNode:
+        return ScholarlyArticleConversion_composeScholarlyArticle_D324A6D(p)
+
+    publications: Array[LDNode] | None = Option_fromSeq(ResizeArray_map(f, investigation.Publications))
+    def f_1(c: Person, investigation: Any=investigation, fs: Any=fs, ignore_broken_wr: Any=ignore_broken_wr) -> LDNode:
+        return PersonConversion_composePerson_Z64D846DC(c)
+
+    creators: Array[LDNode] | None = Option_fromSeq(ResizeArray_map(f_1, investigation.Contacts))
+    def f_2(c_1: Comment, investigation: Any=investigation, fs: Any=fs, ignore_broken_wr: Any=ignore_broken_wr) -> LDNode:
+        return BaseTypes_composeComment_Z13201A7E(c_1)
+
+    comments: Array[LDNode] | None = Option_fromSeq(ResizeArray_map(f_2, investigation.Comments))
+    def _arrow4421(__unit: None=None, investigation: Any=investigation, fs: Any=fs, ignore_broken_wr: Any=ignore_broken_wr) -> IEnumerable_1[LDNode]:
+        def f_3(a_3: ArcAssay) -> LDNode:
+            return AssayConversion_composeAssay_Z5C53FD5C(a_3, fs)
+
+        def _arrow4420(__unit: None=None) -> IEnumerable_1[LDNode]:
+            def f_4(s_2: ArcStudy) -> LDNode:
+                return StudyConversion_composeStudy_ZFE0E38E(s_2, fs)
+
+            def _arrow4419(__unit: None=None) -> IEnumerable_1[LDNode]:
+                def f_5(w: ArcWorkflow) -> LDNode | None:
+                    try: 
+                        return WorkflowConversion_composeWorkflow_42450E6E(w, fs)
+
+                    except Exception as match_value_1:
+                        if value_1(ignore_broken_wr) if (ignore_broken_wr is not None) else False:
+                            return None
+
+                        else: 
+                            raise match_value_1
+
+
+
+                def _arrow4418(__unit: None=None) -> IEnumerable_1[LDNode]:
+                    def f_6(r: ArcRun) -> LDNode | None:
+                        try: 
+                            return RunConversion_composeRun_Z8CC08AC(r, fs)
+
+                        except Exception as match_value_2:
+                            if value_1(ignore_broken_wr) if (ignore_broken_wr is not None) else False:
+                                return None
+
+                            else: 
+                                raise match_value_2
+
+
+
+                    return ResizeArray_choose(f_6, investigation.Runs)
+
+                return append(ResizeArray_choose(f_5, investigation.Workflows), delay(_arrow4418))
+
+            return append(ResizeArray_map(f_4, investigation.Studies), delay(_arrow4419))
+
+        return append(ResizeArray_map(f_3, investigation.Assays), delay(_arrow4420))
+
+    has_parts: Array[LDNode] | None = Option_fromSeq(list(to_list(delay(_arrow4421))))
+    mentions: Array[LDNode] | None = Option_fromSeq([])
+    return LDDataset.create_investigation(investigation.Identifier, name, None, creators, date_created, date_published, None, investigation.Description, has_parts, publications, comments, mentions)
+
+
+def InvestigationConversion_decomposeInvestigation_Z6839B9E8(investigation: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> ArcInvestigation:
+    title: str | None
+    match_value: str | None = LDDataset.try_get_name_as_string(investigation, context)
+    title = LDDataset.try_get_headline_as_string(investigation, context) if (match_value is None) else match_value
+    def _arrow4422(d: Any, investigation: Any=investigation, graph: Any=graph, context: Any=context) -> str:
+        return to_string(d)
+
+    date_created: str | None = map(_arrow4422, LDDataset.try_get_date_created_as_date_time(investigation, context))
+    def _arrow4423(d_1: Any, investigation: Any=investigation, graph: Any=graph, context: Any=context) -> str:
+        return to_string(d_1)
+
+    date_published: str | None = map(_arrow4423, LDDataset.try_get_date_published_as_date_time(investigation, context))
+    def f(p: LDNode, investigation: Any=investigation, graph: Any=graph, context: Any=context) -> Publication:
+        return ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8(p, graph, context)
+
+    publications: Array[Publication] = ResizeArray_map(f, LDDataset.get_citations(investigation, graph, context))
+    def f_1(c: LDNode, investigation: Any=investigation, graph: Any=graph, context: Any=context) -> Person:
+        return PersonConversion_decomposePerson_Z6839B9E8(c, graph, context)
+
+    creators: Array[Person] = ResizeArray_map(f_1, LDDataset.get_creators(investigation, graph, context))
+    datasets: Array[LDNode] = LDDataset.get_has_parts_as_dataset(investigation, graph, context)
+    def f_3(d_3: LDNode, investigation: Any=investigation, graph: Any=graph, context: Any=context) -> ArcStudy:
+        return StudyConversion_decomposeStudy_Z6839B9E8(d_3, graph, context)
+
+    def f_2(d_2: LDNode, investigation: Any=investigation, graph: Any=graph, context: Any=context) -> bool:
+        return LDDataset.validate_study(d_2, context)
+
+    studies: Array[ArcStudy] = ResizeArray_map(f_3, ResizeArray_filter(f_2, datasets))
+    def f_5(d_5: LDNode, investigation: Any=investigation, graph: Any=graph, context: Any=context) -> ArcAssay:
+        return AssayConversion_decomposeAssay_Z6839B9E8(d_5, graph, context)
+
+    def f_4(d_4: LDNode, investigation: Any=investigation, graph: Any=graph, context: Any=context) -> bool:
+        return LDDataset.validate_assay(d_4, context)
+
+    assays: Array[ArcAssay] = ResizeArray_map(f_5, ResizeArray_filter(f_4, datasets))
+    def f_7(d_7: LDNode, investigation: Any=investigation, graph: Any=graph, context: Any=context) -> ArcWorkflow:
+        return WorkflowConversion_decomposeWorkflow_Z6839B9E8(d_7, graph, context)
+
+    def f_6(d_6: LDNode, investigation: Any=investigation, graph: Any=graph, context: Any=context) -> bool:
+        return LDDataset.validate_arcworkflow(d_6, graph, context)
+
+    workflows: Array[ArcWorkflow] = ResizeArray_map(f_7, ResizeArray_filter(f_6, datasets))
+    def f_9(d_9: LDNode, investigation: Any=investigation, graph: Any=graph, context: Any=context) -> ArcRun:
+        return RunConversion_decomposeRun_Z6839B9E8(d_9, graph, context)
+
+    def f_8(d_8: LDNode, investigation: Any=investigation, graph: Any=graph, context: Any=context) -> bool:
+        return LDDataset.validate_arcrun(d_8, context)
+
+    runs: Array[ArcRun] = ResizeArray_map(f_9, ResizeArray_filter(f_8, datasets))
+    def f_10(c_1: LDNode, investigation: Any=investigation, graph: Any=graph, context: Any=context) -> Comment:
+        return BaseTypes_decomposeComment_Z2F770004(c_1, context)
+
+    comments: Array[Comment] = ResizeArray_map(f_10, LDDataset.get_comments(investigation, graph, context))
+    return ArcInvestigation.create(LDDataset.get_identifier_as_string(investigation, context), title, LDDataset.try_get_description_as_string(investigation, context), date_created, date_published, None, publications, creators, assays, studies, workflows, runs, None, comments)
+
+
+__all__ = ["InvestigationConversion_reflection", "InvestigationConversion_composeInvestigation_Z284BC0AC", "InvestigationConversion_decomposeInvestigation_Z6839B9E8"]
+

arctrl/py/Conversion/person.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+from typing import Any
+from ..Core.comment import Comment
+from ..Core.Helper.collections_ import (Option_fromSeq, ResizeArray_map)
+from ..Core.Helper.orcid import try_get_orcid_number
+from ..Core.ontology_annotation import OntologyAnnotation
+from ..Core.person import Person
+from ..Json.ROCrate.ldnode import (decoder as decoder_1, encoder)
+from ..ROCrate.ldcontext import LDContext
+from ..ROCrate.ldobject import (LDNode, LDGraph)
+from ..ROCrate.LDTypes.organization import LDOrganization
+from ..ROCrate.LDTypes.person import LDPerson
+from ..fable_modules.thoth_json_python.decode import Decode_fromString
+from ..fable_modules.thoth_json_python.encode import to_string
+from ..fable_modules.fable_library.option import map
+from ..fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..fable_modules.fable_library.result import FSharpResult_2
+from ..fable_modules.fable_library.seq import (is_empty, filter)
+from ..fable_modules.fable_library.string_ import (to_text, printf)
+from ..fable_modules.fable_library.types import (Array, to_string as to_string_1)
+from .basic import (BaseTypes_composeDefinedTerm_ZDED3A0F, BaseTypes_decomposeDefinedTerm_Z2F770004)
+
+def _expr4317() -> TypeInfo:
+    return class_type("ARCtrl.Conversion.PersonConversion", None, PersonConversion)
+
+
+class PersonConversion:
+    ...
+
+PersonConversion_reflection = _expr4317
+
+def PersonConversion_get_orcidKey(__unit: None=None) -> str:
+    return "ORCID"
+
+
+def PersonConversion_composeAffiliation_Z721C83C5(affiliation: str) -> LDNode:
+    try: 
+        match_value: FSharpResult_2[LDNode, str] = Decode_fromString(decoder_1, affiliation)
+        if match_value.tag == 1:
+            raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+        else: 
+            return match_value.fields[0]
+
+
+    except Exception as match_value_1:
+        return LDOrganization.create(affiliation)
+
+
+
+def PersonConversion_decomposeAffiliation_Z2F770004(affiliation: LDNode, context: LDContext | None=None) -> str:
+    def predicate(n: str, affiliation: Any=affiliation, context: Any=context) -> bool:
+        return n != LDOrganization.name()
+
+    if is_empty(filter(predicate, affiliation.GetPropertyNames(context))):
+        return LDOrganization.get_name_as_string(affiliation, context)
+
+    else: 
+        return to_string(0, encoder(affiliation))
+
+
+
+def PersonConversion_composeAddress_Z721C83C5(address: str) -> Any:
+    try: 
+        def _arrow4323(__unit: None=None) -> LDNode:
+            match_value: FSharpResult_2[LDNode, str] = Decode_fromString(decoder_1, address)
+            if match_value.tag == 1:
+                raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+            else: 
+                return match_value.fields[0]
+
+
+        return _arrow4323()
+
+    except Exception as match_value_1:
+        return address
+
+
+
+def PersonConversion_decomposeAddress_4E60E31B(address: Any=None) -> str:
+    if str(type(address)) == "<class \'str\'>":
+        return address
+
+    elif isinstance(address, LDNode):
+        return to_string(0, encoder(address))
+
+    else: 
+        raise Exception("Address must be a string or a Json.LDNode")
+
+
+
+def PersonConversion_composePerson_Z64D846DC(person: Person) -> LDNode:
+    given_name: str
+    match_value: str | None = person.FirstName
+    if match_value is None:
+        raise Exception("Person must have a given name")
+
+    else: 
+        given_name = match_value
+
+    def f(term: OntologyAnnotation, person: Any=person) -> LDNode:
+        return BaseTypes_composeDefinedTerm_ZDED3A0F(term)
+
+    job_titles: Array[LDNode] | None = Option_fromSeq(ResizeArray_map(f, person.Roles))
+    def f_1(c: Comment, person: Any=person) -> str:
+        return to_string_1(c)
+
+    disambiguating_descriptions: Array[str] | None = Option_fromSeq(ResizeArray_map(f_1, person.Comments))
+    def mapping(address: str, person: Any=person) -> Any:
+        return PersonConversion_composeAddress_Z721C83C5(address)
+
+    address_1: Any | None = map(mapping, person.Address)
+    def mapping_1(affiliation: str, person: Any=person) -> LDNode:
+        return PersonConversion_composeAffiliation_Z721C83C5(affiliation)
+
+    affiliation_1: LDNode | None = map(mapping_1, person.Affiliation)
+    return LDPerson.create(given_name, person.ORCID, None, affiliation_1, person.EMail, person.LastName, None, job_titles, person.MidInitials, address_1, disambiguating_descriptions, person.Fax, person.Phone)
+
+
+def PersonConversion_decomposePerson_Z6839B9E8(person: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Person:
+    orcid: str | None = try_get_orcid_number(person.Id)
+    address: str | None
+    match_value: str | None = LDPerson.try_get_address_as_string(person, context)
+    if match_value is None:
+        match_value_1: LDNode | None = LDPerson.try_get_address_as_postal_address(person, graph, context)
+        address = None if (match_value_1 is None) else PersonConversion_decomposeAddress_4E60E31B(match_value_1)
+
+    else: 
+        address = match_value
+
+    def f(r: LDNode, person: Any=person, graph: Any=graph, context: Any=context) -> OntologyAnnotation:
+        return BaseTypes_decomposeDefinedTerm_Z2F770004(r, context)
+
+    roles: Array[OntologyAnnotation] = ResizeArray_map(f, LDPerson.get_job_titles_as_defined_term(person, graph, context))
+    def f_1(s_1: str, person: Any=person, graph: Any=graph, context: Any=context) -> Comment:
+        return Comment.from_string(s_1)
+
+    comments: Array[Comment] = ResizeArray_map(f_1, LDPerson.get_disambiguating_descriptions_as_string(person, context))
+    def mapping(a_3: LDNode, person: Any=person, graph: Any=graph, context: Any=context) -> str:
+        return PersonConversion_decomposeAffiliation_Z2F770004(a_3, context)
+
+    affiliation: str | None = map(mapping, LDPerson.try_get_affiliation(person, graph, context))
+    return Person.create(orcid, LDPerson.try_get_family_name_as_string(person, context), LDPerson.get_given_name_as_string(person, context), LDPerson.try_get_additional_name_as_string(person, context), LDPerson.try_get_email_as_string(person, context), LDPerson.try_get_telephone_as_string(person, context), LDPerson.try_get_fax_number_as_string(person, context), address, affiliation, roles, comments)
+
+
+__all__ = ["PersonConversion_reflection", "PersonConversion_get_orcidKey", "PersonConversion_composeAffiliation_Z721C83C5", "PersonConversion_decomposeAffiliation_Z2F770004", "PersonConversion_composeAddress_Z721C83C5", "PersonConversion_decomposeAddress_4E60E31B", "PersonConversion_composePerson_Z64D846DC", "PersonConversion_decomposePerson_Z6839B9E8"]
+