Merge remote-tracking branch 'upstream/master' into STY-repr-doc

Author: MomIsBestFriend

ci/print_skipped.py

@@ -5,7 +5,7 @@
 
 def main(filename):
     if not os.path.isfile(filename):
-        raise RuntimeError(f"Could not find junit file {filename!r}")
+        raise RuntimeError(f"Could not find junit file {repr(filename)}")
 
     tree = et.parse(filename)
     root = tree.getroot()

pandas/io/pytables.py

@@ -4,7 +4,7 @@
 """
 
 import copy
-from datetime import date
+from datetime import date, tzinfo
 import itertools
 import os
 import re
@@ -2918,7 +2918,8 @@ def read_array(
             if dtype == "datetime64":
 
                 # reconstruct a timezone if indicated
-                ret = _set_tz(ret, getattr(attrs, "tz", None), coerce=True)
+                tz = getattr(attrs, "tz", None)
+                ret = _set_tz(ret, tz, coerce=True)
 
             elif dtype == "timedelta64":
                 ret = np.asarray(ret, dtype="m8[ns]")
@@ -3734,7 +3735,7 @@ def read_axes(
 
         return True
 
-    def get_object(self, obj):
+    def get_object(self, obj, transposed: bool):
         """ return the data for this obj """
         return obj
 
@@ -3838,15 +3839,13 @@ def create_axes(
             )
 
         # create according to the new data
-        self.non_index_axes = []
-        self.data_columns = []
+        new_non_index_axes: List = []
+        new_data_columns: List[Optional[str]] = []
 
         # nan_representation
         if nan_rep is None:
             nan_rep = "nan"
 
-        self.nan_rep = nan_rep
-
         # create axes to index and non_index
         index_axes_map = dict()
         for i, a in enumerate(obj.axes):
@@ -3863,7 +3862,7 @@ def create_axes(
                 # necessary
                 append_axis = list(a)
                 if existing_table is not None:
-                    indexer = len(self.non_index_axes)
+                    indexer = len(new_non_index_axes)
                     exist_axis = existing_table.non_index_axes[indexer][1]
                     if not array_equivalent(
                         np.array(append_axis), np.array(exist_axis)
@@ -3880,34 +3879,37 @@ def create_axes(
                 info["names"] = list(a.names)
                 info["type"] = type(a).__name__
 
-                self.non_index_axes.append((i, append_axis))
+                new_non_index_axes.append((i, append_axis))
+
+        self.non_index_axes = new_non_index_axes
 
         # set axis positions (based on the axes)
         new_index_axes = [index_axes_map[a] for a in axes]
         for j, iax in enumerate(new_index_axes):
             iax.set_pos(j)
             iax.update_info(self.info)
-        self.index_axes = new_index_axes
 
-        j = len(self.index_axes)
+        j = len(new_index_axes)
 
         # check for column conflicts
-        for a in self.axes:
+        for a in new_index_axes:
             a.maybe_set_size(min_itemsize=min_itemsize)
 
         # reindex by our non_index_axes & compute data_columns
-        for a in self.non_index_axes:
+        for a in new_non_index_axes:
             obj = _reindex_axis(obj, a[0], a[1])
 
         def get_blk_items(mgr, blocks):
             return [mgr.items.take(blk.mgr_locs) for blk in blocks]
 
+        transposed = new_index_axes[0].axis == 1
+
         # figure out data_columns and get out blocks
-        block_obj = self.get_object(obj)._consolidate()
+        block_obj = self.get_object(obj, transposed)._consolidate()
         blocks = block_obj._data.blocks
         blk_items = get_blk_items(block_obj._data, blocks)
-        if len(self.non_index_axes):
-            axis, axis_labels = self.non_index_axes[0]
+        if len(new_non_index_axes):
+            axis, axis_labels = new_non_index_axes[0]
             data_columns = self.validate_data_columns(data_columns, min_itemsize)
             if len(data_columns):
                 mgr = block_obj.reindex(
@@ -3945,7 +3947,7 @@ def get_blk_items(mgr, blocks):
             blk_items = new_blk_items
 
         # add my values
-        self.values_axes = []
+        vaxes = []
         for i, (b, b_items) in enumerate(zip(blocks, blk_items)):
 
             # shape of the data column are the indexable axes
@@ -3959,7 +3961,7 @@ def get_blk_items(mgr, blocks):
                 if not (name is None or isinstance(name, str)):
                     # TODO: should the message here be more specifically non-str?
                     raise ValueError("cannot have non-object label DataIndexableCol")
-                self.data_columns.append(name)
+                new_data_columns.append(name)
 
             # make sure that we match up the existing columns
             # if we have an existing table
@@ -3987,10 +3989,15 @@ def get_blk_items(mgr, blocks):
             )
             col.set_pos(j)
 
-            self.values_axes.append(col)
+            vaxes.append(col)
 
             j += 1
 
+        self.nan_rep = nan_rep
+        self.data_columns = new_data_columns
+        self.values_axes = vaxes
+        self.index_axes = new_index_axes
+
         # validate our min_itemsize
         self.validate_min_itemsize(min_itemsize)
 
@@ -4158,7 +4165,7 @@ def read_column(
                     encoding=self.encoding,
                     errors=self.errors,
                 )
-                return Series(_set_tz(a.take_data(), a.tz, True), name=column)
+                return Series(_set_tz(a.take_data(), a.tz), name=column)
 
         raise KeyError(f"column [{column}] not found in the table")
 
@@ -4428,9 +4435,9 @@ class AppendableFrameTable(AppendableTable):
     def is_transposed(self) -> bool:
         return self.index_axes[0].axis == 1
 
-    def get_object(self, obj):
+    def get_object(self, obj, transposed: bool):
         """ these are written transposed """
-        if self.is_transposed:
+        if transposed:
             obj = obj.T
         return obj
 
@@ -4512,7 +4519,7 @@ class AppendableSeriesTable(AppendableFrameTable):
     def is_transposed(self) -> bool:
         return False
 
-    def get_object(self, obj):
+    def get_object(self, obj, transposed: bool):
         return obj
 
     def write(self, obj, data_columns=None, **kwargs):
@@ -4687,37 +4694,39 @@ def _get_info(info, name):
 # tz to/from coercion
 
 
-def _get_tz(tz):
+def _get_tz(tz: tzinfo) -> Union[str, tzinfo]:
     """ for a tz-aware type, return an encoded zone """
     zone = timezones.get_timezone(tz)
-    if zone is None:
-        zone = tz.utcoffset().total_seconds()
     return zone
 
 
-def _set_tz(values, tz, preserve_UTC: bool = False, coerce: bool = False):
+def _set_tz(
+    values: Union[np.ndarray, Index],
+    tz: Optional[Union[str, tzinfo]],
+    coerce: bool = False,
+) -> Union[np.ndarray, DatetimeIndex]:
     """
     coerce the values to a DatetimeIndex if tz is set
     preserve the input shape if possible
 
     Parameters
     ----------
-    values : ndarray
-    tz : string/pickled tz object
-    preserve_UTC : bool,
-        preserve the UTC of the result
+    values : ndarray or Index
+    tz : str or tzinfo
     coerce : if we do not have a passed timezone, coerce to M8[ns] ndarray
     """
+    if isinstance(values, DatetimeIndex):
+        # If values is tzaware, the tz gets dropped in the values.ravel()
+        #  call below (which returns an ndarray).  So we are only non-lossy
+        #  if `tz` matches `values.tz`.
+        assert values.tz is None or values.tz == tz
+
     if tz is not None:
         name = getattr(values, "name", None)
         values = values.ravel()
         tz = timezones.get_timezone(_ensure_decoded(tz))
         values = DatetimeIndex(values, name=name)
-        if values.tz is None:
-            values = values.tz_localize("UTC").tz_convert(tz)
-        if preserve_UTC:
-            if tz == "UTC":
-                values = list(values)
+        values = values.tz_localize("UTC").tz_convert(tz)
     elif coerce:
         values = np.asarray(values, dtype="M8[ns]")