[CLN] Refactor array type annotations for consistency

Replaced verbose `Annotated` type definitions with `short_array_type` for cleaner and more consistent code. Improved clarity and added error handling for deserialized implicit functions in `FiniteFaultData`.

Author: Leguark

gempy_engine/core/data/centered_grid.py

@@ -1,14 +1,15 @@
 from dataclasses import dataclass, field
-from typing import Sequence, Union, Annotated
 
 import numpy as np
-from .encoders.converters import numpy_array_short_validator
+
+from .encoders.converters import short_array_type
+
 
 @dataclass
 class CenteredGrid:
-    centers: Annotated[np.ndarray,  numpy_array_short_validator] #: This is just used to calculate xyz to interpolate. Tz is independent
-    resolution: Annotated[np.ndarray,  numpy_array_short_validator]  
-    radius: float | Annotated[np.ndarray,  numpy_array_short_validator]
+    centers: short_array_type  #: This is just used to calculate xyz to interpolate. Tz is independent
+    resolution: short_array_type  
+    radius: float | short_array_type
 
     kernel_grid_centers: np.ndarray  = field(init=False)
     left_voxel_edges: np.ndarray  = field(init=False)

gempy_engine/core/data/encoders/converters.py

@@ -1,4 +1,7 @@
+from typing import Annotated
+
 import numpy as np
 from pydantic import BeforeValidator
 
 numpy_array_short_validator = BeforeValidator(lambda v: np.array(v) if v is not None else None)
+short_array_type = Annotated[np.ndarray, numpy_array_short_validator]

gempy_engine/core/data/kernel_classes/faults.py

@@ -1,34 +1,39 @@
 import dataclasses
-from typing import Optional
+from typing import Optional, Callable
 
 import numpy as np
+from pydantic import Field
 
-from gempy_engine.core.data.transforms import Transform
+from ..encoders.converters import short_array_type
+from ..transforms import Transform
 
 
 @dataclasses.dataclass
 class FiniteFaultData:
-    implicit_function: callable
-    implicit_function_transform: Transform
-    pivot: np.ndarray
-    
+    implicit_function: Callable | None =  Field(exclude=True, default=None)#, default=None)
+    implicit_function_transform: Transform = Field()
+    pivot: short_array_type = Field()
+
     def apply(self, points: np.ndarray) -> np.ndarray:
         transformed_points = self.implicit_function_transform.apply_inverse_with_pivot(
             points=points,
             pivot=self.pivot
         )
+        if self.implicit_function is None:
+            raise ValueError("No implicit function defined. This can happen after deserializing (loading).")
+        
         scalar_block = self.implicit_function(transformed_points)
         return scalar_block 
 
 
 
 @dataclasses.dataclass
 class FaultsData:
-    fault_values_everywhere: np.ndarray = None
-    fault_values_on_sp: np.ndarray = None
+    fault_values_everywhere: short_array_type | None = None
+    fault_values_on_sp: short_array_type | None = None
 
-    fault_values_ref: np.ndarray = None
-    fault_values_rest: np.ndarray = None
+    fault_values_ref: short_array_type | None = None
+    fault_values_rest: short_array_type | None = None
 
     # User given data:
     thickness: Optional[float] = None