arctrl 3.0.0__py3-none-any.whl

arctrl/py/Core/Process/factor.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+from ...fable_modules.fable_library.list import (try_find, FSharpList, exists, append, singleton, filter)
+from ...fable_modules.fable_library.option import (default_arg, map)
+from ...fable_modules.fable_library.reflection import (TypeInfo, string_type, option_type, array_type, record_type)
+from ...fable_modules.fable_library.types import (Array, to_string, Record)
+from ...fable_modules.fable_library.util import equals
+from ..comment import (Comment, Comment_reflection)
+from ..Helper.collections_ import (Option_fromValueWithDefault, ResizeArray_map)
+from ..ontology_annotation import (OntologyAnnotation, OntologyAnnotation_reflection)
+
+def _expr1072() -> TypeInfo:
+    return record_type("ARCtrl.Process.Factor", [], Factor, lambda: [("Name", option_type(string_type)), ("FactorType", option_type(OntologyAnnotation_reflection())), ("Comments", option_type(array_type(Comment_reflection())))])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class Factor(Record):
+    Name: str | None
+    FactorType: OntologyAnnotation | None
+    Comments: Array[Comment] | None
+    @staticmethod
+    def make(name: str | None=None, factor_type: OntologyAnnotation | None=None, comments: Array[Comment] | None=None) -> Factor:
+        return Factor(name, factor_type, comments)
+
+    @staticmethod
+    def create(Name: str | None=None, FactorType: OntologyAnnotation | None=None, Comments: Array[Comment] | None=None) -> Factor:
+        return Factor.make(Name, FactorType, Comments)
+
+    @staticmethod
+    def empty() -> Factor:
+        return Factor.create()
+
+    @staticmethod
+    def from_string(name: str, term: str, source: str, accession: str, comments: Array[Comment] | None=None) -> Factor:
+        oa: OntologyAnnotation = OntologyAnnotation.create(term, source, accession, comments)
+        name_1: str | None = Option_fromValueWithDefault("", name)
+        factor_type: OntologyAnnotation | None = Option_fromValueWithDefault(OntologyAnnotation(), oa)
+        return Factor.make(name_1, factor_type, None)
+
+    @staticmethod
+    def to_string_object(factor: Factor) -> dict[str, Any]:
+        value: dict[str, Any] = {
+            "TermAccessionNumber": "",
+            "TermName": "",
+            "TermSourceREF": ""
+        }
+        def mapping(oa: OntologyAnnotation) -> dict[str, Any]:
+            return OntologyAnnotation.to_string_object(oa)
+
+        return default_arg(map(mapping, factor.FactorType), value)
+
+    @property
+    def NameText(self, __unit: None=None) -> str:
+        this: Factor = self
+        return default_arg(this.Name, "")
+
+    def MapCategory(self, f: Callable[[OntologyAnnotation], OntologyAnnotation]) -> Factor:
+        this: Factor = self
+        return Factor(this.Name, map(f, this.FactorType), this.Comments)
+
+    def SetCategory(self, c: OntologyAnnotation) -> Factor:
+        this: Factor = self
+        return Factor(this.Name, c, this.Comments)
+
+    @staticmethod
+    def try_get_by_name(name: str, factors: FSharpList[Factor]) -> Factor | None:
+        def _arrow1069(f: Factor) -> bool:
+            return equals(f.Name, name)
+
+        return try_find(_arrow1069, factors)
+
+    @staticmethod
+    def exists_by_name(name: str, factors: FSharpList[Factor]) -> bool:
+        def _arrow1070(f: Factor) -> bool:
+            return equals(f.Name, name)
+
+        return exists(_arrow1070, factors)
+
+    @staticmethod
+    def add(factors: FSharpList[Factor], factor: Factor) -> FSharpList[Factor]:
+        return append(factors, singleton(factor))
+
+    @staticmethod
+    def remove_by_name(name: str, factors: FSharpList[Factor]) -> FSharpList[Factor]:
+        def _arrow1071(f: Factor) -> bool:
+            return not equals(f.Name, name)
+
+        return filter(_arrow1071, factors)
+
+    @staticmethod
+    def get_comments(factor: Factor) -> Array[Comment] | None:
+        return factor.Comments
+
+    @staticmethod
+    def map_comments(f: Callable[[Array[Comment]], Array[Comment]], factor: Factor) -> Factor:
+        return Factor(factor.Name, factor.FactorType, map(f, factor.Comments))
+
+    @staticmethod
+    def set_comments(factor: Factor, comments: Array[Comment]) -> Factor:
+        return Factor(factor.Name, factor.FactorType, comments)
+
+    @staticmethod
+    def get_factor_type(factor: Factor) -> OntologyAnnotation | None:
+        return factor.FactorType
+
+    @staticmethod
+    def map_factor_type(f: Callable[[OntologyAnnotation], OntologyAnnotation], factor: Factor) -> Factor:
+        return Factor(factor.Name, map(f, factor.FactorType), factor.Comments)
+
+    @staticmethod
+    def set_factor_type(factor: Factor, factor_type: OntologyAnnotation) -> Factor:
+        return Factor(factor.Name, factor_type, factor.Comments)
+
+    @staticmethod
+    def try_get_name(f: Factor) -> str | None:
+        return f.Name
+
+    @staticmethod
+    def get_name_as_string(f: Factor) -> str:
+        return f.NameText
+
+    @staticmethod
+    def name_equals_string(name: str, f: Factor) -> bool:
+        return f.NameText == name
+
+    def Copy(self, __unit: None=None) -> Factor:
+        this: Factor = self
+        def mapping(a: Array[Comment]) -> Array[Comment]:
+            def f(c: Comment, a: Any=a) -> Comment:
+                return c.Copy()
+
+            return ResizeArray_map(f, a)
+
+        comments: Array[Comment] | None = map(mapping, this.Comments)
+        return Factor.make(this.Name, this.FactorType, comments)
+
+    def Print(self, __unit: None=None) -> str:
+        this: Factor = self
+        return to_string(this)
+
+    def PrintCompact(self, __unit: None=None) -> str:
+        this: Factor = self
+        return "OA " + this.NameText
+
+
+Factor_reflection = _expr1072
+
+__all__ = ["Factor_reflection"]
+

arctrl/py/Core/Process/factor_value.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+from ...fable_modules.fable_library.option import (map, bind, default_arg)
+from ...fable_modules.fable_library.reflection import (TypeInfo, string_type, option_type, record_type)
+from ...fable_modules.fable_library.string_ import (to_text, printf)
+from ...fable_modules.fable_library.types import (to_string, Record)
+from ...fable_modules.fable_library.util import int32_to_string
+from ..ontology_annotation import (OntologyAnnotation, OntologyAnnotation_reflection)
+from ..value import (Value as Value_1, Value_reflection)
+from .factor import (Factor, Factor_reflection)
+
+def _expr1076() -> TypeInfo:
+    return record_type("ARCtrl.Process.FactorValue", [], FactorValue, lambda: [("ID", option_type(string_type)), ("Category", option_type(Factor_reflection())), ("Value", option_type(Value_reflection())), ("Unit", option_type(OntologyAnnotation_reflection()))])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class FactorValue(Record):
+    ID: str | None
+    Category: Factor | None
+    Value: Value_1 | None
+    Unit: OntologyAnnotation | None
+    def Print(self, __unit: None=None) -> str:
+        this: FactorValue = self
+        return to_string(this)
+
+    def PrintCompact(self, __unit: None=None) -> str:
+        this: FactorValue = self
+        def mapping(f: Factor) -> str:
+            return f.NameText
+
+        category: str | None = map(mapping, this.Category)
+        def mapping_1(oa: OntologyAnnotation) -> str:
+            return oa.NameText
+
+        unit: str | None = map(mapping_1, this.Unit)
+        def mapping_2(v: Value_1) -> str:
+            s: str = v.PrintCompact()
+            if unit is None:
+                return s
+
+            else: 
+                return (s + " ") + unit
+
+
+        value: str | None = map(mapping_2, this.Value)
+        def _arrow1073(__unit: None=None) -> str:
+            value_2: str = value
+            return value_2
+
+        def _arrow1074(__unit: None=None) -> str:
+            category_2: str = category
+            return (category_2 + ":") + "No Value"
+
+        def _arrow1075(__unit: None=None) -> str:
+            category_1: str = category
+            value_1: str = value
+            return (category_1 + ":") + value_1
+
+        return ("" if (value is None) else _arrow1073()) if (category is None) else (_arrow1074() if (value is None) else _arrow1075())
+
+    def AlternateName(self, __unit: None=None) -> str | None:
+        return None
+
+    def MeasurementMethod(self, __unit: None=None) -> str | None:
+        return None
+
+    def Description(self, __unit: None=None) -> str | None:
+        return None
+
+    def GetCategory(self, __unit: None=None) -> OntologyAnnotation | None:
+        this: FactorValue = self
+        def binder(f: Factor) -> OntologyAnnotation | None:
+            return f.FactorType
+
+        return bind(binder, this.Category)
+
+    def GetValue(self, __unit: None=None) -> Value_1 | None:
+        this: FactorValue = self
+        return this.Value
+
+    def GetUnit(self, __unit: None=None) -> OntologyAnnotation | None:
+        this: FactorValue = self
+        return this.Unit
+
+    def GetAdditionalType(self, __unit: None=None) -> str:
+        return "FactorValue"
+
+
+FactorValue_reflection = _expr1076
+
+def FactorValue_make(id: str | None=None, category: Factor | None=None, value: Value_1 | None=None, unit: OntologyAnnotation | None=None) -> FactorValue:
+    return FactorValue(id, category, value, unit)
+
+
+def FactorValue_create_30BDC49(Id: str | None=None, Category: Factor | None=None, Value: Value_1 | None=None, Unit: OntologyAnnotation | None=None) -> FactorValue:
+    return FactorValue_make(Id, Category, Value, Unit)
+
+
+def FactorValue_get_empty(__unit: None=None) -> FactorValue:
+    return FactorValue_create_30BDC49()
+
+
+def FactorValue__get_ValueText(this: FactorValue) -> str:
+    def mapping(oa: Value_1, this: Any=this) -> str:
+        if oa.tag == 2:
+            return to_string(oa.fields[0])
+
+        elif oa.tag == 1:
+            return int32_to_string(oa.fields[0])
+
+        elif oa.tag == 3:
+            return oa.fields[0]
+
+        else: 
+            return oa.fields[0].NameText
+
+
+    return default_arg(map(mapping, this.Value), "")
+
+
+def FactorValue__get_ValueWithUnitText(this: FactorValue) -> str:
+    def mapping(oa: OntologyAnnotation, this: Any=this) -> str:
+        return oa.NameText
+
+    unit: str | None = map(mapping, this.Unit)
+    v: str = FactorValue__get_ValueText(this)
+    if unit is None:
+        return v
+
+    else: 
+        u: str = unit
+        return to_text(printf("%s %s"))(v)(u)
+
+
+
+def FactorValue__get_NameText(this: FactorValue) -> str:
+    def mapping(factor: Factor, this: Any=this) -> str:
+        return factor.NameText
+
+    return default_arg(map(mapping, this.Category), "")
+
+
+def FactorValue__MapCategory_658CFBF6(this: FactorValue, f: Callable[[OntologyAnnotation], OntologyAnnotation]) -> FactorValue:
+    def mapping(p: Factor, this: Any=this, f: Any=f) -> Factor:
+        return p.MapCategory(f)
+
+    return FactorValue(this.ID, map(mapping, this.Category), this.Value, this.Unit)
+
+
+def FactorValue__SetCategory_ZDED3A0F(this: FactorValue, c: OntologyAnnotation) -> FactorValue:
+    def _arrow1077(__unit: None=None, this: Any=this, c: Any=c) -> Factor | None:
+        match_value: Factor | None = this.Category
+        if match_value is None:
+            return Factor.create(None, c)
+
+        else: 
+            p: Factor = match_value
+            return p.SetCategory(c)
+
+
+    return FactorValue(this.ID, _arrow1077(), this.Value, this.Unit)
+
+
+def FactorValue_getNameAsString_7105C732(fv: FactorValue) -> str:
+    return FactorValue__get_NameText(fv)
+
+
+def FactorValue_nameEqualsString(name: str, fv: FactorValue) -> bool:
+    return FactorValue__get_NameText(fv) == name
+
+
+def FactorValue_createAsPV(alternate_name: str | None=None, measurement_method: str | None=None, description: str | None=None, category: OntologyAnnotation | None=None, value: Value_1 | None=None, unit: OntologyAnnotation | None=None) -> FactorValue:
+    def mapping(c: OntologyAnnotation, alternate_name: Any=alternate_name, measurement_method: Any=measurement_method, description: Any=description, category: Any=category, value: Any=value, unit: Any=unit) -> Factor:
+        return Factor.create(None, c)
+
+    return FactorValue_create_30BDC49(None, map(mapping, category), value, unit)
+
+
+__all__ = ["FactorValue_reflection", "FactorValue_make", "FactorValue_create_30BDC49", "FactorValue_get_empty", "FactorValue__get_ValueText", "FactorValue__get_ValueWithUnitText", "FactorValue__get_NameText", "FactorValue__MapCategory_658CFBF6", "FactorValue__SetCategory_ZDED3A0F", "FactorValue_getNameAsString_7105C732", "FactorValue_nameEqualsString", "FactorValue_createAsPV"]
+

arctrl/py/Core/Process/material.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+from ...fable_modules.fable_library.list import (length, empty, FSharpList, choose)
+from ...fable_modules.fable_library.option import default_arg
+from ...fable_modules.fable_library.reflection import (TypeInfo, string_type, option_type, list_type, record_type)
+from ...fable_modules.fable_library.string_ import (to_text, printf)
+from ...fable_modules.fable_library.types import (to_string, Record)
+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 _expr1085() -> 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())))])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class Material(Record):
+    ID: str | None
+    Name: str | None
+    MaterialType: MaterialType_1 | None
+    Characteristics: FSharpList[MaterialAttributeValue] | None
+    DerivesFrom: FSharpList[Material] | None
+    def Print(self, __unit: None=None) -> str:
+        this: Material = self
+        return to_string(this)
+
+    def PrintCompact(self, __unit: None=None) -> str:
+        this: Material = self
+        chars: int = length(default_arg(this.Characteristics, empty())) or 0
+        match_value: MaterialType_1 | None = this.MaterialType
+        if match_value is None:
+            arg_3: str = Material__get_NameText(this)
+            return to_text(printf("%s [%i characteristics]"))(arg_3)(chars)
+
+        else: 
+            t: MaterialType_1 = match_value
+            arg: str = Material__get_NameText(this)
+            arg_1: str = MaterialType__get_AsString(t)
+            return to_text(printf("%s [%s; %i characteristics]"))(arg)(arg_1)(chars)
+
+
+
+Material_reflection = _expr1085
+
+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)
+
+
+def Material_create_Z66909A6D(Id: str | None=None, Name: str | None=None, MaterialType: MaterialType_1 | None=None, Characteristics: FSharpList[MaterialAttributeValue] | None=None, DerivesFrom: FSharpList[Material] | None=None) -> Material:
+    return Material_make(Id, Name, MaterialType, Characteristics, DerivesFrom)
+
+
+def Material_get_empty(__unit: None=None) -> Material:
+    return Material_create_Z66909A6D()
+
+
+def Material__get_NameText(this: Material) -> str:
+    return default_arg(this.Name, "")
+
+
+def Material_getUnits_ZBCDEB61(m: Material) -> FSharpList[OntologyAnnotation]:
+    def chooser(c: MaterialAttributeValue, m: Any=m) -> OntologyAnnotation | None:
+        return c.Unit
+
+    return choose(chooser, default_arg(m.Characteristics, empty()))
+
+
+def Material_setCharacteristicValues(values: FSharpList[MaterialAttributeValue], m: Material) -> Material:
+    return Material(m.ID, m.Name, m.MaterialType, values, m.DerivesFrom)
+
+
+__all__ = ["Material_reflection", "Material_make", "Material_create_Z66909A6D", "Material_get_empty", "Material__get_NameText", "Material_getUnits_ZBCDEB61", "Material_setCharacteristicValues"]
+

arctrl/py/Core/Process/material_attribute.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+from ...fable_modules.fable_library.option import (default_arg, map, bind)
+from ...fable_modules.fable_library.reflection import (TypeInfo, string_type, option_type, record_type)
+from ...fable_modules.fable_library.types import (to_string, Record, Array)
+from ..comment import Comment
+from ..Helper.collections_ import Option_fromValueWithDefault
+from ..ontology_annotation import (OntologyAnnotation, OntologyAnnotation_reflection)
+
+def _expr1078() -> TypeInfo:
+    return record_type("ARCtrl.Process.MaterialAttribute", [], MaterialAttribute, lambda: [("ID", option_type(string_type)), ("CharacteristicType", option_type(OntologyAnnotation_reflection()))])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class MaterialAttribute(Record):
+    ID: str | None
+    CharacteristicType: OntologyAnnotation | None
+    def Print(self, __unit: None=None) -> str:
+        this: MaterialAttribute = self
+        return to_string(this)
+
+    def PrintCompact(self, __unit: None=None) -> str:
+        this: MaterialAttribute = self
+        return "OA " + MaterialAttribute__get_NameText(this)
+
+
+MaterialAttribute_reflection = _expr1078
+
+def MaterialAttribute_make(id: str | None=None, characteristic_type: OntologyAnnotation | None=None) -> MaterialAttribute:
+    return MaterialAttribute(id, characteristic_type)
+
+
+def MaterialAttribute_create_A220A8A(Id: str | None=None, CharacteristicType: OntologyAnnotation | None=None) -> MaterialAttribute:
+    return MaterialAttribute_make(Id, CharacteristicType)
+
+
+def MaterialAttribute_get_empty(__unit: None=None) -> MaterialAttribute:
+    return MaterialAttribute_create_A220A8A()
+
+
+def MaterialAttribute_fromString_5980DC03(term: str, source: str, accession: str, comments: Array[Comment] | None=None) -> MaterialAttribute:
+    oa: OntologyAnnotation = OntologyAnnotation.create(term, source, accession, comments)
+    return MaterialAttribute_make(None, Option_fromValueWithDefault(OntologyAnnotation(), oa))
+
+
+def MaterialAttribute_toStringObject_Z1E3B85DD(ma: MaterialAttribute) -> dict[str, Any]:
+    value: dict[str, Any] = {
+        "TermAccessionNumber": "",
+        "TermName": "",
+        "TermSourceREF": ""
+    }
+    def mapping(oa: OntologyAnnotation, ma: Any=ma) -> dict[str, Any]:
+        return OntologyAnnotation.to_string_object(oa)
+
+    return default_arg(map(mapping, ma.CharacteristicType), value)
+
+
+def MaterialAttribute__get_NameText(this: MaterialAttribute) -> str:
+    def mapping(oa: OntologyAnnotation, this: Any=this) -> str:
+        return oa.NameText
+
+    return default_arg(map(mapping, this.CharacteristicType), "")
+
+
+def MaterialAttribute__get_TryNameText(this: MaterialAttribute) -> str | None:
+    def binder(oa: OntologyAnnotation, this: Any=this) -> str | None:
+        return oa.Name
+
+    return bind(binder, this.CharacteristicType)
+
+
+def MaterialAttribute__MapCategory_658CFBF6(this: MaterialAttribute, f: Callable[[OntologyAnnotation], OntologyAnnotation]) -> MaterialAttribute:
+    return MaterialAttribute(this.ID, map(f, this.CharacteristicType))
+
+
+def MaterialAttribute__SetCategory_ZDED3A0F(this: MaterialAttribute, c: OntologyAnnotation) -> MaterialAttribute:
+    return MaterialAttribute(this.ID, c)
+
+
+def MaterialAttribute_tryGetNameText_Z1E3B85DD(ma: MaterialAttribute) -> str:
+    return MaterialAttribute__get_NameText(ma)
+
+
+def MaterialAttribute_getNameText_Z1E3B85DD(ma: MaterialAttribute) -> str | None:
+    return MaterialAttribute__get_TryNameText(ma)
+
+
+def MaterialAttribute_nameEqualsString(name: str, ma: MaterialAttribute) -> bool:
+    return MaterialAttribute__get_NameText(ma) == name
+
+
+__all__ = ["MaterialAttribute_reflection", "MaterialAttribute_make", "MaterialAttribute_create_A220A8A", "MaterialAttribute_get_empty", "MaterialAttribute_fromString_5980DC03", "MaterialAttribute_toStringObject_Z1E3B85DD", "MaterialAttribute__get_NameText", "MaterialAttribute__get_TryNameText", "MaterialAttribute__MapCategory_658CFBF6", "MaterialAttribute__SetCategory_ZDED3A0F", "MaterialAttribute_tryGetNameText_Z1E3B85DD", "MaterialAttribute_getNameText_Z1E3B85DD", "MaterialAttribute_nameEqualsString"]
+

arctrl/py/Core/Process/material_attribute_value.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+from ...fable_modules.fable_library.option import (map, bind, default_arg)
+from ...fable_modules.fable_library.reflection import (TypeInfo, string_type, option_type, record_type)
+from ...fable_modules.fable_library.string_ import (to_text, printf)
+from ...fable_modules.fable_library.types import (to_string, Record)
+from ...fable_modules.fable_library.util import int32_to_string
+from ..ontology_annotation import (OntologyAnnotation, OntologyAnnotation_reflection)
+from ..value import (Value as Value_1, Value_reflection)
+from .material_attribute import (MaterialAttribute__get_NameText, MaterialAttribute, MaterialAttribute_reflection, MaterialAttribute__get_TryNameText, MaterialAttribute__MapCategory_658CFBF6, MaterialAttribute_create_A220A8A, MaterialAttribute__SetCategory_ZDED3A0F)
+
+def _expr1083() -> TypeInfo:
+    return record_type("ARCtrl.Process.MaterialAttributeValue", [], MaterialAttributeValue, lambda: [("ID", option_type(string_type)), ("Category", option_type(MaterialAttribute_reflection())), ("Value", option_type(Value_reflection())), ("Unit", option_type(OntologyAnnotation_reflection()))])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class MaterialAttributeValue(Record):
+    ID: str | None
+    Category: MaterialAttribute | None
+    Value: Value_1 | None
+    Unit: OntologyAnnotation | None
+    def Print(self, __unit: None=None) -> str:
+        this: MaterialAttributeValue = self
+        return to_string(this)
+
+    def PrintCompact(self, __unit: None=None) -> str:
+        this: MaterialAttributeValue = self
+        category: str | None = map(MaterialAttribute__get_NameText, this.Category)
+        def mapping_1(oa: OntologyAnnotation) -> str:
+            return oa.NameText
+
+        unit: str | None = map(mapping_1, this.Unit)
+        def mapping_2(v: Value_1) -> str:
+            s: str = v.PrintCompact()
+            if unit is None:
+                return s
+
+            else: 
+                return (s + " ") + unit
+
+
+        value: str | None = map(mapping_2, this.Value)
+        def _arrow1080(__unit: None=None) -> str:
+            value_2: str = value
+            return value_2
+
+        def _arrow1081(__unit: None=None) -> str:
+            category_2: str = category
+            return (category_2 + ":") + "No Value"
+
+        def _arrow1082(__unit: None=None) -> str:
+            category_1: str = category
+            value_1: str = value
+            return (category_1 + ":") + value_1
+
+        return ("" if (value is None) else _arrow1080()) if (category is None) else (_arrow1081() if (value is None) else _arrow1082())
+
+    def AlternateName(self, __unit: None=None) -> str | None:
+        return None
+
+    def MeasurementMethod(self, __unit: None=None) -> str | None:
+        return None
+
+    def Description(self, __unit: None=None) -> str | None:
+        return None
+
+    def GetCategory(self, __unit: None=None) -> OntologyAnnotation | None:
+        this: MaterialAttributeValue = self
+        def binder(x: MaterialAttribute) -> OntologyAnnotation | None:
+            return x.CharacteristicType
+
+        return bind(binder, this.Category)
+
+    def GetValue(self, __unit: None=None) -> Value_1 | None:
+        this: MaterialAttributeValue = self
+        return this.Value
+
+    def GetUnit(self, __unit: None=None) -> OntologyAnnotation | None:
+        this: MaterialAttributeValue = self
+        return this.Unit
+
+    def GetAdditionalType(self, __unit: None=None) -> str:
+        return "MaterialAttributeValue"
+
+
+MaterialAttributeValue_reflection = _expr1083
+
+def MaterialAttributeValue_make(id: str | None=None, category: MaterialAttribute | None=None, value: Value_1 | None=None, unit: OntologyAnnotation | None=None) -> MaterialAttributeValue:
+    return MaterialAttributeValue(id, category, value, unit)
+
+
+def MaterialAttributeValue_create_ZE1D108D(Id: str | None=None, Category: MaterialAttribute | None=None, Value: Value_1 | None=None, Unit: OntologyAnnotation | None=None) -> MaterialAttributeValue:
+    return MaterialAttributeValue_make(Id, Category, Value, Unit)
+
+
+def MaterialAttributeValue_get_empty(__unit: None=None) -> MaterialAttributeValue:
+    return MaterialAttributeValue_create_ZE1D108D()
+
+
+def MaterialAttributeValue__get_NameText(this: MaterialAttributeValue) -> str:
+    def mapping(oa: MaterialAttribute, this: Any=this) -> str:
+        return MaterialAttribute__get_NameText(oa)
+
+    return default_arg(map(mapping, this.Category), "")
+
+
+def MaterialAttributeValue__get_TryNameText(this: MaterialAttributeValue) -> str | None:
+    def binder(oa: MaterialAttribute, this: Any=this) -> str | None:
+        return MaterialAttribute__get_TryNameText(oa)
+
+    return bind(binder, this.Category)
+
+
+def MaterialAttributeValue__get_ValueText(this: MaterialAttributeValue) -> str:
+    def mapping(oa: Value_1, this: Any=this) -> str:
+        if oa.tag == 2:
+            return to_string(oa.fields[0])
+
+        elif oa.tag == 1:
+            return int32_to_string(oa.fields[0])
+
+        elif oa.tag == 3:
+            return oa.fields[0]
+
+        else: 
+            return oa.fields[0].NameText
+
+
+    return default_arg(map(mapping, this.Value), "")
+
+
+def MaterialAttributeValue__get_ValueWithUnitText(this: MaterialAttributeValue) -> str:
+    def mapping(oa: OntologyAnnotation, this: Any=this) -> str:
+        return oa.NameText
+
+    unit: str | None = map(mapping, this.Unit)
+    v: str = MaterialAttributeValue__get_ValueText(this)
+    if unit is None:
+        return v
+
+    else: 
+        u: str = unit
+        return to_text(printf("%s %s"))(v)(u)
+
+
+
+def MaterialAttributeValue__MapCategory_658CFBF6(this: MaterialAttributeValue, f: Callable[[OntologyAnnotation], OntologyAnnotation]) -> MaterialAttributeValue:
+    def mapping(p: MaterialAttribute, this: Any=this, f: Any=f) -> MaterialAttribute:
+        return MaterialAttribute__MapCategory_658CFBF6(p, f)
+
+    return MaterialAttributeValue(this.ID, map(mapping, this.Category), this.Value, this.Unit)
+
+
+def MaterialAttributeValue__SetCategory_ZDED3A0F(this: MaterialAttributeValue, c: OntologyAnnotation) -> MaterialAttributeValue:
+    def _arrow1084(__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, _arrow1084(), this.Value, this.Unit)
+
+
+def MaterialAttributeValue_tryGetNameText_Z772273B8(mv: MaterialAttributeValue) -> str | None:
+    return MaterialAttributeValue__get_TryNameText(mv)
+
+
+def MaterialAttributeValue_getNameAsString_Z772273B8(mv: MaterialAttributeValue) -> str | None:
+    return MaterialAttributeValue__get_TryNameText(mv)
+
+
+def MaterialAttributeValue_nameEqualsString(name: str, mv: MaterialAttributeValue) -> bool:
+    return MaterialAttributeValue__get_NameText(mv) == name
+
+
+def MaterialAttributeValue_createAsPV(alternate_name: str | None=None, measurement_method: str | None=None, description: str | None=None, category: OntologyAnnotation | None=None, value: Value_1 | None=None, unit: OntologyAnnotation | None=None) -> MaterialAttributeValue:
+    def mapping(c: OntologyAnnotation, alternate_name: Any=alternate_name, measurement_method: Any=measurement_method, description: Any=description, category: Any=category, value: Any=value, unit: Any=unit) -> MaterialAttribute:
+        return MaterialAttribute_create_A220A8A(None, c)
+
+    return MaterialAttributeValue_create_ZE1D108D(None, map(mapping, category), value, unit)
+
+
+__all__ = ["MaterialAttributeValue_reflection", "MaterialAttributeValue_make", "MaterialAttributeValue_create_ZE1D108D", "MaterialAttributeValue_get_empty", "MaterialAttributeValue__get_NameText", "MaterialAttributeValue__get_TryNameText", "MaterialAttributeValue__get_ValueText", "MaterialAttributeValue__get_ValueWithUnitText", "MaterialAttributeValue__MapCategory_658CFBF6", "MaterialAttributeValue__SetCategory_ZDED3A0F", "MaterialAttributeValue_tryGetNameText_Z772273B8", "MaterialAttributeValue_getNameAsString_Z772273B8", "MaterialAttributeValue_nameEqualsString", "MaterialAttributeValue_createAsPV"]
+