fix: add pydantic ndarray type

Custom serialization and validation for numpy arrays

src/libecalc/core/consumers/legacy_consumer/consumer_function/results.py

@@ -5,14 +5,14 @@
 from typing import List, Literal, Optional, Union
 
 import numpy as np
-from numpy.typing import NDArray
 from pydantic import BaseModel, ConfigDict
 
 from libecalc.common.logger import logger
 from libecalc.core.consumers.legacy_consumer.consumer_function.types import (
     ConsumerFunctionType,
 )
 from libecalc.core.models.results.base import EnergyFunctionResult
+from libecalc.core.utils.array_type import PydanticNDArray
 
 
 class ConsumerFunctionResultBase(BaseModel):
@@ -24,16 +24,16 @@ class ConsumerFunctionResultBase(BaseModel):
 
     typ: ConsumerFunctionType
 
-    time_vector: NDArray[np.float64]
-    is_valid: NDArray[np.float64]
-    energy_usage: NDArray[np.float64]
-    energy_usage_before_power_loss_factor: Optional[NDArray[np.float64]] = None
-    condition: Optional[NDArray[np.float64]] = None
-    power_loss_factor: Optional[NDArray[np.float64]] = None
+    time_vector: PydanticNDArray
+    is_valid: PydanticNDArray
+    energy_usage: PydanticNDArray
+    energy_usage_before_power_loss_factor: Optional[PydanticNDArray] = None
+    condition: Optional[PydanticNDArray] = None
+    power_loss_factor: Optional[PydanticNDArray] = None
     energy_function_result: Optional[Union[EnergyFunctionResult, List[EnergyFunctionResult]]] = None
 
     # New! to support fuel to power rate...for e.g. compressors emulating turbine
-    power: Optional[NDArray[np.float64]] = None
+    power: Optional[PydanticNDArray] = None
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     @abstractmethod

src/libecalc/core/consumers/legacy_consumer/system/operational_setting.py

@@ -10,6 +10,7 @@
 from libecalc.common.errors.exceptions import EcalcError, IncompatibleDataError
 from libecalc.common.logger import logger
 from libecalc.common.utils.rates import Rates
+from libecalc.core.utils.array_type import PydanticNDArray
 from libecalc.expression import Expression
 
 
@@ -32,7 +33,6 @@ class ConsumerSystemOperationalSettingExpressions(BaseModel):
     discharge_pressures: List[Expression]
     cross_overs: Optional[List[int]] = None
     fluid_densities: Optional[List[Expression]] = None
-    model_config = ConfigDict(arbitrary_types_allowed=True)
 
     @property
     def number_of_consumers(self):
@@ -75,11 +75,11 @@ class PumpSystemOperationalSettingExpressions(ConsumerSystemOperationalSettingEx
 class ConsumerSystemOperationalSetting(BaseModel):
     """Warning! The methods below are fragile to changes in attribute names and types."""
 
-    rates: List[NDArray[np.float64]]
-    suction_pressures: List[NDArray[np.float64]]
-    discharge_pressures: List[NDArray[np.float64]]
+    rates: List[PydanticNDArray]
+    suction_pressures: List[PydanticNDArray]
+    discharge_pressures: List[PydanticNDArray]
     cross_overs: Optional[List[int]] = None
-    fluid_densities: Optional[List[NDArray[np.float64]]] = None
+    fluid_densities: Optional[List[PydanticNDArray]] = None
     model_config = ConfigDict(arbitrary_types_allowed=True, frozen=True)
 
     @model_validator(mode="after")
@@ -149,4 +149,4 @@ class CompressorSystemOperationalSetting(ConsumerSystemOperationalSetting):
 
 
 class PumpSystemOperationalSetting(ConsumerSystemOperationalSetting):
-    fluid_densities: List[NDArray[np.float64]]
+    fluid_densities: List[PydanticNDArray]

src/libecalc/core/consumers/legacy_consumer/system/results.py

@@ -55,7 +55,7 @@ class CompressorResult(ConsumerSystemComponentResult):
 
 class ConsumerSystemOperationalSettingResult(BaseModel):
     consumer_results: List[ConsumerSystemComponentResult]
-    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True)
+    model_config = ConfigDict(frozen=True)
 
     @property
     def total_energy_usage(self) -> NDArray[np.float64]:

src/libecalc/core/models/tabulated.py

@@ -14,6 +14,7 @@
 from libecalc.common.units import Unit
 from libecalc.core.models.base import BaseModel
 from libecalc.core.models.results.base import EnergyFunctionResult
+from libecalc.core.utils.array_type import PydanticNDArray
 from libecalc.dto.types import EnergyUsageType
 from libecalc.expression import Expression
 
@@ -97,5 +98,5 @@ class VariableExpression(PydanticBaseModel):
 
 class Variable(PydanticBaseModel):
     name: str
-    values: NDArray[np.float64]
+    values: PydanticNDArray
     model_config = ConfigDict(arbitrary_types_allowed=True)

src/libecalc/core/utils/array_type.py

@@ -0,0 +1,25 @@
+"""
+Custom pydantic type to allow for serialization and validation of ndarray
+"""
+import numpy as np
+from pydantic import BeforeValidator, PlainSerializer
+from typing_extensions import Annotated
+
+
+def nd_array_custom_before_validator(x):
+    # custom before validation logic
+    if isinstance(x, list):
+        return np.asarray(x)
+    return x
+
+
+def nd_array_custom_serializer(x):
+    # custom serialization logic
+    return str(x)
+
+
+PydanticNDArray = Annotated[
+    np.ndarray,
+    BeforeValidator(nd_array_custom_before_validator),
+    PlainSerializer(nd_array_custom_serializer, return_type=str),
+]