Refactor/ support both Pydantic 1 and 2

.github/workflows/basic.yml

@@ -69,7 +69,7 @@ jobs:
             pip install -I --upgrade certifi
 
         - name: Install Ubuntu compilers
-          if: matrix.os == 'ubuntu-latest'
+          if: matrix.os == 'ubuntu-latest' && steps.cache.outputs.cache-hit != 'true'
           run: conda install gcc_linux-64
 
         # Roundabout solution on macos for proper linking with mpicc
@@ -86,7 +86,7 @@ jobs:
             pip install -r install/misc_feature_requirements.txt
 
         - name: Install mpi4py and MPI from conda
-          if: (matrix.python-version != '3.10' && matrix.os == 'ubuntu-latest') || matrix.os == 'macos-latest'
+          if: (matrix.python-version != '3.10' && matrix.os == 'ubuntu-latest') || matrix.os == 'macos-latest' && steps.cache.outputs.cache-hit != 'true'
           run: |
             conda install mpi4py ${{ matrix.mpi-version }}
 

libensemble/ensemble.py

@@ -322,7 +322,7 @@ def libE_specs(self, new_specs):
 
         # Cast new libE_specs temporarily to dict
         if not isinstance(new_specs, dict):
-            new_specs = new_specs.dict(by_alias=True, exclude_none=True, exclude_unset=True)
+            new_specs = new_specs.model_dump(by_alias=True, exclude_none=True, exclude_unset=True)
 
         # Unset "comms" if we already have a libE_specs that contains that field, that came from parse_args
         if new_specs.get("comms") and hasattr(self._libE_specs, "comms") and self.parsed:
@@ -459,14 +459,7 @@ def _parse_spec(self, loaded_spec):
 
         if len(userf_fields):
             for f in userf_fields:
-                if f == "inputs":
-                    loaded_spec["in"] = field_f[f](loaded_spec[f])
-                    loaded_spec.pop("inputs")
-                elif f == "outputs":
-                    loaded_spec["out"] = field_f[f](loaded_spec[f])
-                    loaded_spec.pop("outputs")
-                else:
-                    loaded_spec[f] = field_f[f](loaded_spec[f])
+                loaded_spec[f] = field_f[f](loaded_spec[f])
 
         return loaded_spec
 
@@ -482,13 +475,9 @@ def _parameterize(self, loaded):
                     old_spec.pop("inputs")  # avoid clashes
                 elif old_spec.get("out") and old_spec.get("outputs"):
                     old_spec.pop("inputs")  # avoid clashes
-            elif isinstance(old_spec, ClassType):
-                old_spec.__dict__.update(**loaded_spec)
-                old_spec = old_spec.dict(by_alias=True)
+                setattr(self, f, ClassType(**old_spec))
             else:  # None. attribute not set yet
                 setattr(self, f, ClassType(**loaded_spec))
-                return
-            setattr(self, f, ClassType(**old_spec))
 
     def from_yaml(self, file_path: str):
         """Parameterizes libEnsemble from ``yaml`` file"""

libensemble/libE.py

@@ -229,11 +229,11 @@ def libE(
     )
 
     # get corresponding dictionaries back (casted in libE() def)
-    sim_specs = ensemble.sim_specs.dict(by_alias=True)
-    gen_specs = ensemble.gen_specs.dict(by_alias=True)
-    exit_criteria = ensemble.exit_criteria.dict(by_alias=True, exclude_none=True)
-    alloc_specs = ensemble.alloc_specs.dict(by_alias=True)
-    libE_specs = ensemble.libE_specs.dict(by_alias=True)
+    sim_specs = ensemble.sim_specs.model_dump(by_alias=True)
+    gen_specs = ensemble.gen_specs.model_dump(by_alias=True)
+    exit_criteria = ensemble.exit_criteria.model_dump(by_alias=True, exclude_none=True)
+    alloc_specs = ensemble.alloc_specs.model_dump(by_alias=True)
+    libE_specs = ensemble.libE_specs.model_dump(by_alias=True)
 
     # Extract platform info from settings or environment
     platform_info = get_platform(libE_specs)

libensemble/resources/platforms.py

@@ -12,9 +12,7 @@
 import subprocess
 from typing import Optional
 
-from pydantic import BaseConfig, BaseModel, root_validator, validator
-
-BaseConfig.validate_assignment = True
+from pydantic import BaseModel, ConfigDict, field_validator, model_validator
 
 
 class PlatformException(Exception):
@@ -28,25 +26,25 @@ class Platform(BaseModel):
     All are optional, and any not defined will be determined by libEnsemble's auto-detection.
     """
 
-    mpi_runner: Optional[str]
+    mpi_runner: Optional[str] = None
     """MPI runner: One of ``"mpich"``, ``"openmpi"``, ``"aprun"``,
     ``"srun"``, ``"jsrun"``, ``"msmpi"``, ``"custom"`` """
 
-    runner_name: Optional[str]
+    runner_name: Optional[str] = None
     """Literal string of MPI runner command. Only needed if different to the default
 
     Note that ``"mpich"`` and ``"openmpi"`` runners have the default command ``"mpirun"``
     """
-    cores_per_node: Optional[int]
+    cores_per_node: Optional[int] = None
     """Number of physical CPU cores on a compute node of the platform"""
 
-    logical_cores_per_node: Optional[int]
+    logical_cores_per_node: Optional[int] = None
     """Number of logical CPU cores on a compute node of the platform"""
 
-    gpus_per_node: Optional[int]
+    gpus_per_node: Optional[int] = None
     """Number of GPU devices on a compute node of the platform"""
 
-    gpu_setting_type: Optional[str]
+    gpu_setting_type: Optional[str] = None
     """ How GPUs will be assigned.
 
     Must take one of the following string options.
@@ -82,14 +80,14 @@ class Platform(BaseModel):
 
     """
 
-    gpu_setting_name: Optional[str]
+    gpu_setting_name: Optional[str] = None
     """Name of GPU setting
 
     See :attr:`gpu_setting_type` for more details.
 
     """
 
-    gpu_env_fallback: Optional[str]
+    gpu_env_fallback: Optional[str] = None
     """GPU fallback environment setting if not using an MPI runner.
 
     For example:
@@ -106,7 +104,7 @@ class Platform(BaseModel):
 
     """
 
-    scheduler_match_slots: Optional[bool]
+    scheduler_match_slots: Optional[bool] = None
     """
     Whether the libEnsemble resource scheduler should only assign matching slots when
     there are multiple (partial) nodes assigned to a sim function.
@@ -120,8 +118,12 @@ class Platform(BaseModel):
     application-level scheduler to manage GPUs, then ``match_slots`` can be **False**
     (allowing for more efficient scheduling when MPI runs cross nodes).
     """
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, populate_by_name=True, extra="forbid", validate_assignment=True
+    )
 
-    @validator("gpu_setting_type")
+    @field_validator("gpu_setting_type")
+    @classmethod
     def check_gpu_setting_type(cls, value):
         if value is not None:
             assert value in [
@@ -132,19 +134,20 @@ def check_gpu_setting_type(cls, value):
             ], "Invalid label for GPU specification type"
         return value
 
-    @validator("mpi_runner")
+    @field_validator("mpi_runner")
+    @classmethod
     def check_mpi_runner_type(cls, value):
         if value is not None:
             assert value in ["mpich", "openmpi", "aprun", "srun", "jsrun", "msmpi", "custom"], "Invalid MPI runner name"
         return value
 
-    @root_validator
-    def check_logical_cores(cls, values):
-        if values.get("cores_per_node") and values.get("logical_cores_per_node"):
+    @model_validator(mode="after")
+    def check_logical_cores(self):
+        if self.__dict__.get("cores_per_node") and self.__dict__.get("logical_cores_per_node"):
             assert (
-                values["logical_cores_per_node"] % values["cores_per_node"] == 0
+                self.logical_cores_per_node % self.cores_per_node == 0
             ), "Logical cores doesn't divide evenly into cores"
-        return values
+        return self
 
 
 # On SLURM systems, let srun assign free GPUs on the node
@@ -298,9 +301,9 @@ def known_envs():
     platform_info = {}
     if os.environ.get("NERSC_HOST") == "perlmutter":
         if os.environ.get("SLURM_JOB_PARTITION").startswith("gpu_"):
-            platform_info = PerlmutterGPU().dict(by_alias=True)
+            platform_info = PerlmutterGPU().model_dump(by_alias=True)
         else:
-            platform_info = PerlmutterCPU().dict(by_alias=True)
+            platform_info = PerlmutterCPU().model_dump(by_alias=True)
     return platform_info
 
 
@@ -314,7 +317,7 @@ def known_system_detect(cmd="hostname -d"):
     platform_info = {}
     try:
         domain_name = subprocess.check_output(run_cmd).decode().rstrip()
-        platform_info = detect_systems[domain_name]().dict(by_alias=True)
+        platform_info = detect_systems[domain_name]().model_dump(by_alias=True)
     except Exception:
         platform_info = known_envs()
     return platform_info
@@ -333,7 +336,7 @@ def get_platform(libE_specs):
     name = libE_specs.get("platform") or os.environ.get("LIBE_PLATFORM")
     if name:
         try:
-            known_platforms = Known_platforms().dict()
+            known_platforms = Known_platforms().model_dump()
             platform_info = known_platforms[name]
         except KeyError:
             raise PlatformException(f"Error. Unknown platform requested {name}")