♻️feat(links/paths) remove links/paths and CGNS linking capacities

CHANGELOG.md

@@ -23,9 +23,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Removed
 
+- (sample/features) cgns links and paths, as well as args `mesh_base_name` and `mesh_zone_name`
 - (sample) time_series support, now handle directly globals at time steps.
 
-
 ## [0.1.9] - 2025-09-24
 
 ### Added

examples/containers/sample_example.py

@@ -56,7 +56,7 @@ def show_sample(sample: Sample):
 # %% [markdown]
 # ## Section 1: Initializing an Empty Sample and Adding Data
 #
-# This section demonstrates how to initialize an empty Sample and add scalars, and meshes / CGNS trees.
+# This section demonstrates how to initialize an empty Sample and add scalars, time series data, and meshes / CGNS trees.
 
 # %% [markdown]
 # ### Create and display CGNS tree from an unstructured mesh
@@ -146,17 +146,7 @@ def show_sample(sample: Sample):
 # Set meshes in the Sample
 new_sample_mult_mesh.features.set_meshes(meshes_dict)
 
-print(f"{new_sample_mult_mesh.features.get_all_mesh_times() = }")
-
-# %% [markdown]
-# ### Link tree from another sample
-
-# %%
-path_linked_sample = Path.cwd() / "dataset/samples/sample_000000000/meshes/mesh_000000000.cgns"
-new_sample_mult_mesh.link_tree(
-    path_linked_sample, linked_sample=sample, linked_time=0.0, time=1.5
-)
-print(f"{new_sample_mult_mesh.features.get_all_mesh_times() = }")
+print(f"{new_sample_mult_mesh.get_all_mesh_times() = }")
 
 # %% [markdown]
 # ## Section 2: Accessing and Modifying Sample Data

src/plaid/bridges/huggingface_bridge.py

@@ -132,30 +132,21 @@ def to_plaid_sample(hf_sample: dict[str, bytes]) -> Sample:
         return Sample.model_validate(pickled_hf_sample)
 
     except ValidationError:
-        # If it fails, try to build the sample from its components
-        try:
-            scalars = pickled_hf_sample["scalars"]
-            meshes = pickled_hf_sample["meshes"]
-
-            features = SampleFeatures(
-                data=meshes,
-                mesh_base_name=pickled_hf_sample.get("mesh_base_name"),
-                mesh_zone_name=pickled_hf_sample.get("mesh_zone_name"),
-                links=pickled_hf_sample.get("links"),
-                paths=pickled_hf_sample.get("paths"),
-            )
+        features = SampleFeatures(
+            data=pickled_hf_sample.get("meshes"),
+        )
 
-            sample = Sample(
-                path=pickled_hf_sample.get("path"),
-                features=features,
-            )
+        sample = Sample(
+            path=pickled_hf_sample.get("path"),
+            features=features,
+        )
 
+        scalars = pickled_hf_sample.get("scalars")
+        if scalars:
             for sn, val in scalars.items():
                 sample.add_scalar(sn, val)
 
-            return Sample.model_validate(sample)
-        except KeyError as e:
-            raise KeyError(f"Missing key {e!s} in HF data.") from e
+        return Sample.model_validate(sample)
 
 
 def generate_huggingface_description(

src/plaid/containers/features.py

@@ -1,11 +1,8 @@
 """Module for implementing collections of features within a Sample."""
 
-import copy
 import logging
-from pathlib import Path
 from typing import Optional
 
-import CGNS.MAP as CGM
 import CGNS.PAT.cgnskeywords as CGK
 import CGNS.PAT.cgnslib as CGL
 import CGNS.PAT.cgnsutils as CGU
@@ -20,7 +17,7 @@
     _check_names,
     _read_index,
 )
-from plaid.types import Array, CGNSLink, CGNSNode, CGNSPath, CGNSTree, Field
+from plaid.types import Array, CGNSNode, CGNSTree, Field
 from plaid.utils import cgns_helper as CGH
 
 logger = logging.getLogger(__name__)
@@ -31,31 +28,18 @@ class SampleFeatures:
 
     Args:
         data (dict[float, CGNSTree], optional): A dictionary mapping time steps to CGNSTrees. Defaults to None.
-        mesh_base_name (str, optional): The base name for the mesh. Defaults to 'Base'.
-        mesh_zone_name (str, optional): The zone name for the mesh. Defaults to 'Zone'.
-        links (dict[float, list[CGNSLink]], optional): A dictionary mapping time steps to lists of links. Defaults to None.
-        paths (dict[float, list[CGNSPath]], optional): A dictionary mapping time steps to lists of paths. Defaults to None.
     """
 
     def __init__(
         self,
         data: Optional[dict[float, CGNSTree]] = None,
-        mesh_base_name: str = "Base",
-        mesh_zone_name: str = "Zone",
-        links: Optional[dict[float, list[CGNSLink]]] = None,
-        paths: Optional[dict[float, list[CGNSPath]]] = None,
     ):
         self.data: dict[float, CGNSTree] = data if data is not None else {}
-        self._links = links if links is not None else {}
-        self._paths = paths if paths is not None else {}
 
         self._default_active_base: Optional[str] = None
         self._default_active_zone: Optional[str] = None
         self._default_active_time: Optional[float] = None
 
-        self._mesh_base_name: str = mesh_base_name
-        self._mesh_zone_name: str = mesh_zone_name
-
     # -------------------------------------------------------------------------#
 
     def set_default_base(self, base_name: str, time: Optional[float] = None) -> None:
@@ -160,6 +144,8 @@ def set_default_zone_base(
 
         self._default_active_zone = zone_name
 
+    # -------------------------------------------------------------------------#
+
     def set_default_time(self, time: float) -> None:
         """Set the default time for the system.
 
@@ -327,36 +313,16 @@ def init_tree(self, time: Optional[float] = None) -> CGNSTree:
 
         if not self.data:
             self.data = {time: CGL.newCGNSTree()}
-            self._links = {time: None}
-            self._paths = {time: None}
         elif time not in self.data:
             self.data[time] = CGL.newCGNSTree()
-            self._links[time] = None
-            self._paths[time] = None
 
         return self.data[time]
 
-    def get_links(self, time: Optional[float] = None) -> list[CGNSLink]:
-        """Retrieve the CGNS links for a specified time step, if available.
-
-        Args:
-            time (float, optional): The time step for which to retrieve the CGNS links. If a specific time is not provided, the method will display the links for the default time step.
-
-        Returns:
-            list: The CGNS links for the specified time step if available; otherwise, returns None.
-        """
-        time = self.get_time_assignment(time)
-        return self._links[time] if (self._links) else None
-
-    def get_mesh(
-        self, time: Optional[float] = None, apply_links: bool = False, in_memory=False
-    ) -> Optional[CGNSTree]:
+    def get_mesh(self, time: Optional[float] = None) -> Optional[CGNSTree]:
         """Retrieve the CGNS tree structure for a specified time step, if available.
 
         Args:
             time (float, optional): The time step for which to retrieve the CGNS tree structure. If a specific time is not provided, the method will display the tree structure for the default time step.
-            apply_links (bool, optional): Activates the following of the CGNS links to reconstruct the complete CGNS tree - in this case, a deepcopy of the tree is made to prevent from modifying the existing tree.
-            in_memory (bool, optional): Active if apply_links == True, ONLY WORKING if linked mesh is in the current sample. This option follows the link in memory from current sample.
 
         Returns:
             CGNSTree: The CGNS tree structure for the specified time step if available; otherwise, returns None.
@@ -365,28 +331,7 @@ def get_mesh(
             return None
 
         time = self.get_time_assignment(time)
-        tree = self.data[time]
-
-        links = self.get_links(time)
-        if not apply_links or links is None:
-            return tree
-
-        tree = copy.deepcopy(tree)
-        for link in links:
-            if not in_memory:
-                subtree, _, _ = CGM.load(str(Path(link[0]) / link[1]), subtree=link[2])
-            else:
-                linked_timestep = int(link[1].split(".cgns")[0].split("_")[1])
-                linked_timestamp = list(self.data.keys())[linked_timestep]
-                subtree = self.get_mesh(linked_timestamp)
-            node_path = "/".join(link[2].split("/")[:-1])
-            node_to_append = CGU.getNodeByPath(tree, node_path)
-            assert node_to_append is not None, (
-                f"nodepath {node_path} not present in tree, cannot apply link"
-            )
-            node_to_append[2].append(CGU.getNodeByPath(subtree, link[2]))
-
-        return tree
+        return self.data[time]
 
     def set_meshes(self, meshes: dict[float, CGNSTree]) -> None:
         """Set all meshes with their corresponding time step.
@@ -399,11 +344,6 @@ def set_meshes(self, meshes: dict[float, CGNSTree]) -> None:
         """
         if not self.data:
             self.data = meshes
-            self._links = {}
-            self._paths = {}
-            for time in self.data.keys():
-                self._links[time] = None
-                self._paths[time] = None
         else:
             raise KeyError(
                 "meshes is already set, you cannot overwrite it, delete it first or extend it with `Sample.add_tree`"
@@ -432,12 +372,8 @@ def add_tree(self, tree: CGNSTree, time: Optional[float] = None) -> CGNSTree:
 
         if not self.data:
             self.data = {time: tree}
-            self._links = {time: None}
-            self._paths = {time: None}
         elif time not in self.data:
             self.data[time] = tree
-            self._links[time] = None
-            self._paths[time] = None
         else:
             # TODO: gérer le cas où il y a des bases de mêmes noms... + merge
             # récursif des nœuds
@@ -481,8 +417,6 @@ def del_tree(self, time: float) -> CGNSTree:
         if time not in self.data:
             raise KeyError(f"There is no CGNS tree for time {time}.")
 
-        self._links.pop(time, None)
-        self._paths.pop(time, None)
         return self.data.pop(time)
 
     # -------------------------------------------------------------------------#
@@ -557,13 +491,7 @@ def init_base(
         time = self.get_time_assignment(time)
 
         if base_name is None:
-            base_name = (
-                self._mesh_base_name
-                + "_"
-                + str(topological_dim)
-                + "_"
-                + str(physical_dim)
-            )
+            base_name = "Base_" + str(topological_dim) + "_" + str(physical_dim)
 
         self.init_tree(time)
         if not (self.has_base(base_name, time)):
@@ -662,7 +590,6 @@ def has_globals(self, time: Optional[float] = None) -> bool:
         Returns:
             bool: `True` if the CGNS tree has a Base called `Globals`, else return `False`.
         """
-        # print(">>>>>>>>>>>", self.get_base_names(time=time))
         return "Global" in self.get_base_names(time=time)
 
     def get_base(
@@ -725,8 +652,7 @@ def init_zone(
 
         zone_name = self.get_zone_assignment(zone_name, base_name, time)
         if zone_name is None:
-            zone_name = self._mesh_zone_name
-
+            zone_name = "Zone"
         zone_node = CGL.newZone(base_node, zone_name, zone_shape, zone_type)
         return zone_node