[ENH] Implement GeoModel serialization with Pydantic (#1027)

# Description
Refactored GeoModel to use Pydantic for serialization and deserialization. This change enables saving and loading models to/from JSON format while handling large numpy arrays efficiently.

Key changes:
- Converted GeoModel from a dataclass to a Pydantic BaseModel
- Added serialization support for numpy arrays in grid, surface points, and orientations
- Implemented context-based injection for large binary data during deserialization
- Added from_args constructor to maintain backward compatibility
- Updated model initialization across the codebase
- Added gitignore entry for test/temp directory
- Added tests for model serialization

Relates to #serialization-support

# Checklist
- [x] My code uses type hinting for function and method arguments and return values.
- [x] I have created tests which cover my code.
- [x] The test code either 1. demonstrates at least one valuable use case (e.g. integration tests) 
or 2. verifies that outputs are as expected for given inputs (e.g. unit tests).
- [x] New tests pass locally with my changes.

Author: Leguark

.gitignore

@@ -181,3 +181,4 @@ examples/tutorials/z_other_tutorials/json_io/multiple_series_faults_computed.jso
 # Generated JSON files from examples
 examples/tutorials/z_other_tutorials/json_io/combination_model.json
 examples/tutorials/z_other_tutorials/json_io/combination_model_computed.json
+/test/temp/

docs/developers_notes/dev_log/2025_05.md

@@ -5,9 +5,10 @@
 
 # TODO: 
 -[ ] Saving and loading models 
-  - [ ] Make tests passing for InterpOptions serializable
-  - [ ] Try to make BaseModel dirctly to StructuralFrame
-  - [ ] Try to make Serializable directly to Grid
+  - [x] Make tests passing for InterpOptions serializable
+  - [x] Dealing with large numpy arrays
+  - [x] Trying to have a better implementation for deserializing complex fields
+  - [ ] Make save and load function
 -[ ] Better api for nugget effect optimization
 
 ## Saving models

examples/examples/real/mik.py

@@ -305,7 +305,7 @@
 all_surface_points_coords: gp.data.SurfacePointsTable = structural_frame.surface_points_copy
 extent_from_data = all_surface_points_coords.xyz.min(axis=0), all_surface_points_coords.xyz.max(axis=0)
 # Initialize GeoModel
-geo_model = gp.data.GeoModel(
+geo_model = gp.data.GeoModel.from_args(
     name="Stratigraphic Pile",
     structural_frame=structural_frame,
     grid=gp.data.Grid(

gempy/API/initialization_API.py

@@ -92,7 +92,7 @@ def create_geomodel(
         case _:
             pass
 
-    geo_model: GeoModel = GeoModel(
+    geo_model: GeoModel = GeoModel.from_args(
         name=project_name,
         structural_frame=structural_frame,
         grid=grid,

gempy/core/data/_data_points_helpers.py

@@ -1,12 +1,13 @@
-from typing import Sequence
+import hashlib
+
+from typing import Sequence
 
 import numpy as np
 
 
 def structural_element_hasher(i: int, name: str, hash_length: int = 8) -> int:
     # Get the last 'hash_length' digits from the hash
-    name_hash = abs(hash(name)) % (10 ** hash_length)
-
+    name_hash = int(hashlib.md5(name.encode('utf-8')).hexdigest(), 16) % (10 ** hash_length)
     return i * (10 ** hash_length) + name_hash
 
 

gempy/core/data/encoders/__init__.py

@@ -0,0 +1,59 @@
+from contextlib import contextmanager
+
+from contextvars import ContextVar
+
+import numpy as np
+from pydantic import BeforeValidator
+
+
+def convert_to_arrays(values, keys):
+    for key in keys:
+        if key in values and not isinstance(values[key], np.ndarray):
+            values[key] = np.array(values[key])
+    return values
+
+
+def validate_numpy_array(v):
+    return np.array(v) if v is not None else None
+
+
+def instantiate_if_necessary(data: dict, key: str, type: type) -> None:
+    """
+    Creates instances of the specified type for a dictionary key if the key exists and its
+    current type does not match the specified type. This function modifies the dictionary
+    in place by converting the value associated with the key into an instance of the given
+    type.
+
+    This is typically used when a dictionary contains data that needs to be represented as
+    objects of a specific class type.
+
+    Args:
+        data (dict): The dictionary containing the key-value pair to inspect and possibly
+            convert.
+        key (str): The key in the dictionary whose value should be inspected and converted
+            if necessary.
+        type (type): The type to which the value of `key` should be converted, if it is not
+            already an instance of the type.
+
+    Returns:
+        None
+    """
+    if key in data and not isinstance(data[key], type):
+        data[key] = type(**data[key])
+
+numpy_array_short_validator = BeforeValidator(validate_numpy_array)
+
+# First, create a context variable
+loading_model_context = ContextVar('loading_model_context', default={})
+
+@contextmanager
+def loading_model_injection(surface_points_binary: np.ndarray, orientations_binary: np.ndarray):
+    token = loading_model_context.set({
+            'surface_points_binary': surface_points_binary,
+            'orientations_binary'  : orientations_binary
+    })
+    try:
+        yield
+    finally:
+        loading_model_context.reset(token)
+

gempy/core/data/encoders/converters.py

@@ -0,0 +1,8 @@
+import numpy as np
+
+
+def encode_numpy_array(array: np.ndarray):
+    # Check length 
+    if array.size > 10:
+        return []
+    return array.tolist()