Release 3.6.0 and removal of TfsDataFrame methods (#120)

Author: fsoubelet

CHANGELOG.md

@@ -1,5 +1,13 @@
 # TFS-Pandas Changelog
 
+## Version 3.6.0
+
+- Removed:
+  - The `append` and `join` methods of `TfsDataFrame` have been removed.
+
+- Changed:
+  - The dependency version on `pandas` has been restored to `>=1.0.0` as the above removal restores compatibility with `pandas` `2.0`.
+
 ## Version 3.5.3
 
 - Changed:
@@ -8,7 +16,7 @@
 ## Version 3.5.2
 
 - Changed:
-  - The dependency on `pandas` has been pinned to `<2.0` to guarantee the proper functionning of the compability `append`, `join` and `merge` methods in `TfsDataFrames`. These will be removed with the next release of `tfs-pandas` and users should use the `tfs.frame.concat` compatibility function instead.
+  - The dependency on `pandas` has been pinned to `<2.0` to guarantee the proper functionning of the compability `append` and `join` methods in `TfsDataFrames`. These will be removed with the next release of `tfs-pandas` and users should use the `tfs.frame.concat` compatibility function instead.
 
 ## Version 3.5.1
 

setup.py

@@ -30,7 +30,7 @@ def about_package(init_posixpath: pathlib.Path) -> dict:
 # Dependencies for the package itself
 DEPENDENCIES = [
     "numpy>=1.19.0",
-    "pandas<2.0",
+    "pandas>=1.0",
 ]
 
 # Extra dependencies

tests/test_frame.py

@@ -28,6 +28,38 @@ def test_merge_headers_raises_on_invalid_how_key(self, caplog, how):
             merge_headers(headers_left, headers_right, how=how)
 
 
+class TestTfsDataFrameMerging:
+    @pytest.mark.parametrize("how_headers", [None, "left", "right"])
+    @pytest.mark.parametrize("how", ["left", "right", "outer", "inner"])
+    @pytest.mark.parametrize("on", ["NAME", "S", "NUMBER", "CO", "CORMS", "BPM_RES"])
+    def test_correct_merging(self, _tfs_file_x_pathlib, _tfs_file_y_pathlib, how_headers, how, on):
+        dframe_x = tfs.read(_tfs_file_x_pathlib)
+        dframe_y = tfs.read(_tfs_file_y_pathlib)
+        result = dframe_x.merge(dframe_y, how_headers=how_headers, how=how, on=on)
+
+        assert isinstance(result, TfsDataFrame)
+        assert isinstance(result.headers, OrderedDict)
+        assert_dict_equal(result.headers, merge_headers(dframe_x.headers, dframe_y.headers, how=how_headers))
+        assert_frame_equal(result, pd.DataFrame(dframe_x).merge(pd.DataFrame(dframe_y), how=how, on=on))
+
+    @pytest.mark.parametrize("how_headers", [None, "left", "right"])
+    @pytest.mark.parametrize("how", ["left", "right", "outer", "inner"])
+    @pytest.mark.parametrize("on", ["NAME", "S", "NUMBER", "CO", "CORMS", "BPM_RES"])
+    def test_merging_accepts_pandas_dataframe(
+        self, _tfs_file_x_pathlib, _tfs_file_y_pathlib, how_headers, how, on
+    ):
+        dframe_x = tfs.read(_tfs_file_x_pathlib)
+        dframe_y = pd.DataFrame(tfs.read(_tfs_file_y_pathlib))  # for test, loses headers here
+        result = dframe_x.merge(dframe_y, how_headers=how_headers, how=how, on=on)
+
+        assert isinstance(result, TfsDataFrame)
+        assert isinstance(result.headers, OrderedDict)
+
+        # using empty OrderedDict here as it's what dframe_y is getting when converted in the call
+        assert_dict_equal(result.headers, merge_headers(dframe_x.headers, OrderedDict(), how=how_headers))
+        assert_frame_equal(result, pd.DataFrame(dframe_x).merge(pd.DataFrame(dframe_y), how=how, on=on))
+
+
 class TestHeadersMerging:
     @pytest.mark.parametrize("how", ["left", "LEFT", "Left", "lEfT"])  # we're case-insensitive
     def test_headers_merging_left(self, _tfs_file_x_pathlib, _tfs_file_y_pathlib, how):
@@ -64,16 +96,12 @@ def test_providing_new_headers_overrides_merging(self, _tfs_file_x_pathlib, _tfs
         dframe_x = tfs.read(_tfs_file_x_pathlib)
         dframe_y = tfs.read(_tfs_file_y_pathlib)
 
-        assert dframe_x.append(other=dframe_y, new_headers={}).headers == OrderedDict()
-        assert dframe_y.append(other=dframe_x, new_headers={}).headers == OrderedDict()
-
-        # we provide lsuffix (or rsuffix) since dframes have the same columns
-        assert dframe_x.join(other=dframe_y, lsuffix="_l", new_headers={}).headers == OrderedDict()
-        assert dframe_y.join(other=dframe_x, lsuffix="_l", new_headers={}).headers == OrderedDict()
-
         assert dframe_x.merge(right=dframe_y, new_headers={}).headers == OrderedDict()
         assert dframe_y.merge(right=dframe_x, new_headers={}).headers == OrderedDict()
 
+        assert tfs.concat([dframe_x, dframe_y], new_headers={}).headers == OrderedDict()
+        assert tfs.concat([dframe_y, dframe_x], new_headers={}).headers == OrderedDict()
+
 
 class TestPrinting:
     def test_header_print(self):
@@ -103,100 +131,6 @@ def test_empty_headers_print(self):
         assert print_tfs == print_df.replace(pd.DataFrame.__name__, TfsDataFrame.__name__)
 
 
-class TestTfsDataFrameAppending:
-    @pytest.mark.parametrize("how_headers", [None, "left", "right"])
-    def test_correct_appending(self, _tfs_file_x_pathlib, _tfs_file_y_pathlib, how_headers):
-        dframe_x = tfs.read(_tfs_file_x_pathlib)
-        dframe_y = tfs.read(_tfs_file_y_pathlib)
-        result = dframe_x.append(dframe_y, how_headers=how_headers)
-
-        assert isinstance(result, TfsDataFrame)
-        assert isinstance(result.headers, OrderedDict)
-        assert_dict_equal(result.headers, merge_headers(dframe_x.headers, dframe_y.headers, how=how_headers))
-        assert_frame_equal(result, pd.DataFrame(dframe_x).append(pd.DataFrame(dframe_y)))
-
-    @pytest.mark.parametrize("how_headers", [None, "left", "right"])
-    def test_appending_accepts_pandas_dataframe(self, _tfs_file_x_pathlib, _tfs_file_y_pathlib, how_headers):
-        dframe_x = tfs.read(_tfs_file_x_pathlib)
-        dframe_y = pd.DataFrame(tfs.read(_tfs_file_y_pathlib))  # for test, loses headers here
-        result = dframe_x.append(dframe_y, how_headers=how_headers)
-
-        assert isinstance(result, TfsDataFrame)
-        assert isinstance(result.headers, OrderedDict)
-
-        # using empty OrderedDict here as it's what dframe_y is getting when converted in the call
-        assert_dict_equal(result.headers, merge_headers(dframe_x.headers, OrderedDict(), how=how_headers))
-        assert_frame_equal(result, pd.DataFrame(dframe_x).append(dframe_y))  # dframe_y already pandas
-
-
-class TestTfsDataFrameJoining:
-    @pytest.mark.parametrize("how_headers", [None, "left", "right"])
-    @pytest.mark.parametrize("lsuffix", ["left", "_x"])
-    @pytest.mark.parametrize("rsuffix", ["right", "_y"])
-    def test_correct_joining(self, _tfs_file_x_pathlib, _tfs_file_y_pathlib, how_headers, lsuffix, rsuffix):
-        dframe_x = tfs.read(_tfs_file_x_pathlib)
-        dframe_y = tfs.read(_tfs_file_y_pathlib)
-        result = dframe_x.join(dframe_y, how_headers=how_headers, lsuffix=lsuffix, rsuffix=rsuffix)
-
-        assert isinstance(result, TfsDataFrame)
-        assert isinstance(result.headers, OrderedDict)
-        assert_dict_equal(result.headers, merge_headers(dframe_x.headers, dframe_y.headers, how=how_headers))
-        assert_frame_equal(
-            result, pd.DataFrame(dframe_x).join(pd.DataFrame(dframe_y), lsuffix=lsuffix, rsuffix=rsuffix)
-        )
-
-    @pytest.mark.parametrize("how_headers", [None, "left", "right"])
-    @pytest.mark.parametrize("lsuffix", ["left", "_x"])
-    @pytest.mark.parametrize("rsuffix", ["right", "_y"])
-    def test_joining_accepts_pandas_dataframe(
-        self, _tfs_file_x_pathlib, _tfs_file_y_pathlib, how_headers, lsuffix, rsuffix
-    ):
-        dframe_x = tfs.read(_tfs_file_x_pathlib)
-        dframe_y = pd.DataFrame(tfs.read(_tfs_file_y_pathlib))  # for test, loses headers here
-        result = dframe_x.join(dframe_y, how_headers=how_headers, lsuffix=lsuffix, rsuffix=rsuffix)
-
-        assert isinstance(result, TfsDataFrame)
-        assert isinstance(result.headers, OrderedDict)
-
-        # using empty OrderedDict here as it's what dframe_y is getting when converted in the call
-        assert_dict_equal(result.headers, merge_headers(dframe_x.headers, OrderedDict(), how=how_headers))
-        assert_frame_equal(
-            result, pd.DataFrame(dframe_x).join(pd.DataFrame(dframe_y), lsuffix=lsuffix, rsuffix=rsuffix)
-        )
-
-
-class TestTfsDataFrameMerging:
-    @pytest.mark.parametrize("how_headers", [None, "left", "right"])
-    @pytest.mark.parametrize("how", ["left", "right", "outer", "inner"])
-    @pytest.mark.parametrize("on", ["NAME", "S", "NUMBER", "CO", "CORMS", "BPM_RES"])
-    def test_correct_merging(self, _tfs_file_x_pathlib, _tfs_file_y_pathlib, how_headers, how, on):
-        dframe_x = tfs.read(_tfs_file_x_pathlib)
-        dframe_y = tfs.read(_tfs_file_y_pathlib)
-        result = dframe_x.merge(dframe_y, how_headers=how_headers, how=how, on=on)
-
-        assert isinstance(result, TfsDataFrame)
-        assert isinstance(result.headers, OrderedDict)
-        assert_dict_equal(result.headers, merge_headers(dframe_x.headers, dframe_y.headers, how=how_headers))
-        assert_frame_equal(result, pd.DataFrame(dframe_x).merge(pd.DataFrame(dframe_y), how=how, on=on))
-
-    @pytest.mark.parametrize("how_headers", [None, "left", "right"])
-    @pytest.mark.parametrize("how", ["left", "right", "outer", "inner"])
-    @pytest.mark.parametrize("on", ["NAME", "S", "NUMBER", "CO", "CORMS", "BPM_RES"])
-    def test_merging_accepts_pandas_dataframe(
-        self, _tfs_file_x_pathlib, _tfs_file_y_pathlib, how_headers, how, on
-    ):
-        dframe_x = tfs.read(_tfs_file_x_pathlib)
-        dframe_y = pd.DataFrame(tfs.read(_tfs_file_y_pathlib))  # for test, loses headers here
-        result = dframe_x.merge(dframe_y, how_headers=how_headers, how=how, on=on)
-
-        assert isinstance(result, TfsDataFrame)
-        assert isinstance(result.headers, OrderedDict)
-
-        # using empty OrderedDict here as it's what dframe_y is getting when converted in the call
-        assert_dict_equal(result.headers, merge_headers(dframe_x.headers, OrderedDict(), how=how_headers))
-        assert_frame_equal(result, pd.DataFrame(dframe_x).merge(pd.DataFrame(dframe_y), how=how, on=on))
-
-
 class TestTfsDataFramesConcatenating:
     @pytest.mark.parametrize("how_headers", [None, "left", "right"])
     @pytest.mark.parametrize("axis", [0, 1])

tests/test_writer.py

@@ -68,7 +68,8 @@ def test_tfs_write_empty_index_dataframe(self, tmp_path):
         assert write_location.is_file()
 
         new = read_tfs(write_location)
-        assert_frame_equal(df, new)
+        # with pandas 2.0 the index of new is empty but of type integer, which is fine
+        assert_frame_equal(df, new, check_index_type=False)
         assert_dict_equal(df.headers, new.headers, compare_keys=True)
 
     def test_write_int_float_str_columns(self, tmp_path):

tfs/__init__.py

@@ -10,7 +10,7 @@
 __title__ = "tfs-pandas"
 __description__ = "Read and write tfs files."
 __url__ = "https://github.com/pylhc/tfs"
-__version__ = "3.5.3"
+__version__ = "3.6.0"
 __author__ = "pylhc"
 __author_email__ = "[email protected]"
 __license__ = "MIT"

tfs/frame.py

@@ -81,107 +81,6 @@ def __repr__(self) -> str:
         headers_string = self._headers_repr()
         return f"{headers_string}{super().__repr__()}"
 
-    def append(
-        self,
-        other: Union["TfsDataFrame", pd.DataFrame],
-        how_headers: str = None,
-        new_headers: dict = None,
-        **kwargs,
-    ) -> "TfsDataFrame":
-        """
-        Append rows of the other ``TfsDataFrame`` to the end of caller, returning a new object. Data
-        manipulation is done by the ``pandas.Dataframe`` method of the same name. Resulting headers are
-        either merged according to the provided **how_headers** method or as given via **new_headers**.
-
-        ..warning::
-            This method uses ``pandas.DataFrame.append`` internally, which has been deprecated for a
-            while and removed with pandas 2.0. It will be removed from ``tfs-pandas`` as well in the
-            next release.
-
-        Args:
-            other (Union[TfsDataFrame, pd.DataFrame]): The ``TfsDataFrame`` to append to the caller.
-            how_headers (str): Type of merge to be performed for the headers. Either **left** or **right**.
-                Refer to :func:`tfs.frame.merge_headers` for behavior. If ``None`` is provided and
-                **new_headers** is not provided, the final headers will be empty. Case insensitive,
-                defaults to ``None``.
-            new_headers (dict): If provided, will be used as new_headers for the merged ``TfsDataFrame``.
-                Otherwise these are determined by merging the headers from the caller and the other
-                ``TfsDataFrame`` according to the method defined by the **how_headers** argument.
-
-        Keyword Args:
-            Any keyword argument is given to ``pandas.DataFrame.append()``. The default values for all these
-            parameters are left as set in the ``pandas`` codebase. To see these, refer to the pandas
-            [DataFrame.append documentation](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.append.html).
-
-        Returns:
-            A new ``TfsDataFrame`` with the appended data and merged headers.
-        """
-        LOGGER.warn("This method has been removed in pandas 2.0 and will be removed from TfsDataFrames too. Please use 'tfs.frame.concat' instead.")
-        LOGGER.debug("Appending data through 'pandas'")
-        if not hasattr(other, "headers"):
-            LOGGER.debug("Converting 'other' to TfsDataFrame for appending")
-            other = TfsDataFrame(other)  # so we accept pandas.DataFrame input here
-
-        dframe = super().append(other, **kwargs)
-
-        LOGGER.debug("Determining headers")
-        new_headers = (
-            new_headers
-            if new_headers is not None
-            else merge_headers(self.headers, other.headers, how=how_headers)
-        )
-        return TfsDataFrame(data=dframe, headers=new_headers)
-
-    def join(
-        self,
-        other: Union["TfsDataFrame", pd.DataFrame],
-        how_headers: str = None,
-        new_headers: dict = None,
-        **kwargs,
-    ) -> "TfsDataFrame":
-        """
-        Join columns of another ``TfsDataFrame``. Data manipulation is done by the ``pandas.Dataframe``
-        method of the same name. Resulting headers are either merged according to the provided
-        **how_headers** method or as given via **new_headers**.
-
-        ..warning::
-            This method uses ``pandas.DataFrame.join`` internally, which has been deprecated for a
-            while and removed with pandas 2.0. It will be removed from ``tfs-pandas`` as well in the
-            next release.
-
-        Args:
-            other (Union[TfsDataFrame, pd.DataFrame]): The ``TfsDataFrame`` to join into the caller.
-            how_headers (str): Type of merge to be performed for the headers. Either **left** or **right**.
-                Refer to :func:`tfs.frame.merge_headers` for behavior. If ``None`` is provided and
-                **new_headers** is not provided, the final headers will be empty. Case insensitive,
-                defaults to ``None``.
-            new_headers (dict): If provided, will be used as new_headers for the merged ``TfsDataFrame``.
-                Otherwise these are determined by merging the headers from the caller and the other
-                ``TfsDataFrame`` according to the method defined by the **how_headers** argument.
-
-        Keyword Args:
-            Any keyword argument is given to ``pandas.DataFrame.join()``. The default values for all these
-            parameters are left as set in the ``pandas`` codebase. To see these, refer to the pandas
-            [DataFrame.join documentation](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.join.html).
-
-        Returns:
-            A new ``TfsDataFrame`` with the joined columns and merged headers.
-        """
-        LOGGER.warn("This method has been removed in pandas 2.0 and will be removed from TfsDataFrames too. Please use 'tfs.frame.concat' instead.")
-        LOGGER.debug("Joining data through 'pandas'")
-        if not hasattr(other, "headers"):
-            LOGGER.debug("Converting 'other' to TfsDataFrame for joining")
-            other = TfsDataFrame(other)  # so we accept pandas.DataFrame input here
-        dframe = super().join(other, **kwargs)
-
-        LOGGER.debug("Determining headers")
-        new_headers = (
-            new_headers
-            if new_headers is not None
-            else merge_headers(self.headers, other.headers, how=how_headers)
-        )
-        return TfsDataFrame(data=dframe, headers=new_headers)
-
     def merge(
         self,
         right: Union["TfsDataFrame", pd.DataFrame],
@@ -381,4 +280,4 @@ def _element_is_list(element):
         LOGGER.debug(f"Space(s) found in TFS columns, dataframe {info_str} is invalid")
         raise TfsFormatError("TFS-Columns can not contain spaces.")
 
-    LOGGER.debug(f"DataFrame {info_str} validated")
+    LOGGER.debug(f"DataFrame {info_str} validated")