Fix bugs with pandas 1.5.0

Author: enekomartinmartinez

docs/whats_new.rst

@@ -1,5 +1,30 @@
 What's New
 ==========
+v3.7.1 (2022/09/19)
+-------------------
+
+New Features
+~~~~~~~~~~~~
+
+Breaking changes
+~~~~~~~~~~~~~~~~
+
+Deprecations
+~~~~~~~~~~~~
+
+Bug fixes
+~~~~~~~~~
+- Fix bugs with :py:class:`pandas.DataFrame` 1.5.0 (:issue:`366`). (`@enekomartinmartinez <https://github.com/enekomartinmartinez>`_)
+
+Documentation
+~~~~~~~~~~~~~
+
+Performance
+~~~~~~~~~~~
+
+Internal Changes
+~~~~~~~~~~~~~~~~
+
 v3.7.0 (2022/09/19)
 -------------------
 

pysd/_version.py

@@ -1 +1 @@
-__version__ = "3.7.0"
+__version__ = "3.7.1"

pysd/py_backend/model.py

@@ -1175,7 +1175,6 @@ def run(self, params=None, return_columns=None, return_timestamps=None,
         # create a dictionary splitting run cached and others
         capture_elements = self._split_capture_elements(capture_elements)
 
-
         # include outputs in cache if needed
         self._dependencies["OUTPUTS"] = {
             element: 1 for element in capture_elements["step"]
@@ -1622,11 +1621,11 @@ def _split_capture_elements(self, capture_elements):
         Returns
         -------
         capture_dict: dict
-            Dictionary of sets with keywords step and run.
+            Dictionary of list with keywords step and run.
 
         """
-        capture_dict = {'step': set(), 'run': set(), None: set()}
-        [capture_dict[self.cache_type[element]].add(element)
+        capture_dict = {'step': [], 'run': [], None: []}
+        [capture_dict[self.cache_type[element]].append(element)
          for element in capture_elements]
         return capture_dict
 

pysd/py_backend/output.py

@@ -30,7 +30,7 @@ class ModelOutput():
     ----------
     model: pysd.Model
         PySD Model object
-    capture_elements: set
+    capture_elements: list
         Which model elements to capture - uses pysafe names.
     out_file: str or pathlib.Path
         Path to the file where the results will be written.
@@ -44,7 +44,7 @@ def __init__(self, model, capture_elements, out_file=None):
         # want them to run (DataFrameHandler runs first)
         self.handler = DataFrameHandler(DatasetHandler(None)).handle(out_file)
 
-        capture_elements.add("time")
+        capture_elements.append("time")
         self.capture_elements = capture_elements
 
         self.initialize(model)
@@ -206,7 +206,7 @@ def initialize(self, model, capture_elements):
         ----------
         model: pysd.Model
             PySD Model object
-        capture_elements: set
+        capture_elements: list
             Which model elements to capture - uses pysafe names.
 
         Returns
@@ -246,14 +246,14 @@ def initialize(self, model, capture_elements):
 
     def update(self, model, capture_elements):
         """
-        Writes values of cache step variables from the capture_elements set
-        in the netCDF4 Dataset.
+        Writes values of cache step variables from the capture_elements
+        list in the netCDF4 Dataset.
 
         Parameters
         ----------
         model: pysd.Model
             PySD Model object
-        capture_elements: set
+        capture_elements: list
             Which model elements to capture - uses pysafe names.
 
         Returns
@@ -280,7 +280,7 @@ def __update_run_elements(self, model, capture_elements):
         ----------
         model: pysd.Model
             PySD Model object
-        capture_elements: set
+        capture_elements: list
             Which model elements to capture - uses pysafe names.
 
         Returns
@@ -335,7 +335,7 @@ def __create_ds_vars(self, model, capture_elements, time_dim=True):
         ----------
         model: pysd.Model
             PySD Model object
-        capture_elements: set
+        capture_elements: list
             Which model elements to capture - uses pysafe names.
         time_dim: bool
             Whether to add time as the first dimension for the variable.
@@ -413,7 +413,7 @@ def initialize(self, model, capture_elements):
         ----------
         model: pysd.Model
             PySD Model object
-        capture_elements: set
+        capture_elements: list
             Which model elements to capture - uses pysafe names.
 
         Returns
@@ -432,15 +432,15 @@ def update(self, model, capture_elements):
         ----------
         model: pysd.Model
             PySD Model object
-        capture_elements: set
+        capture_elements: list
             Which model elements to capture - uses pysafe names.
 
         Returns
         -------
         None
 
         """
-        self.ds.at[model.time.round()] = [
+        self.ds.loc[model.time.round()] = [
             getattr(model.components, key)()
             for key in capture_elements]
 
@@ -506,7 +506,7 @@ def add_run_elements(self, model, capture_elements):
         ----------
         model: pysd.Model
             PySD Model object
-        capture_elements: set
+        capture_elements: list
             Which model elements to capture - uses pysafe names.
 
         Returns

tests/pytest_pysd/pytest_output.py

@@ -306,7 +306,7 @@ def test_output_csv(self, fmt, sep, capsys, model, tmp_path):
 
     @pytest.mark.parametrize("model_path", [test_model_look])
     def test_dataset_handler_step_setter(self, tmp_path, model):
-        capture_elements = set()
+        capture_elements = []
         results = tmp_path.joinpath("results.nc")
         output = ModelOutput(model, capture_elements, results)
 
@@ -322,10 +322,10 @@ def test_dataset_handler_step_setter(self, tmp_path, model):
     def test_make_flat_df(self):
 
         df = pd.DataFrame(index=[1], columns=['elem1'])
-        df.at[1] = [xr.DataArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-                                 {'Dim1': ['A', 'B', 'C'],
-                                  'Dim2': ['D', 'E', 'F']},
-                                 dims=['Dim1', 'Dim2'])]
+        df.loc[1] = [xr.DataArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+                                  {'Dim1': ['A', 'B', 'C'],
+                                   'Dim2': ['D', 'E', 'F']},
+                                  dims=['Dim1', 'Dim2'])]
 
         expected = pd.DataFrame(index=[1], data={'Elem1[B,F]': 6.})
 
@@ -341,7 +341,7 @@ def test_make_flat_df(self):
     def test_make_flat_df_0dxarray(self):
 
         df = pd.DataFrame(index=[1], columns=['elem1'])
-        df.at[1] = [xr.DataArray(5)]
+        df.loc[1] = [xr.DataArray(5)]
 
         expected = pd.DataFrame(index=[1], data={'Elem1': 5.})
 
@@ -357,10 +357,10 @@ def test_make_flat_df_0dxarray(self):
     def test_make_flat_df_nosubs(self):
 
         df = pd.DataFrame(index=[1], columns=['elem1', 'elem2'])
-        df.at[1] = [25, 13]
+        df.loc[1] = [25, 13]
 
         expected = pd.DataFrame(index=[1], columns=['Elem1', 'Elem2'])
-        expected.at[1] = [25, 13]
+        expected.loc[1] = [25, 13]
 
         return_addresses = {'Elem1': ('elem1', {}),
                             'Elem2': ('elem2', {})}
@@ -378,24 +378,24 @@ def test_make_flat_df_return_array(self):
         the simulation dictionary. in this case, we can't force to float..."""
 
         df = pd.DataFrame(index=[1], columns=['elem1', 'elem2'])
-        df.at[1] = [xr.DataArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-                                 {'Dim1': ['A', 'B', 'C'],
-                                  'Dim2': ['D', 'E', 'F']},
-                                 dims=['Dim1', 'Dim2']),
-                    xr.DataArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-                                 {'Dim1': ['A', 'B', 'C'],
-                                  'Dim2': ['D', 'E', 'F']},
-                                 dims=['Dim1', 'Dim2'])]
+        df.loc[1] = [xr.DataArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+                                  {'Dim1': ['A', 'B', 'C'],
+                                   'Dim2': ['D', 'E', 'F']},
+                                  dims=['Dim1', 'Dim2']),
+                     xr.DataArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+                                  {'Dim1': ['A', 'B', 'C'],
+                                   'Dim2': ['D', 'E', 'F']},
+                                  dims=['Dim1', 'Dim2'])]
 
         expected = pd.DataFrame(index=[1], columns=['Elem1[A, Dim2]', 'Elem2'])
-        expected.at[1] = [xr.DataArray([[1, 2, 3]],
-                                       {'Dim1': ['A'],
-                                        'Dim2': ['D', 'E', 'F']},
-                                       dims=['Dim1', 'Dim2']),
-                          xr.DataArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-                                       {'Dim1': ['A', 'B', 'C'],
-                                        'Dim2': ['D', 'E', 'F']},
-                                       dims=['Dim1', 'Dim2'])]
+        expected.loc[1] = [xr.DataArray([[1, 2, 3]],
+                                        {'Dim1': ['A'],
+                                         'Dim2': ['D', 'E', 'F']},
+                                        dims=['Dim1', 'Dim2']),
+                           xr.DataArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+                                        {'Dim1': ['A', 'B', 'C'],
+                                         'Dim2': ['D', 'E', 'F']},
+                                        dims=['Dim1', 'Dim2'])]
 
         return_addresses = {
             'Elem1[A, Dim2]': ('elem1', {'Dim1': ['A'],
@@ -414,14 +414,14 @@ def test_make_flat_df_return_array(self):
     def test_make_flat_df_flatten(self):
 
         df = pd.DataFrame(index=[1], columns=['elem1', 'elem2'])
-        df.at[1] = [xr.DataArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-                                 {'Dim1': ['A', 'B', 'C'],
-                                  'Dim2': ['D', 'E', 'F']},
-                                 dims=['Dim1', 'Dim2']),
-                    xr.DataArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
-                                 {'Dim1': ['A', 'B', 'C'],
-                                  'Dim2': ['D', 'E', 'F']},
-                                 dims=['Dim1', 'Dim2'])]
+        df.loc[1] = [xr.DataArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+                                  {'Dim1': ['A', 'B', 'C'],
+                                   'Dim2': ['D', 'E', 'F']},
+                                  dims=['Dim1', 'Dim2']),
+                     xr.DataArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+                                  {'Dim1': ['A', 'B', 'C'],
+                                   'Dim2': ['D', 'E', 'F']},
+                                  dims=['Dim1', 'Dim2'])]
 
         expected = pd.DataFrame(index=[1], columns=[
             'Elem1[A,D]',
@@ -437,7 +437,7 @@ def test_make_flat_df_flatten(self):
             'Elem2[C,E]',
             'Elem2[C,F]'])
 
-        expected.at[1] = [1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+        expected.loc[1] = [1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
         return_addresses = {
             'Elem1[A,Dim2]': ('elem1', {'Dim1': ['A'],
@@ -456,7 +456,7 @@ def test_make_flat_df_flatten(self):
     def test_make_flat_df_flatten_transposed(self):
 
         df = pd.DataFrame(index=[1], columns=['elem2'])
-        df.at[1] = [
+        df.loc[1] = [
             xr.DataArray(
                 [[1, 4, 7], [2, 5, 8], [3, 6, 9]],
                 {'Dim2': ['D', 'E', 'F'], 'Dim1': ['A', 'B', 'C']},
@@ -475,7 +475,7 @@ def test_make_flat_df_flatten_transposed(self):
             'Elem2[C,E]',
             'Elem2[C,F]'])
 
-        expected.at[1] = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+        expected.loc[1] = [1, 2, 3, 4, 5, 6, 7, 8, 9]
 
         return_addresses = {
             'Elem2': ('elem2', {})}

tests/pytest_pysd/pytest_pysd.py

@@ -1211,7 +1211,7 @@ def test__integrate(self, tmp_path, model):
         from pysd.py_backend.model import ModelOutput
         # TODO: think through a stronger test here...
         model.time.add_return_timestamps(list(range(0, 5, 2)))
-        capture_elements = {'teacup_temperature'}
+        capture_elements = ['teacup_temperature']
 
         out = ModelOutput(model, capture_elements, None)
         model._integrate(out)