Rename fsapi.FlowsheetExport dict() method and model_objects field to…

… resolve Pydantic 2.0 warnings (#1346)

* Convert deprecated method .dict() to .model_dump()

* Rename model_objects to exports b/c Pydantic model_ reserved namespace

* Undo .dict() -> .model_dump() for FlowsheetInterface (not a BaseModel)

watertap/ui/fsapi.py

@@ -271,7 +271,7 @@ class FlowsheetExport(BaseModel):
     obj: object = Field(default=None, exclude=True)
     name: Union[None, str] = Field(default="", validate_default=True)
     description: Union[None, str] = Field(default="", validate_default=True)
-    model_objects: Dict[str, ModelExport] = {}
+    exports: Dict[str, ModelExport] = {}
     version: int = 2
     requires_idaes_solver: bool = False
     dof: int = 0
@@ -349,15 +349,15 @@ def add(self, *args, data: Union[dict, ModelExport] = None, **kwargs) -> object:
             else:
                 model_export = data
         key = model_export.obj_key
-        if key in self.model_objects:
+        if key in self.exports:
             raise KeyError(
                 f"Adding ModelExport object failed: duplicate key '{key}' (model_export={model_export})"
             )
         if _log.isEnabledFor(logging.DEBUG):  # skip except in debug mode
             _log.debug(
-                f"Adding ModelExport object with key={key}: {model_export.dict()}"
+                f"Adding ModelExport object with key={key}: {model_export.model_dump()}"
             )
-        self.model_objects[key] = model_export
+        self.exports[key] = model_export
         return model_export
 
     def from_csv(self, file: Union[str, Path], flowsheet):
@@ -494,10 +494,10 @@ def to_csv(self, output: Union[TextIOBase, Path, str] = None) -> int:
         csv_output_file = writer(output_file)
 
         # write header row
-        obj = next(iter(self.model_objects.values()))
+        obj = next(iter(self.exports.values()))
         values = ["obj", "ui_units"]
         col_idx_map = {}
-        for i, field_name in enumerate(obj.dict()):
+        for i, field_name in enumerate(obj.model_dump()):
             # add to mapping of field name to column number
             col_idx_map[field_name] = i + 2
             # add column name
@@ -507,14 +507,14 @@ def to_csv(self, output: Union[TextIOBase, Path, str] = None) -> int:
 
         # write a row for each object
         num = 0
-        for key, obj in self.model_objects.items():
+        for key, obj in self.exports.items():
             # initialize values list
             #   first 2 column values are object name and units
             obj_name = self._massage_object_name(key)
             units_str = self._massage_ui_units(str(obj.ui_units))
             values = [obj_name, units_str] + [""] * (ncol - 2)
             # add columns
-            for field_name, field_value in obj.dict().items():
+            for field_name, field_value in obj.model_dump().items():
                 values[col_idx_map[field_name]] = field_value
             # write row
             csv_output_file.writerow(values)
@@ -707,7 +707,7 @@ def dict(self) -> Dict:
         Returns:
             Serialized contained FlowsheetExport object
         """
-        return self.fs_exp.dict(exclude={"obj"})
+        return self.fs_exp.model_dump(exclude={"obj"})
 
     def load(self, data: Dict):
         """Load values from the data into corresponding variables in this
@@ -721,10 +721,10 @@ def load(self, data: Dict):
         # Set the value for each input variable
         missing = []
         # 'src' is the data source and 'dst' is this flowsheet (destination)
-        for key, src in fs.model_objects.items():
+        for key, src in fs.exports.items():
             # get corresponding exported variable
             try:
-                dst = self.fs_exp.model_objects[key]
+                dst = self.fs_exp.exports[key]
             except KeyError:
                 missing.append((key, src.name))
                 continue
@@ -845,8 +845,8 @@ def action_wrapper(**kwargs):
                         "constructor or call `add_action(Actions.export, <function>)` "
                         "on FlowsheetInterface instance."
                     )
-                # clear model_objects dict, since duplicates not allowed
-                self.fs_exp.model_objects.clear()
+                # clear exports dict, since duplicates not allowed
+                self.fs_exp.exports.clear()
                 # use get_action() since run_action() will refuse to call it directly
                 self.get_action(Actions.export)(
                     exports=self.fs_exp, build_options=self.fs_exp.build_options
@@ -909,7 +909,7 @@ def export_values(self):
         _log.info("Exporting values from flowsheet model to UI")
         u = pyo.units
         self.fs_exp.dof = degrees_of_freedom(self.fs_exp.obj)
-        for key, mo in self.fs_exp.model_objects.items():
+        for key, mo in self.fs_exp.exports.items():
             mo.value = pyo.value(u.convert(mo.obj, to_units=mo.ui_units))
             # print(f'{key} is being set to: {mo.value}')
             if hasattr(mo.obj, "bounds"):

watertap/ui/tests/test_flowsheet_interfaces.py

@@ -70,14 +70,14 @@ def data_post_build(self, fs_interface) -> dict:
     def test_build(self, data_post_build):
         data = data_post_build
         assert data
-        assert "model_objects" in data
+        assert "exports" in data
 
     @pytest.fixture
-    def model_objects(self, data_post_build):
-        return data_post_build["model_objects"]
+    def exports(self, data_post_build):
+        return data_post_build["exports"]
 
-    def test_model_objects(self, model_objects):
-        assert len(model_objects) > 0
+    def test_exports(self, exports):
+        assert len(exports) > 0
 
     @pytest.fixture
     def solve_results(self, fs_interface, data_post_build):

watertap/ui/tests/test_fsapi.py

@@ -139,8 +139,8 @@ def test_build():
     fsi.build(erd_type="pressure_exchanger")
     data = fsi.dict()
     print(data)
-    assert "model_objects" in data
-    assert len(data["model_objects"]) == 1
+    assert "exports" in data
+    assert len(data["exports"]) == 1
 
 
 @pytest.mark.parametrize(
@@ -267,22 +267,22 @@ def test_load():
     fsi = flowsheet_interface()
     fsi.build(erd_type="pressure_exchanger")
     # get some info
-    var_key = list(fsi.fs_exp.model_objects.keys())[0]
-    var_obj = fsi.fs_exp.model_objects[var_key].obj
+    var_key = list(fsi.fs_exp.exports.keys())[0]
+    var_obj = fsi.fs_exp.exports[var_key].obj
     save_value = var_obj.value
     # serialize
     data = fsi.dict()
     # modify
-    data["model_objects"][var_key]["value"] = -1000
+    data["exports"][var_key]["value"] = -1000
     # reload
     fsi.load(data)
     # check
-    assert fsi.fs_exp.model_objects[var_key].value == -1000
+    assert fsi.fs_exp.exports[var_key].value == -1000
 
     # this time with a missing thing
     data = fsi.dict()
     # add another (fake) one
-    data["model_objects"]["foobar"] = data["model_objects"][var_key].copy()
+    data["exports"]["foobar"] = data["exports"][var_key].copy()
     # reload (fake one will be 'missing')
     try:
         fsi.load(data)
@@ -322,11 +322,11 @@ def test_export_values():
     d1 = fsi.dict()
 
     # change one value
-    key = list(fsi.fs_exp.model_objects.keys())[0]
-    orig_value = value(fsi.fs_exp.model_objects[key].obj)
+    key = list(fsi.fs_exp.exports.keys())[0]
+    orig_value = value(fsi.fs_exp.exports[key].obj)
     new_value = orig_value + 1
     print(f"@@ orig_value = {orig_value}, new value = {new_value}")
-    fsi.fs_exp.model_objects[key].obj.value = new_value
+    fsi.fs_exp.exports[key].obj.value = new_value
 
     # re-export
     fsi.export_values()
@@ -368,10 +368,10 @@ def test_nonoptimal_termination():
     fsi.build()
 
     # pick a crazy value
-    key = list(fsi.fs_exp.model_objects.keys())[0]
-    orig_value = value(fsi.fs_exp.model_objects[key].obj)
+    key = list(fsi.fs_exp.exports.keys())[0]
+    orig_value = value(fsi.fs_exp.exports[key].obj)
     new_value = orig_value + 1e9
-    fsi.fs_exp.model_objects[key].obj.value = new_value
+    fsi.fs_exp.exports[key].obj.value = new_value
     print(f"* orig_value = {orig_value}, new value = {new_value}")
 
     # try to solve (for real)