[ENH] Implement ZIP-based model serialization format (#1035)

# Description
Refactored the model serialization system to use ZIP archives instead of raw binary files. This change:

- Implemented `model_to_bytes()` to replace `model_to_binary()`, creating a ZIP archive with header.json, input.bin, and grid.bin
- Added `_load_model_from_bytes()` to replace `_deserialize_binary_file()`, extracting data from the ZIP archive
- Updated references in save_model(), load_model(), and test verification helpers
- Added imports for io and zipfile modules

Relates to #serialization-improvement

# Checklist
- [ ] My code uses type hinting for function and method arguments and return values.
- [ ] I have created tests which cover my code.
- [ ] 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).
- [ ] New tests pass locally with my changes.

Author: Leguark

gempy/core/data/grid.py

@@ -95,13 +95,11 @@ def grid_binary(self):
         return custom_grid_bytes + topography_bytes
 
 
-    _grid_binary_size: int = 0
     @computed_field
     def binary_meta_data(self) -> dict:
         return {
                 'custom_grid_binary_length': len(self._custom_grid.values.astype("float64").tobytes()) if self._custom_grid else 0,
                 'topography_binary_length': len(self._topography.values.astype("float64").tobytes()) if self._topography else 0,
-                'grid_binary_size': self._grid_binary_size
         }
 
     @computed_field(alias="active_grids")

gempy/core/data/structural_frame.py

@@ -492,13 +492,11 @@ def deserialize_binary(cls, data: Union["StructuralFrame", dict], constructor: M
 
         # Access the context variable to get injected data
 
-    _input_binary_size: int = 0
     @computed_field
     def binary_meta_data(self) -> dict:
         return {
                 'sp_binary_length': len(self.surface_points_copy.data.tobytes()),
                 'ori_binary_length': len(self.orientations_copy.data.tobytes()) ,
-                'input_binary_size': self._input_binary_size
         }
 
     # endregion

gempy/modules/serialization/save_load.py

@@ -7,6 +7,8 @@
 from ...optional_dependencies import require_zlib
 import pathlib
 import os
+import io
+import zipfile
 
 
 def save_model(model: GeoModel, path: str | None = None, validate_serialization: bool = True):
@@ -44,10 +46,10 @@ def save_model(model: GeoModel, path: str | None = None, validate_serialization:
         # If no extension, add the valid extension
         path = str(path_obj) + VALID_EXTENSION
 
-    binary_file = model_to_binary(model)
+    binary_file = model_to_bytes(model)
 
     if validate_serialization:
-        model_deserialized = _deserialize_binary_file(binary_file)
+        model_deserialized = _load_model_from_bytes(binary_file)
         _validate_serialization(model, model_deserialized)
 
     # Create directory if it doesn't exist
@@ -129,8 +131,62 @@ def load_model(path: str) -> GeoModel:
     with open(path, 'rb') as f:
         binary_file = f.read()
 
-    return _deserialize_binary_file(binary_file)
+    return _load_model_from_bytes(binary_file)
 
+def model_to_bytes(model: GeoModel) -> bytes:
+    # 1) Make a fully deterministic JSON header
+    # header_dict = model.model_dump(by_alias=True)
+    # header_json = json.dumps(
+    #     header_dict,
+    #     sort_keys=True,          # always sort object keys
+    #     separators=(",", ":"),   # no extra whitespace
+    # ).encode("utf-8")
+    
+    header_json = model.model_dump_json(by_alias=True, indent=4)
+
+    # 2) Raw binary chunks (no additional zlib.compress here)
+    input_raw = model.structural_frame.input_tables_binary
+    grid_raw  = model.grid.grid_binary
+
+    # 3) Pack into a ZIP archive in a fixed order:
+    
+    buf = io.BytesIO()
+    with zipfile.ZipFile(
+            buf, mode="w",
+            compression=zipfile.ZIP_DEFLATED,
+            compresslevel=6
+    ) as zf:
+        # Force a fixed timestamp (1980-01-01) so the file headers don't vary
+        def make_info(name):
+            zi = zipfile.ZipInfo(name, date_time=(1980,1,1,0,0,0))
+            zi.external_attr = 0  # clear OS-specific file permissions
+            return zi
+
+        zf.writestr(make_info("header.json"), header_json)
+        zf.writestr(make_info("input.bin"),   input_raw)
+        zf.writestr(make_info("grid.bin"),    grid_raw)
+
+    return buf.getvalue()
+
+def _load_model_from_bytes(data: bytes) -> GeoModel:
+    import json, zlib
+    from ...core.data.encoders.converters import loading_model_from_binary
+
+    buf = io.BytesIO(data)
+    with zipfile.ZipFile(buf, "r") as zf:
+        header_json = zf.read("header.json").decode("utf-8")
+        # header      = json.loads(header_json)
+        input_raw   = zf.read("input.bin")
+        grid_raw    = zf.read("grid.bin")
+
+    # If you want to validate or decompress further, do it here…
+    with loading_model_from_binary(
+            input_binary=input_raw,
+            grid_binary= grid_raw
+    ):
+        model = GeoModel.model_validate_json(header_json)
+
+    return model
 
 def _deserialize_binary_file(binary_file):
     import json

test/test_modules/_geophysics_TO_UPDATE/test_gravity.test_gravity.verify/2-layers.approved.txt

@@ -55,11 +55,9 @@
         ],
         "is_dirty": true,
         "basement_color": "#ffbe00",
-        "_input_binary_size": 79,
         "binary_meta_data": {
             "sp_binary_length": 144,
-            "ori_binary_length": 60,
-            "input_binary_size": 79
+            "ori_binary_length": 60
         }
     },
     "grid": {
@@ -104,11 +102,9 @@
         },
         "_transform": null,
         "_octree_levels": -1,
-        "_grid_binary_size": 8,
         "binary_meta_data": {
             "custom_grid_binary_length": 0,
-            "topography_binary_length": 0,
-            "grid_binary_size": 8
+            "topography_binary_length": 0
         },
         "active_grids": 1058
     },

test/test_modules/test_faults/test_finite_faults.test_finite_fault_scalar_field_on_fault.verify/fault.approved.txt

@@ -129,11 +129,9 @@
         ],
         "is_dirty": true,
         "basement_color": "#728f02",
-        "_input_binary_size": 211,
         "binary_meta_data": {
             "sp_binary_length": 792,
-            "ori_binary_length": 300,
-            "input_binary_size": 211
+            "ori_binary_length": 300
         }
     },
     "grid": {
@@ -160,11 +158,9 @@
         "_centered_grid": null,
         "_transform": null,
         "_octree_levels": -1,
-        "_grid_binary_size": 8,
         "binary_meta_data": {
             "custom_grid_binary_length": 0,
-            "topography_binary_length": 0,
-            "grid_binary_size": 8
+            "topography_binary_length": 0
         },
         "active_grids": 1025
     },

test/test_modules/test_grids/test_custom_grid.test_custom_grid.verify/fold.approved.txt

@@ -61,11 +61,9 @@
         ],
         "is_dirty": true,
         "basement_color": "#ffbe00",
-        "_input_binary_size": 233,
         "binary_meta_data": {
             "sp_binary_length": 1296,
-            "ori_binary_length": 120,
-            "input_binary_size": 233
+            "ori_binary_length": 120
         }
     },
     "grid": {
@@ -92,11 +90,9 @@
         "_centered_grid": null,
         "_transform": null,
         "_octree_levels": -1,
-        "_grid_binary_size": 29,
         "binary_meta_data": {
             "custom_grid_binary_length": 192,
-            "topography_binary_length": 0,
-            "grid_binary_size": 29
+            "topography_binary_length": 0
         },
         "active_grids": 1029
     },

test/test_modules/test_grids/test_grids_sections.test_section_grids.verify/fold.approved.txt

@@ -61,11 +61,9 @@
         ],
         "is_dirty": true,
         "basement_color": "#ffbe00",
-        "_input_binary_size": 233,
         "binary_meta_data": {
             "sp_binary_length": 1296,
-            "ori_binary_length": 120,
-            "input_binary_size": 233
+            "ori_binary_length": 120
         }
     },
     "grid": {
@@ -154,11 +152,9 @@
         "_centered_grid": null,
         "_transform": null,
         "_octree_levels": -1,
-        "_grid_binary_size": 37758,
         "binary_meta_data": {
             "custom_grid_binary_length": 0,
-            "topography_binary_length": 86400,
-            "grid_binary_size": 37758
+            "topography_binary_length": 86400
         },
         "active_grids": 1049
     },

test/test_modules/test_grids/test_grids_sections.test_topography_II.verify/Model1.approved.txt

@@ -96,11 +96,9 @@
         ],
         "is_dirty": true,
         "basement_color": "#443988",
-        "_input_binary_size": 165,
         "binary_meta_data": {
             "sp_binary_length": 360,
-            "ori_binary_length": 120,
-            "input_binary_size": 165
+            "ori_binary_length": 120
         }
     },
     "grid": {
@@ -154,11 +152,9 @@
         "_centered_grid": null,
         "_transform": null,
         "_octree_levels": -1,
-        "_grid_binary_size": 20161,
         "binary_meta_data": {
             "custom_grid_binary_length": 0,
-            "topography_binary_length": 48000,
-            "grid_binary_size": 20161
+            "topography_binary_length": 48000
         },
         "active_grids": 1034
     },

test/test_modules/test_serialize_model.test_generate_horizontal_stratigraphic_model.verify/Horizontal Stratigraphic Model serialization.approved.txt

@@ -61,11 +61,9 @@
         ],
         "is_dirty": true,
         "basement_color": "#ffbe00",
-        "_input_binary_size": 0,
         "binary_meta_data": {
             "sp_binary_length": 432,
-            "ori_binary_length": 120,
-            "input_binary_size": 0
+            "ori_binary_length": 120
         }
     },
     "grid": {
@@ -92,11 +90,9 @@
         "_centered_grid": null,
         "_transform": null,
         "_octree_levels": -1,
-        "_grid_binary_size": 0,
         "binary_meta_data": {
             "custom_grid_binary_length": 0,
-            "topography_binary_length": 0,
-            "grid_binary_size": 0
+            "topography_binary_length": 0
         },
         "active_grids": 1026
     },

test/verify_helper.py

@@ -11,9 +11,7 @@
 from approvaltests.reporters import GenericDiffReporter, GenericDiffReporterConfig
 
 from gempy.core.data import GeoModel
-from gempy.modules.serialization.save_load import _to_binary, _deserialize_binary_file, model_to_binary
-from gempy.optional_dependencies import require_zlib
-
+from gempy.modules.serialization.save_load import _load_model_from_bytes, model_to_bytes
 
 class WSLWindowsDiffReporter(GenericDiffReporter):
     def get_command(self, received, approved):
@@ -120,7 +118,7 @@ def verify_model_serialization(model: GeoModel, verify_moment: Literal["before",
     Raises:
         ValueError: If `verify_moment` is not set to "before" or "after".
     """
-    binary_file = model_to_binary(model)
+    binary_file = model_to_bytes(model)
 
     original_model = model
     original_model.meta.creation_date = "<DATE_IGNORED>"
@@ -131,7 +129,7 @@ def verify_model_serialization(model: GeoModel, verify_moment: Literal["before",
             name=file_name
         )
     elif verify_moment == "after":
-        model_deserialized = _deserialize_binary_file(binary_file)
+        model_deserialized = _load_model_from_bytes(binary_file)
         model_deserialized.meta.creation_date = "<DATE_IGNORED>"
         verify_json(
             item=model_deserialized.model_dump_json(by_alias=True, indent=4),