feat: allow for "undefined" material types and units (#949)

Author: RobPasMue

src/ansys/geometry/core/designer/design.py

@@ -44,7 +44,7 @@
 from beartype.typing import Dict, List, Optional, Union
 from google.protobuf.empty_pb2 import Empty
 import numpy as np
-from pint import Quantity
+from pint import Quantity, UndefinedUnitError
 
 from ansys.geometry.core.connection.conversions import (
     grpc_frame_to_frame,
@@ -687,11 +687,34 @@ def __read_existing_design(self) -> None:
             properties = []
             density = Quantity(0)
             for property in material.material_properties:
-                mp = MaterialProperty(
-                    MaterialPropertyType.from_id(property.id),
-                    property.display_name,
-                    Quantity(property.value, property.units),
-                )
+                # TODO: Add support for more material properties...
+                #      - Need to add support for more MaterialPropertyTypes
+                #      - Need to add support for more Quantity units
+                try:
+                    mp_type = MaterialPropertyType.from_id(property.id)
+                except ValueError as err:  # TODO: Errors coming from MaterialPropertyType.from_id
+                    # because of unsupported MaterialPropertyType entries...
+                    self._grpc_client.log.warning(
+                        f"Material property {property.display_name} of type {property.id} is not supported."  # noqa : E501
+                        " Storing as string."
+                    )
+                    self._grpc_client.log.warning(f"Error: {err}")
+                    mp_type = property.id
+
+                try:
+                    mp_quantity = Quantity(property.value, property.units)
+                except (
+                    UndefinedUnitError,
+                    TypeError,
+                ) as err:  # TODO: Errors coming from Quantity ctor because of unsupported units...
+                    self._grpc_client.log.warning(
+                        f"Material property {property.display_name} with units {property.units} is not fully supported."  # noqa : E501
+                        " Storing value only as float."
+                    )
+                    self._grpc_client.log.warning(f"Error: {err}")
+                    mp_quantity = property.value
+
+                mp = MaterialProperty(mp_type, property.display_name, mp_quantity)
                 properties.append(mp)
                 if mp.type == MaterialPropertyType.DENSITY:
                     density = mp.quantity

src/ansys/geometry/core/materials/property.py

@@ -24,8 +24,11 @@
 from enum import Enum, unique
 
 from beartype import beartype as check_input_types
+from beartype.typing import Union
 from pint import Quantity
 
+from ansys.geometry.core.typing import Real
+
 
 @unique
 class MaterialPropertyType(Enum):
@@ -71,29 +74,36 @@ class MaterialProperty:
 
     Parameters
     ----------
-    type : MaterialPropertyType
-        Type of the material property.
+    type : Union[MaterialPropertyType, str]
+        Type of the material property. If the type is a string, it must be a valid
+        material property type - though it might not be supported by the MaterialPropertyType
+        enum.
     name: str
         Material property name.
-    quantity: ~pint.Quantity
-        Value and unit.
+    quantity: Union[~pint.Quantity, Real]
+        Value and unit in case of a supported Quantity. If the type is not supported, it
+        must be a Real value (float or integer).
     """
 
     @check_input_types
     def __init__(
         self,
-        type: MaterialPropertyType,
+        type: Union[MaterialPropertyType, str],
         name: str,
-        quantity: Quantity,
+        quantity: Union[Quantity, Real],
     ):
         """Initialize ``MaterialProperty`` class."""
         self._type = type
         self._name = name
         self._quantity = quantity
 
     @property
-    def type(self) -> MaterialPropertyType:
-        """Material property ID."""
+    def type(self) -> Union[MaterialPropertyType, str]:
+        """
+        Material property ID.
+
+        If the type is not supported, it will be a string.
+        """
         return self._type
 
     @property
@@ -102,6 +112,10 @@ def name(self) -> str:
         return self._name
 
     @property
-    def quantity(self) -> Quantity:
-        """Material property quantity and unit."""
+    def quantity(self) -> Union[Quantity, Real]:
+        """
+        Material property quantity and unit.
+
+        If the type is not supported, it will be a Real value (float or integer).
+        """
         return self._quantity