arctrl 3.0.0b9__tar.gz → 3.0.0b10__tar.gz

{arctrl-3.0.0b9 → arctrl-3.0.0b10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arctrl
-Version: 3.0.0b9
+Version: 3.0.0b10
 Summary: Library for management of Annotated Research Contexts (ARCs) using an in-memory representation and runtimer agnostic contract systems.
 License-File: LICENSE
 Keywords: arc,annotated research context,isa,research data,multi platform

{arctrl-3.0.0b9 → arctrl-3.0.0b10}/pyproject.toml

@@ -1,43 +1,43 @@
-[project]
-name = "arctrl"
-version = "3.0.0b9"
-description = "Library for management of Annotated Research Contexts (ARCs) using an in-memory representation and runtimer agnostic contract systems."
-authors = [
-    { name = "Heinrich Lukas Weil", email = "weil@rptu.de" },
-    { name = "Kevin Frey", email = "freymaurer@gmx.de" },
-]
-requires-python = ">=3.11"
-readme = "README.md"
-maintainers = [{ name = "Florian Wetzels" }]
-keywords = [
-    "arc",
-    "annotated research context",
-    "isa",
-    "research data",
-    "multi platform",
-]
-dependencies = [
-    "requests>= 2.28.1, <3.0.0",
-    "openpyxl>=3.1.5,<4",
-]
-
-[project.urls]
-Repository = "https://github.com/nfdi4plants/ARCtrl"
-
-[dependency-groups]
-dev = [
-    "pytest>=8.1.1,<9",
-    "twine>=4.0.2"
-]
-
-[tool.poetry]
-include = [
-    "src/ARCtrl/py/**/*.py"
-]
-packages = [
-    { include = "**/*.py", from = "src/ARCtrl/", to = "arctrl" }
-]
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
+[project]
+name = "arctrl"
+version = "3.0.0b10"
+description = "Library for management of Annotated Research Contexts (ARCs) using an in-memory representation and runtimer agnostic contract systems."
+authors = [
+    { name = "Heinrich Lukas Weil", email = "weil@rptu.de" },
+    { name = "Kevin Frey", email = "freymaurer@gmx.de" },
+]
+requires-python = ">=3.11"
+readme = "README.md"
+maintainers = [{ name = "Florian Wetzels" }]
+keywords = [
+    "arc",
+    "annotated research context",
+    "isa",
+    "research data",
+    "multi platform",
+]
+dependencies = [
+    "requests>= 2.28.1, <3.0.0",
+    "openpyxl>=3.1.5,<4",
+]
+
+[project.urls]
+Repository = "https://github.com/nfdi4plants/ARCtrl"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.1.1,<9",
+    "twine>=4.0.2"
+]
+
+[tool.poetry]
+include = [
+    "src/ARCtrl/py/**/*.py"
+]
+packages = [
+    { include = "**/*.py", from = "src/ARCtrl/", to = "arctrl" }
+]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

{arctrl-3.0.0b9 → arctrl-3.0.0b10}/src/ARCtrl/py/CWL/tool_description.py

@@ -7,7 +7,7 @@ from .inputs import CWLInput
 from .outputs import CWLOutput
 from .requirements import Requirement
 
-def _expr3393() -> TypeInfo:
+def _expr3375() -> TypeInfo:
     return class_type("ARCtrl.CWL.CWLToolDescription", None, CWLToolDescription, DynamicObj_reflection())
 
 
@@ -93,7 +93,7 @@ class CWLToolDescription(DynamicObj):
         this._metadata = metadata
 
 
-CWLToolDescription_reflection = _expr3393
+CWLToolDescription_reflection = _expr3375
 
 def CWLToolDescription__ctor_Z3224DB85(outputs: Array[CWLOutput], cwl_version: str | None=None, base_command: Array[str] | None=None, requirements: Array[Requirement] | None=None, hints: Array[Requirement] | None=None, inputs: Array[CWLInput] | None=None, metadata: DynamicObj | None=None) -> CWLToolDescription:
     return CWLToolDescription(outputs, cwl_version, base_command, requirements, hints, inputs, metadata)

{arctrl-3.0.0b9 → arctrl-3.0.0b10}/src/ARCtrl/py/CWL/workflow_description.py

@@ -8,7 +8,7 @@ from .outputs import CWLOutput
 from .requirements import Requirement
 from .workflow_steps import WorkflowStep
 
-def _expr3461() -> TypeInfo:
+def _expr3419() -> TypeInfo:
     return class_type("ARCtrl.CWL.CWLWorkflowDescription", None, CWLWorkflowDescription, DynamicObj_reflection())
 
 
@@ -94,7 +94,7 @@ class CWLWorkflowDescription(DynamicObj):
         this._metadata = metadata
 
 
-CWLWorkflowDescription_reflection = _expr3461
+CWLWorkflowDescription_reflection = _expr3419
 
 def CWLWorkflowDescription__ctor_704BBD06(steps: Array[WorkflowStep], inputs: Array[CWLInput], outputs: Array[CWLOutput], cwl_version: str | None=None, requirements: Array[Requirement] | None=None, hints: Array[Requirement] | None=None, metadata: DynamicObj | None=None) -> CWLWorkflowDescription:
     return CWLWorkflowDescription(steps, inputs, outputs, cwl_version, requirements, hints, metadata)

{arctrl-3.0.0b9 → arctrl-3.0.0b10}/src/ARCtrl/py/Contract/datamap.py

@@ -329,17 +329,17 @@ def ARCtrl_DataMap__DataMap_ToDeleteContractForRun_Z721C83C5(this: DataMap, run_
 
 
 def ARCtrl_DataMap__DataMap_toDeleteContractForRun_Static_Z721C83C5(run_identifier: str) -> Callable[[DataMap], Contract]:
-    def _arrow3623(data_map: DataMap, run_identifier: Any=run_identifier) -> Contract:
+    def _arrow3620(data_map: DataMap, run_identifier: Any=run_identifier) -> Contract:
         return ARCtrl_DataMap__DataMap_ToDeleteContractForRun_Z721C83C5(data_map, run_identifier)
 
-    return _arrow3623
+    return _arrow3620
 
 
 def ARCtrl_DataMap__DataMap_toUpdateContractForRun_Static_Z721C83C5(run_identifier: str) -> Callable[[DataMap], Contract]:
-    def _arrow3624(data_map: DataMap, run_identifier: Any=run_identifier) -> Contract:
+    def _arrow3621(data_map: DataMap, run_identifier: Any=run_identifier) -> Contract:
         return ARCtrl_DataMap__DataMap_ToUpdateContractForRun_Z721C83C5(data_map, run_identifier)
 
-    return _arrow3624
+    return _arrow3621
 
 
 def ARCtrl_DataMap__DataMap_tryFromReadContractForRun_Static(run_identifier: str, c: Contract) -> DataMap | None:
@@ -350,11 +350,11 @@ def ARCtrl_DataMap__DataMap_tryFromReadContractForRun_Static(run_identifier: str
             if c.DTOType.tag == 5:
                 if c.DTO is not None:
                     if c.DTO.tag == 0:
-                        def _arrow3625(__unit: None=None, run_identifier: Any=run_identifier, c: Any=c) -> bool:
+                        def _arrow3622(__unit: None=None, run_identifier: Any=run_identifier, c: Any=c) -> bool:
                             fsworkbook: Any = c.DTO.fields[0]
                             return c.Path == path
 
-                        if _arrow3625():
+                        if _arrow3622():
                             pattern_matching_result = 0
                             fsworkbook_1 = c.DTO.fields[0]
                             p_1 = c.Path

{arctrl-3.0.0b9 → arctrl-3.0.0b10}/src/ARCtrl/py/Contract/license.py

@@ -10,27 +10,27 @@ from .contract import (Contract, DTOType, DTO)
 
 def LicenseContractExtensions__007CLicensePath_007C__007C(input: Array[str]) -> str | None:
     (pattern_matching_result,) = (None,)
-    def _arrow3620(x: str, y: str, input: Any=input) -> bool:
+    def _arrow3623(x: str, y: str, input: Any=input) -> bool:
         return x == y
 
-    if (len(input) == 1) if (not equals_with(_arrow3620, input, None)) else False:
+    if (len(input) == 1) if (not equals_with(_arrow3623, input, None)) else False:
         if input[0] == "LICENSE":
             pattern_matching_result = 0
 
         else: 
-            class ObjectExpr3622:
+            class ObjectExpr3625:
                 @property
                 def Equals(self) -> Callable[[str, str], bool]:
-                    def _arrow3621(x_1: str, y_1: str) -> bool:
+                    def _arrow3624(x_1: str, y_1: str) -> bool:
                         return x_1 == y_1
 
-                    return _arrow3621
+                    return _arrow3624
 
                 @property
                 def GetHashCode(self) -> Callable[[str], int]:
                     return string_hash
 
-            if contains(input[0], alternative_licensefile_names, ObjectExpr3622()):
+            if contains(input[0], alternative_licensefile_names, ObjectExpr3625()):
                 pattern_matching_result = 1
 
             else: 

{arctrl-3.0.0b9 → arctrl-3.0.0b10}/src/ARCtrl/py/ContractIO/contract_io.py

@@ -15,14 +15,14 @@ from .file_system_helper import (read_file_xlsx_async, read_file_text_async, ens
 
 def fulfill_read_contract_async(base_path: str, c: Contract) -> Async[FSharpResult_2[Contract, str]]:
     def f(e_1: Exception, base_path: Any=base_path, c: Any=c) -> FSharpResult_2[Contract, str]:
-        def _arrow3804(__unit: None=None, e_1: Any=e_1) -> str:
+        def _arrow3806(__unit: None=None, e_1: Any=e_1) -> str:
             arg_4: str = str(e_1)
             return to_text(printf("Error reading contract %s: %s"))(c.Path)(arg_4)
 
-        return FSharpResult_2(1, _arrow3804())
+        return FSharpResult_2(1, _arrow3806())
 
-    def _arrow3810(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
-        def _arrow3807(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+    def _arrow3812(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow3809(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
             match_value: DTOType | None = c.DTOType
             (pattern_matching_result,) = (None,)
             if match_value is not None:
@@ -56,37 +56,37 @@ def fulfill_read_contract_async(base_path: str, c: Contract) -> Async[FSharpResu
 
             if pattern_matching_result == 0:
                 path: str = combine(base_path, c.Path)
-                def _arrow3805(_arg: FsWorkbook) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3807(_arg: FsWorkbook) -> Async[FSharpResult_2[Contract, str]]:
                     return singleton.Return(FSharpResult_2(0, Contract(c.Operation, c.Path, c.DTOType, DTO_2(0, _arg))))
 
-                return singleton.Bind(read_file_xlsx_async(path), _arrow3805)
+                return singleton.Bind(read_file_xlsx_async(path), _arrow3807)
 
             elif pattern_matching_result == 1:
                 path_1: str = combine(base_path, c.Path)
-                def _arrow3806(_arg_1: str) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3808(_arg_1: str) -> Async[FSharpResult_2[Contract, str]]:
                     return singleton.Return(FSharpResult_2(0, Contract(c.Operation, c.Path, c.DTOType, DTO_2(1, _arg_1))))
 
-                return singleton.Bind(read_file_text_async(path_1), _arrow3806)
+                return singleton.Bind(read_file_text_async(path_1), _arrow3808)
 
             elif pattern_matching_result == 2:
                 return singleton.Return(FSharpResult_2(1, to_text(printf("Contract %s is neither an ISA nor a freetext contract"))(c.Path)))
 
 
-        def _arrow3809(_arg_2: Exception) -> Async[FSharpResult_2[Contract, str]]:
-            def _arrow3808(__unit: None=None) -> str:
+        def _arrow3811(_arg_2: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow3810(__unit: None=None) -> str:
                 arg_2: str = str(_arg_2)
                 return to_text(printf("Error reading contract %s: %s"))(c.Path)(arg_2)
 
-            return singleton.Return(FSharpResult_2(1, _arrow3808()))
+            return singleton.Return(FSharpResult_2(1, _arrow3810()))
 
-        return singleton.TryWith(singleton.Delay(_arrow3807), _arrow3809)
+        return singleton.TryWith(singleton.Delay(_arrow3809), _arrow3811)
 
-    return catch_with(f, singleton.Delay(_arrow3810))
+    return catch_with(f, singleton.Delay(_arrow3812))
 
 
 def fullfill_contract_batch_async_by(contract_f: Callable[[str, Contract], Async[FSharpResult_2[Contract, str]]], base_path: str, cs: Array[Contract]) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
-    def _arrow3812(__unit: None=None, contract_f: Any=contract_f, base_path: Any=base_path, cs: Any=cs) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
-        def _arrow3811(_arg: Array[FSharpResult_2[Contract, str]]) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
+    def _arrow3814(__unit: None=None, contract_f: Any=contract_f, base_path: Any=base_path, cs: Any=cs) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
+        def _arrow3813(_arg: Array[FSharpResult_2[Contract, str]]) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
             def folder(acc: FSharpResult_2[Array[Contract], Array[str]], cr: FSharpResult_2[Contract, str]) -> FSharpResult_2[Array[Contract], Array[str]]:
                 copy_of_struct: FSharpResult_2[Array[Contract], Array[str]] = acc
                 if copy_of_struct.tag == 1:
@@ -111,112 +111,112 @@ def fullfill_contract_batch_async_by(contract_f: Callable[[str, Contract], Async
             res: FSharpResult_2[Array[Contract], Array[str]] = fold(folder, FSharpResult_2(0, []), _arg)
             return singleton.Return(res)
 
-        return singleton.Bind(start_sequential(curry2(contract_f)(base_path), cs), _arrow3811)
+        return singleton.Bind(start_sequential(curry2(contract_f)(base_path), cs), _arrow3813)
 
-    return singleton.Delay(_arrow3812)
+    return singleton.Delay(_arrow3814)
 
 
 def fulfill_write_contract_async(base_path: str, c: Contract) -> Async[FSharpResult_2[Contract, str]]:
     def f(e_1: Exception, base_path: Any=base_path, c: Any=c) -> FSharpResult_2[Contract, str]:
-        def _arrow3813(__unit: None=None, e_1: Any=e_1) -> str:
+        def _arrow3815(__unit: None=None, e_1: Any=e_1) -> str:
             arg_4: str = str(e_1)
             return to_text(printf("Error writing contract %s: %s"))(c.Path)(arg_4)
 
-        return FSharpResult_2(1, _arrow3813())
+        return FSharpResult_2(1, _arrow3815())
 
-    def _arrow3823(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
-        def _arrow3820(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+    def _arrow3825(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow3822(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
             match_value: DTO_2 | None = c.DTO
             if match_value is None:
                 path_2: str = combine(base_path, c.Path)
-                def _arrow3815(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
-                    def _arrow3814(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3817(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3816(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
                         return singleton.Return(FSharpResult_2(0, c))
 
-                    return singleton.Bind(write_file_text_async(path_2, ""), _arrow3814)
+                    return singleton.Bind(write_file_text_async(path_2, ""), _arrow3816)
 
-                return singleton.Bind(ensure_directory_of_file_async(path_2), _arrow3815)
+                return singleton.Bind(ensure_directory_of_file_async(path_2), _arrow3817)
 
             elif match_value.tag == 1:
                 t: str = match_value.fields[0]
                 path: str = combine(base_path, c.Path)
-                def _arrow3817(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
-                    def _arrow3816(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3819(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3818(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
                         return singleton.Return(FSharpResult_2(0, c))
 
-                    return singleton.Bind(write_file_text_async(path, t), _arrow3816)
+                    return singleton.Bind(write_file_text_async(path, t), _arrow3818)
 
-                return singleton.Bind(ensure_directory_of_file_async(path), _arrow3817)
+                return singleton.Bind(ensure_directory_of_file_async(path), _arrow3819)
 
             elif match_value.tag == 0:
                 wb: Any = match_value.fields[0]
                 path_1: str = combine(base_path, c.Path)
-                def _arrow3819(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
-                    def _arrow3818(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3821(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3820(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
                         return singleton.Return(FSharpResult_2(0, c))
 
-                    return singleton.Bind(write_file_xlsx_async(path_1, wb), _arrow3818)
+                    return singleton.Bind(write_file_xlsx_async(path_1, wb), _arrow3820)
 
-                return singleton.Bind(ensure_directory_of_file_async(path_1), _arrow3819)
+                return singleton.Bind(ensure_directory_of_file_async(path_1), _arrow3821)
 
             else: 
                 return singleton.Return(FSharpResult_2(1, to_text(printf("Contract %s is not an ISA contract"))(c.Path)))
 
 
-        def _arrow3822(_arg_6: Exception) -> Async[FSharpResult_2[Contract, str]]:
-            def _arrow3821(__unit: None=None) -> str:
+        def _arrow3824(_arg_6: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow3823(__unit: None=None) -> str:
                 arg_2: str = str(_arg_6)
                 return to_text(printf("Error writing contract %s: %s"))(c.Path)(arg_2)
 
-            return singleton.Return(FSharpResult_2(1, _arrow3821()))
+            return singleton.Return(FSharpResult_2(1, _arrow3823()))
 
-        return singleton.TryWith(singleton.Delay(_arrow3820), _arrow3822)
+        return singleton.TryWith(singleton.Delay(_arrow3822), _arrow3824)
 
-    return catch_with(f, singleton.Delay(_arrow3823))
+    return catch_with(f, singleton.Delay(_arrow3825))
 
 
 def fulfill_update_contract_async(base_path: str, c: Contract) -> Async[FSharpResult_2[Contract, str]]:
     def f(e_1: Exception, base_path: Any=base_path, c: Any=c) -> FSharpResult_2[Contract, str]:
-        def _arrow3824(__unit: None=None, e_1: Any=e_1) -> str:
+        def _arrow3826(__unit: None=None, e_1: Any=e_1) -> str:
             arg_4: str = str(e_1)
             return to_text(printf("Error updating contract %s: %s"))(c.Path)(arg_4)
 
-        return FSharpResult_2(1, _arrow3824())
+        return FSharpResult_2(1, _arrow3826())
 
     def _arrow3836(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
         def _arrow3833(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
             match_value: DTO_2 | None = c.DTO
             if match_value is None:
                 path_2: str = combine(base_path, c.Path)
-                def _arrow3826(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
-                    def _arrow3825(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3828(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3827(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
                         return singleton.Return(FSharpResult_2(0, c))
 
-                    return singleton.Bind(write_file_text_async(path_2, ""), _arrow3825)
+                    return singleton.Bind(write_file_text_async(path_2, ""), _arrow3827)
 
-                return singleton.Bind(ensure_directory_of_file_async(path_2), _arrow3826)
+                return singleton.Bind(ensure_directory_of_file_async(path_2), _arrow3828)
 
             elif match_value.tag == 1:
                 t: str = match_value.fields[0]
                 path: str = combine(base_path, c.Path)
-                def _arrow3828(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
-                    def _arrow3827(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3830(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3829(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
                         return singleton.Return(FSharpResult_2(0, c))
 
-                    return singleton.Bind(write_file_text_async(path, t), _arrow3827)
+                    return singleton.Bind(write_file_text_async(path, t), _arrow3829)
 
-                return singleton.Bind(ensure_directory_of_file_async(path), _arrow3828)
+                return singleton.Bind(ensure_directory_of_file_async(path), _arrow3830)
 
             elif match_value.tag == 0:
                 wb: Any = match_value.fields[0]
                 path_1: str = combine(base_path, c.Path)
-                def _arrow3831(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
-                    def _arrow3829(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3832(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3831(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
                         return singleton.Return(FSharpResult_2(0, c))
 
-                    return singleton.Bind(write_file_xlsx_async(path_1, wb), _arrow3829)
+                    return singleton.Bind(write_file_xlsx_async(path_1, wb), _arrow3831)
 
-                return singleton.Bind(ensure_directory_of_file_async(path_1), _arrow3831)
+                return singleton.Bind(ensure_directory_of_file_async(path_1), _arrow3832)
 
             else: 
                 return singleton.Return(FSharpResult_2(1, to_text(printf("Contract %s is not an ISA contract"))(c.Path)))

{arctrl-3.0.0b9 → arctrl-3.0.0b10}/src/ARCtrl/py/Core/Process/material.py

@@ -10,7 +10,7 @@ from ..ontology_annotation import OntologyAnnotation
 from .material_attribute_value import (MaterialAttributeValue, MaterialAttributeValue_reflection)
 from .material_type import (MaterialType as MaterialType_1, MaterialType__get_AsString, MaterialType_reflection)
 
-def _expr591() -> TypeInfo:
+def _expr590() -> TypeInfo:
     return record_type("ARCtrl.Process.Material", [], Material, lambda: [("ID", option_type(string_type)), ("Name", option_type(string_type)), ("MaterialType", option_type(MaterialType_reflection())), ("Characteristics", option_type(list_type(MaterialAttributeValue_reflection()))), ("DerivesFrom", option_type(list_type(Material_reflection())))])
 
 
@@ -41,7 +41,7 @@ class Material(Record):
 
 
 
-Material_reflection = _expr591
+Material_reflection = _expr590
 
 def Material_make(id: str | None=None, name: str | None=None, material_type: MaterialType_1 | None=None, characteristics: FSharpList[MaterialAttributeValue] | None=None, derives_from: FSharpList[Material] | None=None) -> Material:
     return Material(id, name, material_type, characteristics, derives_from)

{arctrl-3.0.0b9 → arctrl-3.0.0b10}/src/ARCtrl/py/Core/Process/material_attribute_value.py

@@ -154,11 +154,11 @@ def MaterialAttributeValue__MapCategory_658CFBF6(this: MaterialAttributeValue, f
 
 
 def MaterialAttributeValue__SetCategory_ZDED3A0F(this: MaterialAttributeValue, c: OntologyAnnotation) -> MaterialAttributeValue:
-    def _arrow590(__unit: None=None, this: Any=this, c: Any=c) -> MaterialAttribute | None:
+    def _arrow591(__unit: None=None, this: Any=this, c: Any=c) -> MaterialAttribute | None:
         match_value: MaterialAttribute | None = this.Category
         return MaterialAttribute_create_A220A8A(None, c) if (match_value is None) else MaterialAttribute__SetCategory_ZDED3A0F(match_value, c)
 
-    return MaterialAttributeValue(this.ID, _arrow590(), this.Value, this.Unit)
+    return MaterialAttributeValue(this.ID, _arrow591(), this.Value, this.Unit)
 
 
 def MaterialAttributeValue_tryGetNameText_Z772273B8(mv: MaterialAttributeValue) -> str | None:

{arctrl-3.0.0b9 → arctrl-3.0.0b10}/src/ARCtrl/py/Core/Process/process.py

@@ -442,7 +442,7 @@ def Process_getSamples_763471FF(p: Process) -> FSharpList[Sample]:
     def chooser_1(po: ProcessOutput, p: Any=p) -> Sample | None:
         return ProcessOutput_trySample_Z42C11600(po)
 
-    class ObjectExpr616:
+    class ObjectExpr620:
         @property
         def Equals(self) -> Callable[[Sample, Sample], bool]:
             return equals
@@ -451,7 +451,7 @@ def Process_getSamples_763471FF(p: Process) -> FSharpList[Sample]:
         def GetHashCode(self) -> Callable[[Sample], int]:
             return safe_hash
 
-    return List_distinct(append(choose(chooser, default_arg(p.Inputs, empty())), choose(chooser_1, default_arg(p.Outputs, empty()))), ObjectExpr616())
+    return List_distinct(append(choose(chooser, default_arg(p.Inputs, empty())), choose(chooser_1, default_arg(p.Outputs, empty()))), ObjectExpr620())
 
 
 def Process_getMaterials_763471FF(p: Process) -> FSharpList[Material]:
@@ -461,7 +461,7 @@ def Process_getMaterials_763471FF(p: Process) -> FSharpList[Material]:
     def chooser_1(po: ProcessOutput, p: Any=p) -> Material | None:
         return ProcessOutput_tryMaterial_Z42C11600(po)
 
-    class ObjectExpr617:
+    class ObjectExpr623:
         @property
         def Equals(self) -> Callable[[Material, Material], bool]:
             return equals
@@ -470,7 +470,7 @@ def Process_getMaterials_763471FF(p: Process) -> FSharpList[Material]:
         def GetHashCode(self) -> Callable[[Material], int]:
             return safe_hash
 
-    return List_distinct(append(choose(chooser, default_arg(p.Inputs, empty())), choose(chooser_1, default_arg(p.Outputs, empty()))), ObjectExpr617())
+    return List_distinct(append(choose(chooser, default_arg(p.Inputs, empty())), choose(chooser_1, default_arg(p.Outputs, empty()))), ObjectExpr623())
 
 
 __all__ = ["Process_reflection", "Process_make", "Process_create_Z7C1F7FA9", "Process_get_empty", "Process_composeName", "Process_decomposeName_Z721C83C5", "Process_tryGetProtocolName_763471FF", "Process_getProtocolName_763471FF", "Process_getParameterValues_763471FF", "Process_getParameters_763471FF", "Process_getInputCharacteristicValues_763471FF", "Process_getOutputCharacteristicValues_763471FF", "Process_getCharacteristicValues_763471FF", "Process_getCharacteristics_763471FF", "Process_getFactorValues_763471FF", "Process_getFactors_763471FF", "Process_getUnits_763471FF", "Process_tryGetInputsWithParameterBy", "Process_tryGetOutputsWithParameterBy", "Process_tryGetInputsWithCharacteristicBy", "Process_tryGetOutputsWithCharacteristicBy", "Process_tryGetOutputsWithFactorBy", "Process_getSources_763471FF", "Process_getData_763471FF", "Process_getSamples_763471FF", "Process_getMaterials_763471FF"]

{arctrl-3.0.0b9 → arctrl-3.0.0b10}/src/ARCtrl/py/Core/Process/process_sequence.py

@@ -30,26 +30,26 @@ def get_protocol_names(process_sequence: FSharpList[Process]) -> FSharpList[str]
 
         return bind(binder, p.ExecutesProtocol)
 
-    class ObjectExpr619:
+    class ObjectExpr617:
         @property
         def Equals(self) -> Callable[[str, str], bool]:
-            def _arrow618(x: str, y: str) -> bool:
+            def _arrow616(x: str, y: str) -> bool:
                 return x == y
 
-            return _arrow618
+            return _arrow616
 
         @property
         def GetHashCode(self) -> Callable[[str], int]:
             return string_hash
 
-    return List_distinct(choose(chooser, process_sequence), ObjectExpr619())
+    return List_distinct(choose(chooser, process_sequence), ObjectExpr617())
 
 
 def get_protocols(process_sequence: FSharpList[Process]) -> FSharpList[Protocol]:
     def chooser(p: Process, process_sequence: Any=process_sequence) -> Protocol | None:
         return p.ExecutesProtocol
 
-    class ObjectExpr620:
+    class ObjectExpr618:
         @property
         def Equals(self) -> Callable[[Protocol, Protocol], bool]:
             return equals
@@ -58,7 +58,7 @@ def get_protocols(process_sequence: FSharpList[Process]) -> FSharpList[Protocol]
         def GetHashCode(self) -> Callable[[Protocol], int]:
             return safe_hash
 
-    return List_distinct(choose(chooser, process_sequence), ObjectExpr620())
+    return List_distinct(choose(chooser, process_sequence), ObjectExpr618())
 
 
 def filter_by_protocol_by(predicate: Callable[[Protocol], bool], process_sequence: FSharpList[Process]) -> FSharpList[Process]:
@@ -87,10 +87,10 @@ def filter_by_protocol_by(predicate: Callable[[Protocol], bool], process_sequenc
 
 
 def filter_by_protocol_name(protocol_name: str, process_sequence: FSharpList[Process]) -> FSharpList[Process]:
-    def _arrow621(p: Protocol, protocol_name: Any=protocol_name, process_sequence: Any=process_sequence) -> bool:
+    def _arrow619(p: Protocol, protocol_name: Any=protocol_name, process_sequence: Any=process_sequence) -> bool:
         return equals(p.Name, protocol_name)
 
-    return filter_by_protocol_by(_arrow621, process_sequence)
+    return filter_by_protocol_by(_arrow619, process_sequence)
 
 
 def get_inputs_with_parameter_by(predicate: Callable[[ProtocolParameter], bool], process_sequence: FSharpList[Process]) -> FSharpList[tuple[ProcessInput, ProcessParameterValue]]:
@@ -111,7 +111,7 @@ def get_parameters(process_sequence: FSharpList[Process]) -> FSharpList[Protocol
     def mapping(p: Process, process_sequence: Any=process_sequence) -> FSharpList[ProtocolParameter]:
         return Process_getParameters_763471FF(p)
 
-    class ObjectExpr622:
+    class ObjectExpr621:
         @property
         def Equals(self) -> Callable[[ProtocolParameter, ProtocolParameter], bool]:
             return equals
@@ -120,14 +120,14 @@ def get_parameters(process_sequence: FSharpList[Process]) -> FSharpList[Protocol
         def GetHashCode(self) -> Callable[[ProtocolParameter], int]:
             return safe_hash
 
-    return List_distinct(collect(mapping, process_sequence), ObjectExpr622())
+    return List_distinct(collect(mapping, process_sequence), ObjectExpr621())
 
 
 def get_characteristics(process_sequence: FSharpList[Process]) -> FSharpList[MaterialAttribute]:
     def mapping(p: Process, process_sequence: Any=process_sequence) -> FSharpList[MaterialAttribute]:
         return Process_getCharacteristics_763471FF(p)
 
-    class ObjectExpr623:
+    class ObjectExpr622:
         @property
         def Equals(self) -> Callable[[MaterialAttribute, MaterialAttribute], bool]:
             return equals
@@ -136,7 +136,7 @@ def get_characteristics(process_sequence: FSharpList[Process]) -> FSharpList[Mat
         def GetHashCode(self) -> Callable[[MaterialAttribute], int]:
             return safe_hash
 
-    return List_distinct(collect(mapping, process_sequence), ObjectExpr623())
+    return List_distinct(collect(mapping, process_sequence), ObjectExpr622())
 
 
 def get_inputs_with_characteristic_by(predicate: Callable[[MaterialAttribute], bool], process_sequence: FSharpList[Process]) -> FSharpList[tuple[ProcessInput, MaterialAttributeValue]]: