Adding server files GEN-11702 (#9)

Adding server files

[WIP/TEST] Trying to add server tests

Author: Leguark

gempy_engine/API/server/_old_example.json

@@ -1,5 +1,6 @@
 import json
 import logging
+from typing import List
 
 import numpy as np
 import pandas as pd
@@ -12,92 +13,118 @@
 PLOT_SUBSURFACE_OBJECT = False
 
 
-def process_output(meshes: list[DualContouringMesh], n_stack: int, solutions: Solutions, logger: logging.Logger) \
-        -> bytes:
-    # * serialize meshes
+def process_output(
+    meshes: List[DualContouringMesh],
+    n_stack: int,
+    solutions: Solutions,
+    logger: logging.Logger
+) -> bytes:
+    """
+    Process model outputs into binary format for transmission.
+    
+    Args:
+        meshes: List of dual contouring meshes
+        n_stack: Number of stacks in the model
+        solutions: Model solutions containing octree data
+        logger: Logger instance
+        
+    Returns:
+        Binary data containing serialized meshes and octrees
+    """
+    # Serialize meshes
     unstructured_data_meshes: UnstructuredData = _meshes_to_unstruct(meshes, logger)
     if PLOT_SUBSURFACE_OBJECT:
         _plot_subsurface_object(unstructured_data_meshes)
-    body_meshes, header_meshes = unstructured_data_meshes.to_binary()
-    header_json = json.dumps(header_meshes)
-    header_json_bytes = header_json.encode('utf-8')
-    header_json_length = len(header_json_bytes)
-    header_json_length_bytes = header_json_length.to_bytes(4, byteorder='little')
-    body_meshes = header_json_length_bytes + header_json_bytes + body_meshes
-
-    # * serialize octrees
+    body_meshes = unstructured_data_meshes.to_binary()
+    
+    # Serialize octrees
     unstructured_data_volume = subsurface.UnstructuredData.from_array(
         vertex=solutions.octrees_output[0].grid_centers.values,
         cells="points",
         cells_attr=pd.DataFrame(
             data=solutions.octrees_output[0].last_output_center.ids_block,
             columns=['id']
-        )  # TODO: We have to create an array with the shape of simplex array with the id of each simplex
+        )
     )
+    body_volume = unstructured_data_volume.to_binary()
 
-    body_volume, header_volume = unstructured_data_volume.to_binary()
-    header_json = json.dumps(header_volume)
-    header_json_bytes = header_json.encode('utf-8')
-    header_json_length = len(header_json_bytes)
-    header_json_length_bytes = header_json_length.to_bytes(4, byteorder='little')
-    body_volume = header_json_length_bytes + header_json_bytes + body_volume
-
-    # * serialize global header
+    # Serialize global header and combine data
     body = body_meshes + body_volume
     global_header = json.dumps({"mesh_size": len(body_meshes), "octree_size": len(body_volume)})
     global_header_bytes = global_header.encode('utf-8')
     global_header_length = len(global_header_bytes)
     global_header_length_bytes = global_header_length.to_bytes(4, byteorder='little')
-    body = global_header_length_bytes + global_header_bytes + body
-    return body
+    
+    return global_header_length_bytes + global_header_bytes + body
 
 
-def _meshes_to_unstruct(meshes: list[DualContouringMesh], logger: logging.Logger) -> UnstructuredData:
-    # ? I added this function to the Solutions class
+def _meshes_to_unstruct(
+    meshes: List[DualContouringMesh], 
+    logger: logging.Logger
+) -> UnstructuredData:
+    """
+    Convert a list of dual contouring meshes to an unstructured data format.
+    
+    Args:
+        meshes: List of dual contouring meshes
+        logger: Logger instance
+        
+    Returns:
+        Unstructured data representation of the meshes
+    """
     n_meshes = len(meshes)
     logger.debug(f"Number of meshes: {n_meshes}")
-    logger.debug("Mesh1TriShape" + str(meshes[0].edges.shape))
+    logger.debug(f"Mesh1TriShape: {meshes[0].edges.shape}")
 
+    # Prepare the vertex array
     vertex_array = np.concatenate([meshes[i].vertices for i in range(n_meshes)])
+    
+    # Check for edge uniqueness (debugging)
     simplex_array = np.concatenate([meshes[i].edges for i in range(n_meshes)])
     unc, count = np.unique(simplex_array, axis=0, return_counts=True)
     logger.debug(f"edges shape {simplex_array.shape}")
 
-    # * Prepare the simplex array
+    # Prepare the simplex array with proper indexing
     simplex_array = meshes[0].edges
-    for i in range(1,n_meshes):
+    for i in range(1, n_meshes):
         adder = np.max(meshes[i - 1].edges) + 1
-        logger.debug("triangle counts adder:" + str(adder))
+        logger.debug(f"triangle counts adder: {adder}")
         add_mesh = meshes[i].edges + adder
         simplex_array = np.append(simplex_array, add_mesh, axis=0)
 
     logger.debug(f"edges shape {simplex_array.shape}")
 
-    # * Prepare the cells_attr array
+    # Prepare the cells_attr array
     ids_array = np.ones(simplex_array.shape[0])
     l0 = 0
-    id = 1
+    id_value = 1
     for mesh in meshes:
         l1 = l0 + mesh.edges.shape[0]
-        logger.debug(f"l0 {l0} l1 {l1} id {id}")
-        ids_array[l0:l1] = id
+        logger.debug(f"l0 {l0} l1 {l1} id {id_value}")
+        ids_array[l0:l1] = id_value
         l0 = l1
-        id += 1
-    logger.debug("ids_array count" + str(np.unique(ids_array)))
+        id_value += 1
+    logger.debug(f"ids_array count: {np.unique(ids_array)}")
 
-    # * Create the unstructured data
+    # Create the unstructured data
     unstructured_data = subsurface.UnstructuredData.from_array(
         vertex=vertex_array,
         cells=simplex_array,
-        cells_attr=pd.DataFrame(ids_array, columns=['id'])  # TODO: We have to create an array with the shape of simplex array with the id of each simplex
+        cells_attr=pd.DataFrame(ids_array, columns=['id'])
     )
 
     return unstructured_data
 
 
-def _plot_subsurface_object(unstructured_data):
+def _plot_subsurface_object(unstructured_data: UnstructuredData) -> None:
+    """
+    Visualize the unstructured data using subsurface.
+    
+    Args:
+        unstructured_data: The unstructured data to visualize
+    """
     print(unstructured_data)
     obj = subsurface.TriSurf(unstructured_data)
     pv_unstruct = subsurface.visualization.to_pyvista_mesh(obj)
     print(pv_unstruct)
-    subsurface.visualization.pv_plot([pv_unstruct])
+    subsurface.visualization.pv_plot([pv_unstruct])

gempy_engine/API/server/_process_output.py

@@ -1,14 +1,19 @@
-import sys
-import logging
+import logging
+import sys
+from typing import Tuple
 
-from gempy_engine.core.data.engine_grid import EngineGrid
-from core.data.regular_grid import RegularGrid
 from gempy_engine.core.data.input_data_descriptor import InputDataDescriptor
 from gempy_engine.core.data.interpolation_input import InterpolationInput
 from gempy_engine.core.data.kernel_classes.server.input_parser import GemPyInput
 
 
-def setup_logger():
+def setup_logger() -> logging.Logger:
+    """
+    Configure and set up a logger for the application.
+    
+    Returns:
+        logging.Logger: Configured logger instance with console and file handlers
+    """
     logger = logging.getLogger("my-fastapi-app")
     logger.setLevel(logging.DEBUG)
 
@@ -23,25 +28,38 @@ def setup_logger():
     fh = logging.FileHandler("app.log")
     fh.setLevel(logging.DEBUG)
     fh.setFormatter(formatter)
-    
-    # Add the console handler to the logger
+
+    # Add the handlers to the logger
     logger.addHandler(ch)
     logger.addHandler(fh)
 
     return logger
 
 
-def process_input(gempy_input: GemPyInput, logger: logging.Logger) -> (InputDataDescriptor, InterpolationInput, int):
+def process_input(
+    gempy_input: GemPyInput, 
+    logger: logging.Logger
+) -> Tuple[InputDataDescriptor, InterpolationInput, int]:
+    """
+    Process the GemPy input data to prepare it for model computation.
     
-    logger.debug("Input grid:", gempy_input.interpolation_input.grid)
-    
-    gempy_input.interpolation_input.grid = EngineGrid.from_regular_grid(
-        regular_grid=RegularGrid.from_schema(gempy_input.interpolation_input.grid)
-    )
+    Args:
+        gempy_input: Input data for the GemPy model
+        logger: Logger instance for recording processing information
+        
+    Returns:
+        Tuple containing:
+            - InputDataDescriptor: Structure descriptor for the model
+            - InterpolationInput: Prepared interpolation input data
+            - int: Number of stacks in the model
+    """
+    logger.debug(f"Input grid: {gempy_input.interpolation_input.grid}")
+
     interpolation_input: InterpolationInput = InterpolationInput.from_schema(gempy_input.interpolation_input)
     input_data_descriptor: InputDataDescriptor = InputDataDescriptor.from_schema(gempy_input.input_data_descriptor)
     n_stack = len(input_data_descriptor.stack_structure.masking_descriptor)
-    logger.debug("masking descriptor: ", input_data_descriptor.stack_structure.masking_descriptor)
-    logger.debug("stack structure: ", input_data_descriptor.stack_structure)
-    return input_data_descriptor, interpolation_input, n_stack
 
+    logger.debug(f"masking descriptor: {input_data_descriptor.stack_structure.masking_descriptor}")
+    logger.debug(f"stack structure: {input_data_descriptor.stack_structure}")
+    
+    return input_data_descriptor, interpolation_input, n_stack