arctrl 3.0.0__py3-none-any.whl

arctrl/py/Core/Process/process_sequence.py

@@ -0,0 +1,435 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...fable_modules.fable_library.list import (choose, FSharpList, filter, concat, collect, empty, map, zip, singleton)
+from ...fable_modules.fable_library.map import (of_list as of_list_1, FSharpMap__TryFind)
+from ...fable_modules.fable_library.option import (bind, default_arg, value as value_4)
+from ...fable_modules.fable_library.seq2 import (List_distinct, List_groupBy)
+from ...fable_modules.fable_library.set import (of_list, FSharpSet__Contains)
+from ...fable_modules.fable_library.util import (string_hash, equals, safe_hash, compare_primitives, equal_arrays, array_hash)
+from ..data import Data
+from ..ontology_annotation import OntologyAnnotation
+from .factor import Factor
+from .factor_value import FactorValue
+from .material import Material
+from .material_attribute import MaterialAttribute
+from .material_attribute_value import MaterialAttributeValue
+from .process import (Process, Process_tryGetInputsWithParameterBy, Process_tryGetOutputsWithParameterBy, Process_getParameters_763471FF, Process_getCharacteristics_763471FF, Process_tryGetInputsWithCharacteristicBy, Process_tryGetOutputsWithCharacteristicBy, Process_tryGetOutputsWithFactorBy, Process_getFactors_763471FF, Process_getUnits_763471FF, Process_getData_763471FF, Process_getSources_763471FF, Process_getSamples_763471FF, Process_getMaterials_763471FF)
+from .process_input import (ProcessInput, ProcessInput_getName_5B3D5BA9, ProcessInput__get_Name)
+from .process_output import (ProcessOutput, ProcessOutput_getName_Z42C11600, ProcessOutput__get_Name)
+from .process_parameter_value import ProcessParameterValue
+from .protocol import Protocol
+from .protocol_parameter import ProtocolParameter
+from .sample import Sample
+from .source import Source
+
+def get_protocol_names(process_sequence: FSharpList[Process]) -> FSharpList[str]:
+    def chooser(p: Process, process_sequence: Any=process_sequence) -> str | None:
+        def binder(protocol: Protocol, p: Any=p) -> str | None:
+            return protocol.Name
+
+        return bind(binder, p.ExecutesProtocol)
+
+    class ObjectExpr1113:
+        @property
+        def Equals(self) -> Callable[[str, str], bool]:
+            def _arrow1112(x: str, y: str) -> bool:
+                return x == y
+
+            return _arrow1112
+
+        @property
+        def GetHashCode(self) -> Callable[[str], int]:
+            return string_hash
+
+    return List_distinct(choose(chooser, process_sequence), ObjectExpr1113())
+
+
+def get_protocols(process_sequence: FSharpList[Process]) -> FSharpList[Protocol]:
+    def chooser(p: Process, process_sequence: Any=process_sequence) -> Protocol | None:
+        return p.ExecutesProtocol
+
+    class ObjectExpr1114:
+        @property
+        def Equals(self) -> Callable[[Protocol, Protocol], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[Protocol], int]:
+            return safe_hash
+
+    return List_distinct(choose(chooser, process_sequence), ObjectExpr1114())
+
+
+def filter_by_protocol_by(predicate: Callable[[Protocol], bool], process_sequence: FSharpList[Process]) -> FSharpList[Process]:
+    def predicate_1(p: Process, predicate: Any=predicate, process_sequence: Any=process_sequence) -> bool:
+        match_value: Protocol | None = p.ExecutesProtocol
+        (pattern_matching_result,) = (None,)
+        if match_value is not None:
+            if predicate(match_value):
+                pattern_matching_result = 0
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return True
+
+        elif pattern_matching_result == 1:
+            return False
+
+
+    return filter(predicate_1, process_sequence)
+
+
+def filter_by_protocol_name(protocol_name: str, process_sequence: FSharpList[Process]) -> FSharpList[Process]:
+    def _arrow1115(p: Protocol, protocol_name: Any=protocol_name, process_sequence: Any=process_sequence) -> bool:
+        return equals(p.Name, protocol_name)
+
+    return filter_by_protocol_by(_arrow1115, process_sequence)
+
+
+def get_inputs_with_parameter_by(predicate: Callable[[ProtocolParameter], bool], process_sequence: FSharpList[Process]) -> FSharpList[tuple[ProcessInput, ProcessParameterValue]]:
+    def chooser(p: Process, predicate: Any=predicate, process_sequence: Any=process_sequence) -> FSharpList[tuple[ProcessInput, ProcessParameterValue]] | None:
+        return Process_tryGetInputsWithParameterBy(predicate, p)
+
+    return concat(choose(chooser, process_sequence))
+
+
+def get_outputs_with_parameter_by(predicate: Callable[[ProtocolParameter], bool], process_sequence: FSharpList[Process]) -> FSharpList[tuple[ProcessOutput, ProcessParameterValue]]:
+    def chooser(p: Process, predicate: Any=predicate, process_sequence: Any=process_sequence) -> FSharpList[tuple[ProcessOutput, ProcessParameterValue]] | None:
+        return Process_tryGetOutputsWithParameterBy(predicate, p)
+
+    return concat(choose(chooser, process_sequence))
+
+
+def get_parameters(process_sequence: FSharpList[Process]) -> FSharpList[ProtocolParameter]:
+    def mapping(p: Process, process_sequence: Any=process_sequence) -> FSharpList[ProtocolParameter]:
+        return Process_getParameters_763471FF(p)
+
+    class ObjectExpr1116:
+        @property
+        def Equals(self) -> Callable[[ProtocolParameter, ProtocolParameter], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[ProtocolParameter], int]:
+            return safe_hash
+
+    return List_distinct(collect(mapping, process_sequence), ObjectExpr1116())
+
+
+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 ObjectExpr1117:
+        @property
+        def Equals(self) -> Callable[[MaterialAttribute, MaterialAttribute], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[MaterialAttribute], int]:
+            return safe_hash
+
+    return List_distinct(collect(mapping, process_sequence), ObjectExpr1117())
+
+
+def get_inputs_with_characteristic_by(predicate: Callable[[MaterialAttribute], bool], process_sequence: FSharpList[Process]) -> FSharpList[tuple[ProcessInput, MaterialAttributeValue]]:
+    def chooser(p: Process, predicate: Any=predicate, process_sequence: Any=process_sequence) -> FSharpList[tuple[ProcessInput, MaterialAttributeValue]] | None:
+        return Process_tryGetInputsWithCharacteristicBy(predicate, p)
+
+    return concat(choose(chooser, process_sequence))
+
+
+def get_outputs_with_characteristic_by(predicate: Callable[[MaterialAttribute], bool], process_sequence: FSharpList[Process]) -> FSharpList[tuple[ProcessOutput, MaterialAttributeValue]]:
+    def chooser(p: Process, predicate: Any=predicate, process_sequence: Any=process_sequence) -> FSharpList[tuple[ProcessOutput, MaterialAttributeValue]] | None:
+        return Process_tryGetOutputsWithCharacteristicBy(predicate, p)
+
+    return concat(choose(chooser, process_sequence))
+
+
+def get_outputs_with_factor_by(predicate: Callable[[Factor], bool], process_sequence: FSharpList[Process]) -> FSharpList[tuple[ProcessOutput, FactorValue]]:
+    def chooser(p: Process, predicate: Any=predicate, process_sequence: Any=process_sequence) -> FSharpList[tuple[ProcessOutput, FactorValue]] | None:
+        return Process_tryGetOutputsWithFactorBy(predicate, p)
+
+    return concat(choose(chooser, process_sequence))
+
+
+def get_factors(process_sequence: FSharpList[Process]) -> FSharpList[Factor]:
+    def mapping(p: Process, process_sequence: Any=process_sequence) -> FSharpList[Factor]:
+        return Process_getFactors_763471FF(p)
+
+    class ObjectExpr1118:
+        @property
+        def Equals(self) -> Callable[[Factor, Factor], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[Factor], int]:
+            return safe_hash
+
+    return List_distinct(collect(mapping, process_sequence), ObjectExpr1118())
+
+
+def get_root_inputs(process_sequence: FSharpList[Process]) -> FSharpList[ProcessInput]:
+    def mapping(p: Process, process_sequence: Any=process_sequence) -> FSharpList[ProcessInput]:
+        return default_arg(p.Inputs, empty())
+
+    inputs: FSharpList[ProcessInput] = collect(mapping, process_sequence)
+    def mapping_2(p_1: Process, process_sequence: Any=process_sequence) -> FSharpList[str]:
+        def mapping_1(po: ProcessOutput, p_1: Any=p_1) -> str:
+            return ProcessOutput_getName_Z42C11600(po)
+
+        return map(mapping_1, default_arg(p_1.Outputs, empty()))
+
+    class ObjectExpr1119:
+        @property
+        def Compare(self) -> Callable[[str, str], int]:
+            return compare_primitives
+
+    outputs: Any = of_list(collect(mapping_2, process_sequence), ObjectExpr1119())
+    def predicate(i: ProcessInput, process_sequence: Any=process_sequence) -> bool:
+        return not FSharpSet__Contains(outputs, ProcessInput_getName_5B3D5BA9(i))
+
+    return filter(predicate, inputs)
+
+
+def get_final_outputs(process_sequence: FSharpList[Process]) -> FSharpList[ProcessOutput]:
+    def mapping_1(p: Process, process_sequence: Any=process_sequence) -> FSharpList[str]:
+        def mapping(pi: ProcessInput, p: Any=p) -> str:
+            return ProcessInput_getName_5B3D5BA9(pi)
+
+        return map(mapping, default_arg(p.Inputs, empty()))
+
+    class ObjectExpr1120:
+        @property
+        def Compare(self) -> Callable[[str, str], int]:
+            return compare_primitives
+
+    inputs: Any = of_list(collect(mapping_1, process_sequence), ObjectExpr1120())
+    def predicate(o: ProcessOutput, process_sequence: Any=process_sequence) -> bool:
+        return not FSharpSet__Contains(inputs, ProcessOutput_getName_Z42C11600(o))
+
+    def mapping_2(p_1: Process, process_sequence: Any=process_sequence) -> FSharpList[ProcessOutput]:
+        return default_arg(p_1.Outputs, empty())
+
+    return filter(predicate, collect(mapping_2, process_sequence))
+
+
+def get_root_input_of(process_sequence: FSharpList[Process], sample: str) -> FSharpList[str]:
+    def mapping_4(tupled_arg: tuple[str, FSharpList[tuple[str, str]]], process_sequence: Any=process_sequence, sample: Any=sample) -> tuple[str, FSharpList[str]]:
+        def mapping_3(tuple_1: tuple[str, str], tupled_arg: Any=tupled_arg) -> str:
+            return tuple_1[1]
+
+        return (tupled_arg[0], map(mapping_3, tupled_arg[1]))
+
+    def projection(tuple: tuple[str, str], process_sequence: Any=process_sequence, sample: Any=sample) -> str:
+        return tuple[0]
+
+    def mapping_2(p: Process, process_sequence: Any=process_sequence, sample: Any=sample) -> FSharpList[tuple[str, str]]:
+        def mapping(o: ProcessOutput, p: Any=p) -> str:
+            return ProcessOutput__get_Name(o)
+
+        def mapping_1(i: ProcessInput, p: Any=p) -> str:
+            return ProcessInput__get_Name(i)
+
+        class ObjectExpr1121:
+            @property
+            def Equals(self) -> Callable[[tuple[str, str], tuple[str, str]], bool]:
+                return equal_arrays
+
+            @property
+            def GetHashCode(self) -> Callable[[tuple[str, str]], int]:
+                return array_hash
+
+        return List_distinct(zip(map(mapping, value_4(p.Outputs)), map(mapping_1, value_4(p.Inputs))), ObjectExpr1121())
+
+    class ObjectExpr1123:
+        @property
+        def Equals(self) -> Callable[[str, str], bool]:
+            def _arrow1122(x_1: str, y_1: str) -> bool:
+                return x_1 == y_1
+
+            return _arrow1122
+
+        @property
+        def GetHashCode(self) -> Callable[[str], int]:
+            return string_hash
+
+    class ObjectExpr1124:
+        @property
+        def Compare(self) -> Callable[[str, str], int]:
+            return compare_primitives
+
+    mappings: Any = of_list_1(map(mapping_4, List_groupBy(projection, collect(mapping_2, process_sequence), ObjectExpr1123())), ObjectExpr1124())
+    def loop(last_state_mut: FSharpList[str], state_mut: FSharpList[str], process_sequence: Any=process_sequence, sample: Any=sample) -> FSharpList[str]:
+        while True:
+            (last_state, state) = (last_state_mut, state_mut)
+            if equals(last_state, state):
+                return state
+
+            else: 
+                last_state_mut = state
+                def mapping_5(s: str, last_state: Any=last_state, state: Any=state) -> FSharpList[str]:
+                    return default_arg(FSharpMap__TryFind(mappings, s), singleton(s))
+
+                state_mut = collect(mapping_5, state)
+                continue
+
+            break
+
+    return loop(empty(), singleton(sample))
+
+
+def get_final_outputs_of(process_sequence: FSharpList[Process], sample: str) -> FSharpList[str]:
+    def mapping_4(tupled_arg: tuple[str, FSharpList[tuple[str, str]]], process_sequence: Any=process_sequence, sample: Any=sample) -> tuple[str, FSharpList[str]]:
+        def mapping_3(tuple_1: tuple[str, str], tupled_arg: Any=tupled_arg) -> str:
+            return tuple_1[1]
+
+        return (tupled_arg[0], map(mapping_3, tupled_arg[1]))
+
+    def projection(tuple: tuple[str, str], process_sequence: Any=process_sequence, sample: Any=sample) -> str:
+        return tuple[0]
+
+    def mapping_2(p: Process, process_sequence: Any=process_sequence, sample: Any=sample) -> FSharpList[tuple[str, str]]:
+        def mapping(i: ProcessInput, p: Any=p) -> str:
+            return ProcessInput__get_Name(i)
+
+        def mapping_1(o: ProcessOutput, p: Any=p) -> str:
+            return ProcessOutput__get_Name(o)
+
+        class ObjectExpr1125:
+            @property
+            def Equals(self) -> Callable[[tuple[str, str], tuple[str, str]], bool]:
+                return equal_arrays
+
+            @property
+            def GetHashCode(self) -> Callable[[tuple[str, str]], int]:
+                return array_hash
+
+        return List_distinct(zip(map(mapping, value_4(p.Inputs)), map(mapping_1, value_4(p.Outputs))), ObjectExpr1125())
+
+    class ObjectExpr1127:
+        @property
+        def Equals(self) -> Callable[[str, str], bool]:
+            def _arrow1126(x_1: str, y_1: str) -> bool:
+                return x_1 == y_1
+
+            return _arrow1126
+
+        @property
+        def GetHashCode(self) -> Callable[[str], int]:
+            return string_hash
+
+    class ObjectExpr1128:
+        @property
+        def Compare(self) -> Callable[[str, str], int]:
+            return compare_primitives
+
+    mappings: Any = of_list_1(map(mapping_4, List_groupBy(projection, collect(mapping_2, process_sequence), ObjectExpr1127())), ObjectExpr1128())
+    def loop(last_state_mut: FSharpList[str], state_mut: FSharpList[str], process_sequence: Any=process_sequence, sample: Any=sample) -> FSharpList[str]:
+        while True:
+            (last_state, state) = (last_state_mut, state_mut)
+            if equals(last_state, state):
+                return state
+
+            else: 
+                last_state_mut = state
+                def mapping_5(s: str, last_state: Any=last_state, state: Any=state) -> FSharpList[str]:
+                    return default_arg(FSharpMap__TryFind(mappings, s), singleton(s))
+
+                state_mut = collect(mapping_5, state)
+                continue
+
+            break
+
+    return loop(empty(), singleton(sample))
+
+
+def get_units(process_sequence: FSharpList[Process]) -> FSharpList[OntologyAnnotation]:
+    def _arrow1129(p: Process, process_sequence: Any=process_sequence) -> FSharpList[OntologyAnnotation]:
+        return Process_getUnits_763471FF(p)
+
+    class ObjectExpr1130:
+        @property
+        def Equals(self) -> Callable[[OntologyAnnotation, OntologyAnnotation], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[OntologyAnnotation], int]:
+            return safe_hash
+
+    return List_distinct(collect(_arrow1129, process_sequence), ObjectExpr1130())
+
+
+def get_data(process_sequence: FSharpList[Process]) -> FSharpList[Data]:
+    def mapping(p: Process, process_sequence: Any=process_sequence) -> FSharpList[Data]:
+        return Process_getData_763471FF(p)
+
+    class ObjectExpr1131:
+        @property
+        def Equals(self) -> Callable[[Data, Data], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[Data], int]:
+            return safe_hash
+
+    return List_distinct(collect(mapping, process_sequence), ObjectExpr1131())
+
+
+def get_sources(process_sequence: FSharpList[Process]) -> FSharpList[Source]:
+    def mapping(p: Process, process_sequence: Any=process_sequence) -> FSharpList[Source]:
+        return Process_getSources_763471FF(p)
+
+    class ObjectExpr1132:
+        @property
+        def Equals(self) -> Callable[[Source, Source], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[Source], int]:
+            return safe_hash
+
+    return List_distinct(collect(mapping, process_sequence), ObjectExpr1132())
+
+
+def get_samples(process_sequence: FSharpList[Process]) -> FSharpList[Sample]:
+    def mapping(p: Process, process_sequence: Any=process_sequence) -> FSharpList[Sample]:
+        return Process_getSamples_763471FF(p)
+
+    class ObjectExpr1133:
+        @property
+        def Equals(self) -> Callable[[Sample, Sample], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[Sample], int]:
+            return safe_hash
+
+    return List_distinct(collect(mapping, process_sequence), ObjectExpr1133())
+
+
+def get_materials(process_sequence: FSharpList[Process]) -> FSharpList[Material]:
+    def mapping(p: Process, process_sequence: Any=process_sequence) -> FSharpList[Material]:
+        return Process_getMaterials_763471FF(p)
+
+    class ObjectExpr1134:
+        @property
+        def Equals(self) -> Callable[[Material, Material], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[Material], int]:
+            return safe_hash
+
+    return List_distinct(collect(mapping, process_sequence), ObjectExpr1134())
+
+
+__all__ = ["get_protocol_names", "get_protocols", "filter_by_protocol_by", "filter_by_protocol_name", "get_inputs_with_parameter_by", "get_outputs_with_parameter_by", "get_parameters", "get_characteristics", "get_inputs_with_characteristic_by", "get_outputs_with_characteristic_by", "get_outputs_with_factor_by", "get_factors", "get_root_inputs", "get_final_outputs", "get_root_input_of", "get_final_outputs_of", "get_units", "get_data", "get_sources", "get_samples", "get_materials"]
+

arctrl/py/Core/Process/protocol.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+from ...fable_modules.fable_library.list import (FSharpList, try_find, exists, append, singleton, filter, empty)
+from ...fable_modules.fable_library.option import (map, default_arg)
+from ...fable_modules.fable_library.reflection import (TypeInfo, string_type, option_type, list_type, record_type)
+from ...fable_modules.fable_library.types import Record
+from ...fable_modules.fable_library.util import equals
+from ..comment import (Comment, Comment_reflection)
+from ..ontology_annotation import (OntologyAnnotation, OntologyAnnotation_reflection)
+from .component import (Component, Component_reflection)
+from .protocol_parameter import (ProtocolParameter, ProtocolParameter_reflection)
+
+def _expr1090() -> TypeInfo:
+    return record_type("ARCtrl.Process.Protocol", [], Protocol, lambda: [("ID", option_type(string_type)), ("Name", option_type(string_type)), ("ProtocolType", option_type(OntologyAnnotation_reflection())), ("Description", option_type(string_type)), ("Uri", option_type(string_type)), ("Version", option_type(string_type)), ("Parameters", option_type(list_type(ProtocolParameter_reflection()))), ("Components", option_type(list_type(Component_reflection()))), ("Comments", option_type(list_type(Comment_reflection())))])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class Protocol(Record):
+    ID: str | None
+    Name: str | None
+    ProtocolType: OntologyAnnotation | None
+    Description: str | None
+    Uri: str | None
+    Version: str | None
+    Parameters: FSharpList[ProtocolParameter] | None
+    Components: FSharpList[Component] | None
+    Comments: FSharpList[Comment] | None
+
+Protocol_reflection = _expr1090
+
+def Protocol_make(id: str | None=None, name: str | None=None, protocol_type: OntologyAnnotation | None=None, description: str | None=None, uri: str | None=None, version: str | None=None, parameters: FSharpList[ProtocolParameter] | None=None, components: FSharpList[Component] | None=None, comments: FSharpList[Comment] | None=None) -> Protocol:
+    return Protocol(id, name, protocol_type, description, uri, version, parameters, components, comments)
+
+
+def Protocol_create_Z414665E7(Id: str | None=None, Name: str | None=None, ProtocolType: OntologyAnnotation | None=None, Description: str | None=None, Uri: str | None=None, Version: str | None=None, Parameters: FSharpList[ProtocolParameter] | None=None, Components: FSharpList[Component] | None=None, Comments: FSharpList[Comment] | None=None) -> Protocol:
+    return Protocol_make(Id, Name, ProtocolType, Description, Uri, Version, Parameters, Components, Comments)
+
+
+def Protocol_get_empty(__unit: None=None) -> Protocol:
+    return Protocol_create_Z414665E7()
+
+
+def Protocol_tryGetByName(name: str, protocols: FSharpList[Protocol]) -> Protocol | None:
+    def _arrow1091(p: Protocol, name: Any=name, protocols: Any=protocols) -> bool:
+        return equals(p.Name, name)
+
+    return try_find(_arrow1091, protocols)
+
+
+def Protocol_existsByName(name: str, protocols: FSharpList[Protocol]) -> bool:
+    def _arrow1092(p: Protocol, name: Any=name, protocols: Any=protocols) -> bool:
+        return equals(p.Name, name)
+
+    return exists(_arrow1092, protocols)
+
+
+def Protocol_add(protocols: FSharpList[Protocol], protocol: Protocol) -> FSharpList[Protocol]:
+    return append(protocols, singleton(protocol))
+
+
+def Protocol_removeByName(name: str, protocols: FSharpList[Protocol]) -> FSharpList[Protocol]:
+    def _arrow1093(p: Protocol, name: Any=name, protocols: Any=protocols) -> bool:
+        return not equals(p.Name, name)
+
+    return filter(_arrow1093, protocols)
+
+
+def Protocol_getComments_3BF20962(protocol: Protocol) -> FSharpList[Comment] | None:
+    return protocol.Comments
+
+
+def Protocol_mapComments(f: Callable[[FSharpList[Comment]], FSharpList[Comment]], protocol: Protocol) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, map(f, protocol.Comments))
+
+
+def Protocol_setComments(protocol: Protocol, comments: FSharpList[Comment]) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, comments)
+
+
+def Protocol_getProtocolType_3BF20962(protocol: Protocol) -> OntologyAnnotation | None:
+    return protocol.ProtocolType
+
+
+def Protocol_mapProtocolType(f: Callable[[OntologyAnnotation], OntologyAnnotation], protocol: Protocol) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, map(f, protocol.ProtocolType), protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments)
+
+
+def Protocol_setProtocolType(protocol: Protocol, protocol_type: OntologyAnnotation) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, protocol_type, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments)
+
+
+def Protocol_getVersion_3BF20962(protocol: Protocol) -> str | None:
+    return protocol.Version
+
+
+def Protocol_mapVersion(f: Callable[[str], str], protocol: Protocol) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, map(f, protocol.Version), protocol.Parameters, protocol.Components, protocol.Comments)
+
+
+def Protocol_setVersion(protocol: Protocol, version: str) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, version, protocol.Parameters, protocol.Components, protocol.Comments)
+
+
+def Protocol_getName_3BF20962(protocol: Protocol) -> str | None:
+    return protocol.Name
+
+
+def Protocol_mapName(f: Callable[[str], str], protocol: Protocol) -> Protocol:
+    return Protocol(protocol.ID, map(f, protocol.Name), protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments)
+
+
+def Protocol_setName(protocol: Protocol, name: str) -> Protocol:
+    return Protocol(protocol.ID, name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments)
+
+
+def Protocol_getDescription_3BF20962(protocol: Protocol) -> str | None:
+    return protocol.Description
+
+
+def Protocol_mapDescription(f: Callable[[str], str], protocol: Protocol) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, map(f, protocol.Description), protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments)
+
+
+def Protocol_setDescription(protocol: Protocol, description: str) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments)
+
+
+def Protocol_getUri_3BF20962(protocol: Protocol) -> str | None:
+    return protocol.Uri
+
+
+def Protocol_mapUri(f: Callable[[str], str], protocol: Protocol) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, map(f, protocol.Uri), protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments)
+
+
+def Protocol_setUri(protocol: Protocol, uri: str) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments)
+
+
+def Protocol_getComponents_3BF20962(protocol: Protocol) -> FSharpList[Component] | None:
+    return protocol.Components
+
+
+def Protocol_mapComponents(f: Callable[[FSharpList[Component]], FSharpList[Component]], protocol: Protocol) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, map(f, protocol.Components), protocol.Comments)
+
+
+def Protocol_setComponents(protocol: Protocol, components: FSharpList[Component]) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, components, protocol.Comments)
+
+
+def Protocol_addComponent(comp: Component, protocol: Protocol) -> Protocol:
+    return Protocol_setComponents(protocol, append(default_arg(protocol.Components, empty()), singleton(comp)))
+
+
+def Protocol_getParameters_3BF20962(protocol: Protocol) -> FSharpList[ProtocolParameter] | None:
+    return protocol.Parameters
+
+
+def Protocol_mapParameters(f: Callable[[FSharpList[ProtocolParameter]], FSharpList[ProtocolParameter]], protocol: Protocol) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, map(f, protocol.Parameters), protocol.Components, protocol.Comments)
+
+
+def Protocol_setParameters(protocol: Protocol, parameters: FSharpList[ProtocolParameter]) -> Protocol:
+    return Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, parameters, protocol.Components, protocol.Comments)
+
+
+def Protocol_addParameter(parameter: ProtocolParameter, protocol: Protocol) -> Protocol:
+    return Protocol_setParameters(protocol, append(default_arg(protocol.Parameters, empty()), singleton(parameter)))
+
+
+__all__ = ["Protocol_reflection", "Protocol_make", "Protocol_create_Z414665E7", "Protocol_get_empty", "Protocol_tryGetByName", "Protocol_existsByName", "Protocol_add", "Protocol_removeByName", "Protocol_getComments_3BF20962", "Protocol_mapComments", "Protocol_setComments", "Protocol_getProtocolType_3BF20962", "Protocol_mapProtocolType", "Protocol_setProtocolType", "Protocol_getVersion_3BF20962", "Protocol_mapVersion", "Protocol_setVersion", "Protocol_getName_3BF20962", "Protocol_mapName", "Protocol_setName", "Protocol_getDescription_3BF20962", "Protocol_mapDescription", "Protocol_setDescription", "Protocol_getUri_3BF20962", "Protocol_mapUri", "Protocol_setUri", "Protocol_getComponents_3BF20962", "Protocol_mapComponents", "Protocol_setComponents", "Protocol_addComponent", "Protocol_getParameters_3BF20962", "Protocol_mapParameters", "Protocol_setParameters", "Protocol_addParameter"]
+