remove char in 1.5.2, merge in upstream

Author: Dr-Irv

ci/deps/actions-38-downstream_compat.yaml

@@ -34,7 +34,7 @@ dependencies:
   - gcsfs
   - jinja2
   - lxml
-  - matplotlib
+  - matplotlib>=3.6.1
   - numba
   - numexpr
   - openpyxl

ci/deps/circle-38-arm64.yaml

@@ -33,7 +33,7 @@ dependencies:
   - gcsfs
   - jinja2
   - lxml
-  - matplotlib
+  - matplotlib>=3.6.1
   - numba
   - numexpr
   - openpyxl

doc/source/user_guide/basics.rst

@@ -1213,12 +1213,6 @@ With a DataFrame, you can simultaneously reindex the index and columns:
    df
    df.reindex(index=["c", "f", "b"], columns=["three", "two", "one"])
 
-You may also use ``reindex`` with an ``axis`` keyword:
-
-.. ipython:: python
-
-   df.reindex(["c", "f", "b"], axis="index")
-
 Note that the ``Index`` objects containing the actual axis labels can be
 **shared** between objects. So if we have a Series and a DataFrame, the
 following can be done:

doc/source/whatsnew/v1.5.2.rst

@@ -29,7 +29,6 @@ Bug fixes
 ~~~~~~~~~
 - Bug in the Copy-on-Write implementation losing track of views in certain chained indexing cases (:issue:`48996`)
 - Fixed memory leak in :meth:`.Styler.to_excel` (:issue:`49751`)
--
 
 .. ---------------------------------------------------------------------------
 .. _whatsnew_152.other:

doc/source/whatsnew/v1.5.3.rst

@@ -27,6 +27,7 @@ Fixed regressions
 Bug fixes
 ~~~~~~~~~
 - Bug in :meth:`.Styler.to_excel` leading to error when unrecognized ``border-style`` (e.g. ``"hair"``) provided to Excel writers (:issue:`48649`)
+- Bug when chaining several :meth:`.Styler.concat` calls, only the last styler was concatenated (:issue:`49207`)
 - Fixed bug when instantiating a :class:`DataFrame` subclass inheriting from ``typing.Generic`` that triggered a ``UserWarning`` on python 3.11 (:issue:`49649`)
 -
 
@@ -36,7 +37,6 @@ Bug fixes
 Other
 ~~~~~
 -
--
 
 .. ---------------------------------------------------------------------------
 .. _whatsnew_153.contributors:

doc/source/whatsnew/v2.0.0.rst

@@ -717,7 +717,7 @@ Timezones
 ^^^^^^^^^
 - Bug in :meth:`Series.astype` and :meth:`DataFrame.astype` with object-dtype containing multiple timezone-aware ``datetime`` objects with heterogeneous timezones to a :class:`DatetimeTZDtype` incorrectly raising (:issue:`32581`)
 - Bug in :func:`to_datetime` was failing to parse date strings with timezone name when ``format`` was specified with ``%Z`` (:issue:`49748`)
--
+- Better error message when passing invalid values to ``ambiguous`` parameter in :meth:`Timestamp.tz_localize` (:issue:`49565`)
 
 Numeric
 ^^^^^^^

environment.yml

@@ -35,7 +35,7 @@ dependencies:
   - gcsfs
   - jinja2
   - lxml
-  - matplotlib
+  - matplotlib>=3.6.1
   - numba>=0.53.1
   - numexpr>=2.8.0  # pin for "Run checks on imported code" job
   - openpyxl

pandas/_libs/tslibs/timestamps.pyx

@@ -6,8 +6,8 @@ construction requirements, we need to do object instantiation in python
 (see Timestamp class below). This will serve as a C extension type that
 shadows the python class, where we do any heavy lifting.
 """
-import warnings
 
+import warnings
 cimport cython
 
 import numpy as np
@@ -1944,8 +1944,11 @@ default 'raise'
         >>> pd.NaT.tz_localize()
         NaT
         """
-        if ambiguous == "infer":
-            raise ValueError("Cannot infer offset with only one time.")
+        if not isinstance(ambiguous, bool) and ambiguous not in {"NaT", "raise"}:
+            raise ValueError(
+                        "'ambiguous' parameter must be one of: "
+                        "True, False, 'NaT', 'raise' (default)"
+                    )
 
         nonexistent_options = ("raise", "NaT", "shift_forward", "shift_backward")
         if nonexistent not in nonexistent_options and not PyDelta_Check(nonexistent):

pandas/core/indexes/interval.py

@@ -59,6 +59,8 @@
     is_number,
     is_object_dtype,
     is_scalar,
+    is_signed_integer_dtype,
+    is_unsigned_integer_dtype,
 )
 from pandas.core.dtypes.dtypes import IntervalDtype
 from pandas.core.dtypes.missing import is_valid_na_for_dtype
@@ -521,6 +523,7 @@ def _maybe_convert_i8(self, key):
         original = key
         if is_list_like(key):
             key = ensure_index(key)
+            key = self._maybe_convert_numeric_to_64bit(key)
 
         if not self._needs_i8_conversion(key):
             return original
@@ -566,6 +569,20 @@ def _maybe_convert_i8(self, key):
 
         return key_i8
 
+    def _maybe_convert_numeric_to_64bit(self, idx: Index) -> Index:
+        # IntervalTree only supports 64 bit numpy array
+        dtype = idx.dtype
+        if np.issubclass_(dtype.type, np.number):
+            return idx
+        elif is_signed_integer_dtype(dtype) and dtype != np.int64:
+            return idx.astype(np.int64)
+        elif is_unsigned_integer_dtype(dtype) and dtype != np.uint64:
+            return idx.astype(np.uint64)
+        elif is_float_dtype(dtype) and dtype != np.float64:
+            return idx.astype(np.float64)
+        else:
+            return idx
+
     def _searchsorted_monotonic(self, label, side: Literal["left", "right"] = "left"):
         if not self.is_non_overlapping_monotonic:
             raise KeyError(

pandas/io/formats/style.py

@@ -316,6 +316,12 @@ def concat(self, other: Styler) -> Styler:
             inherited from the original Styler and not ``other``.
           - hidden columns and hidden index levels will be inherited from the
             original Styler
+          - ``css`` will be inherited from the original Styler, and the value of
+            keys ``data``, ``row_heading`` and ``row`` will be prepended with
+            ``foot0_``. If more concats are chained, their styles will be prepended
+            with ``foot1_``, ''foot_2'', etc., and if a concatenated style have
+            another concatanated style, the second style will be prepended with
+            ``foot{parent}_foot{child}_``.
 
         A common use case is to concatenate user defined functions with
         ``DataFrame.agg`` or with described statistics via ``DataFrame.describe``.
@@ -367,7 +373,7 @@ def concat(self, other: Styler) -> Styler:
                 "number of index levels must be same in `other` "
                 "as in `Styler`. See documentation for suggestions."
             )
-        self.concatenated = other
+        self.concatenated.append(other)
         return self
 
     def _repr_html_(self) -> str | None:

pandas/io/formats/style_render.py

@@ -119,7 +119,7 @@ def __init__(
             "blank": "blank",
             "foot": "foot",
         }
-        self.concatenated: StylerRenderer | None = None
+        self.concatenated: list[StylerRenderer] = []
         # add rendering variables
         self.hide_index_names: bool = False
         self.hide_column_names: bool = False
@@ -161,27 +161,34 @@ def _render(
         stylers for use within `_translate_latex`
         """
         self._compute()
-        dx = None
-        if self.concatenated is not None:
-            self.concatenated.hide_index_ = self.hide_index_
-            self.concatenated.hidden_columns = self.hidden_columns
-            self.concatenated.css = {
+        dxs = []
+        ctx_len = len(self.index)
+        for i, concatenated in enumerate(self.concatenated):
+            concatenated.hide_index_ = self.hide_index_
+            concatenated.hidden_columns = self.hidden_columns
+            foot = f"{self.css['foot']}{i}"
+            concatenated.css = {
                 **self.css,
-                "data": f"{self.css['foot']}_{self.css['data']}",
-                "row_heading": f"{self.css['foot']}_{self.css['row_heading']}",
-                "row": f"{self.css['foot']}_{self.css['row']}",
-                "foot": self.css["foot"],
+                "data": f"{foot}_data",
+                "row_heading": f"{foot}_row_heading",
+                "row": f"{foot}_row",
+                "foot": f"{foot}_foot",
             }
-            dx = self.concatenated._render(
+            dx = concatenated._render(
                 sparse_index, sparse_columns, max_rows, max_cols, blank
             )
+            dxs.append(dx)
 
-            for (r, c), v in self.concatenated.ctx.items():
-                self.ctx[(r + len(self.index), c)] = v
-            for (r, c), v in self.concatenated.ctx_index.items():
-                self.ctx_index[(r + len(self.index), c)] = v
+            for (r, c), v in concatenated.ctx.items():
+                self.ctx[(r + ctx_len, c)] = v
+            for (r, c), v in concatenated.ctx_index.items():
+                self.ctx_index[(r + ctx_len, c)] = v
 
-        d = self._translate(sparse_index, sparse_columns, max_rows, max_cols, blank, dx)
+            ctx_len += len(concatenated.index)
+
+        d = self._translate(
+            sparse_index, sparse_columns, max_rows, max_cols, blank, dxs
+        )
         return d
 
     def _render_html(
@@ -258,7 +265,7 @@ def _translate(
         max_rows: int | None = None,
         max_cols: int | None = None,
         blank: str = " ",
-        dx: dict | None = None,
+        dxs: list[dict] | None = None,
     ):
         """
         Process Styler data and settings into a dict for template rendering.
@@ -278,15 +285,17 @@ def _translate(
             Specific max rows and cols. max_elements always take precedence in render.
         blank : str
             Entry to top-left blank cells.
-        dx : dict
-            The render dict of the concatenated Styler.
+        dxs : list[dict]
+            The render dicts of the concatenated Stylers.
 
         Returns
         -------
         d : dict
             The following structure: {uuid, table_styles, caption, head, body,
             cellstyle, table_attributes}
         """
+        if dxs is None:
+            dxs = []
         self.css["blank_value"] = blank
 
         # construct render dict
@@ -340,10 +349,12 @@ def _translate(
             ]
             d.update({k: map})
 
-        if dx is not None:  # self.concatenated is not None
+        for dx in dxs:  # self.concatenated is not empty
             d["body"].extend(dx["body"])  # type: ignore[union-attr]
             d["cellstyle"].extend(dx["cellstyle"])  # type: ignore[union-attr]
-            d["cellstyle_index"].extend(dx["cellstyle"])  # type: ignore[union-attr]
+            d["cellstyle_index"].extend(  # type: ignore[union-attr]
+                dx["cellstyle_index"]
+            )
 
         table_attr = self.table_attributes
         if not get_option("styler.html.mathjax"):
@@ -847,23 +858,27 @@ def _translate_latex(self, d: dict, clines: str | None) -> None:
             for r, row in enumerate(d["head"])
         ]
 
-        def concatenated_visible_rows(obj, n, row_indices):
+        def _concatenated_visible_rows(obj, n, row_indices):
             """
             Extract all visible row indices recursively from concatenated stylers.
             """
             row_indices.extend(
                 [r + n for r in range(len(obj.index)) if r not in obj.hidden_rows]
             )
-            return (
-                row_indices
-                if obj.concatenated is None
-                else concatenated_visible_rows(
-                    obj.concatenated, n + len(obj.index), row_indices
-                )
-            )
+            n += len(obj.index)
+            for concatenated in obj.concatenated:
+                n = _concatenated_visible_rows(concatenated, n, row_indices)
+            return n
+
+        def concatenated_visible_rows(obj):
+            row_indices: list[int] = []
+            _concatenated_visible_rows(obj, 0, row_indices)
+            # TODO try to consolidate the concat visible rows
+            # methods to a single function / recursion for simplicity
+            return row_indices
 
         body = []
-        for r, row in zip(concatenated_visible_rows(self, 0, []), d["body"]):
+        for r, row in zip(concatenated_visible_rows(self), d["body"]):
             # note: cannot enumerate d["body"] because rows were dropped if hidden
             # during _translate_body so must zip to acquire the true r-index associated
             # with the ctx obj which contains the cell styles.

pandas/tests/io/excel/test_writers.py

@@ -29,6 +29,7 @@
     _XlsxWriter,
     register_writer,
 )
+from pandas.io.excel._util import _writers
 
 
 @pytest.fixture
@@ -1351,3 +1352,11 @@ def test_excelwriter_fspath(self):
         with tm.ensure_clean("foo.xlsx") as path:
             with ExcelWriter(path) as writer:
                 assert os.fspath(writer) == str(path)
+
+
+@pytest.mark.parametrize("klass", _writers.values())
+def test_subclass_attr(klass):
+    # testing that subclasses of ExcelWriter don't have public attributes (issue 49602)
+    attrs_base = {name for name in dir(ExcelWriter) if not name.startswith("_")}
+    attrs_klass = {name for name in dir(klass) if not name.startswith("_")}
+    assert not attrs_base.symmetric_difference(attrs_klass)