CLN: avoid storing unnecessary variable

Author: AlexKirko

ci/azure/posix.yml

@@ -44,15 +44,13 @@ jobs:
           PATTERN: "not slow and not network"
           LOCALE_OVERRIDE: "zh_CN.UTF-8"
 
-        # Disabled for NumPy object-dtype warning.
-        # https://github.com/pandas-dev/pandas/issues/30043
-        # py37_np_dev:
-        #   ENV_FILE: ci/deps/azure-37-numpydev.yaml
-        #   CONDA_PY: "37"
-        #   PATTERN: "not slow and not network"
-        #   TEST_ARGS: "-W error"
-        #   PANDAS_TESTING_MODE: "deprecate"
-        #   EXTRA_APT: "xsel"
+        py37_np_dev:
+          ENV_FILE: ci/deps/azure-37-numpydev.yaml
+          CONDA_PY: "37"
+          PATTERN: "not slow and not network"
+          TEST_ARGS: "-W error"
+          PANDAS_TESTING_MODE: "deprecate"
+          EXTRA_APT: "xsel"
 
   steps:
     - script: |

doc/source/whatsnew/v1.0.0.rst

@@ -535,6 +535,7 @@ or ``matplotlib.Axes.plot``. See :ref:`plotting.formatters` for more.
 - :meth:`Series.plot` no longer accepts positional arguments, pass keyword arguments instead (:issue:`30003`)
 - :meth:`DataFrame.hist` and :meth:`Series.hist` no longer allows ``figsize="default"``, specify figure size by passinig a tuple instead (:issue:`30003`)
 - Floordiv of integer-dtyped array by :class:`Timedelta` now raises ``TypeError`` (:issue:`21036`)
+- :class:`TimedeltaIndex` and :class:`DatetimeIndex` no longer accept non-nanosecond dtype strings like "timedelta64" or "datetime64", use "timedelta64[ns]" and "datetime64[ns]" instead (:issue:`24806`)
 - :func:`pandas.api.types.infer_dtype` argument ``skipna`` defaults to ``True`` instead of ``False`` (:issue:`24050`)
 - Removed the previously deprecated :attr:`Series.ix` and :attr:`DataFrame.ix` (:issue:`26438`)
 - Removed the previously deprecated :meth:`Index.summary` (:issue:`18217`)
@@ -634,6 +635,7 @@ or ``matplotlib.Axes.plot``. See :ref:`plotting.formatters` for more.
 - Removed the previously deprecated keyword "data" from :func:`andrews_curves`, use "frame" instead (:issue:`6956`)
 - Removed the previously deprecated keyword "data" from :func:`parallel_coordinates`, use "frame" instead (:issue:`6956`)
 - Removed the previously deprecated keyword "colors" from :func:`parallel_coordinates`, use "color" instead (:issue:`6956`)
+- Removed the previously deprecated keywords "verbose" and "private_key" from :func:`read_gbq` (:issue:`30200`)
 -
 
 .. _whatsnew_1000.performance:
@@ -825,7 +827,7 @@ Groupby/resample/rolling
 - Bug in :meth:`DataFrameGroupBy.rolling().quantile()` ignoring ``interpolation`` keyword argument (:issue:`28779`)
 - Bug in :meth:`DataFrame.groupby` where ``any``, ``all``, ``nunique`` and transform functions would incorrectly handle duplicate column labels (:issue:`21668`)
 - Bug in :meth:`DataFrameGroupBy.agg` with timezone-aware datetime64 column incorrectly casting results to the original dtype (:issue:`29641`)
--
+- Bug in :meth:`DataFrame.groupby` when using axis=1 and having a single level columns index (:issue:`30208`)
 
 Reshaping
 ^^^^^^^^^

pandas/_libs/parsers.pyx

@@ -657,7 +657,7 @@ cdef class TextReader:
 
         if isinstance(source, str):
             encoding = sys.getfilesystemencoding() or "utf-8"
-
+            usource = source
             source = source.encode(encoding)
 
             if self.memory_map:
@@ -677,10 +677,11 @@ cdef class TextReader:
 
             if ptr == NULL:
                 if not os.path.exists(source):
+
                     raise FileNotFoundError(
                         ENOENT,
-                        f'File {source} does not exist',
-                        source)
+                        f'File {usource} does not exist',
+                        usource)
                 raise IOError('Initializing from file failed')
 
             self.parser.source = ptr

pandas/core/arrays/numpy_.py

@@ -72,7 +72,12 @@ def _is_boolean(self):
 
     @classmethod
     def construct_from_string(cls, string):
-        return cls(np.dtype(string))
+        try:
+            return cls(np.dtype(string))
+        except TypeError as err:
+            raise TypeError(
+                f"Cannot construct a 'PandasDtype' from '{string}'"
+            ) from err
 
     def construct_array_type(cls):
         return PandasArray

pandas/core/arrays/sparse/dtype.py

@@ -199,7 +199,7 @@ def construct_from_string(cls, string):
         -------
         SparseDtype
         """
-        msg = f"Could not construct SparseDtype from '{string}'"
+        msg = f"Cannot construct a 'SparseDtype' from '{string}'"
         if string.startswith("Sparse"):
             try:
                 sub_type, has_fill_value = cls._parse_subtype(string)
@@ -208,7 +208,7 @@ def construct_from_string(cls, string):
             else:
                 result = SparseDtype(sub_type)
                 msg = (
-                    f"Could not construct SparseDtype from '{string}'.\n\nIt "
+                    f"Cannot construct a 'SparseDtype' from '{string}'.\n\nIt "
                     "looks like the fill_value in the string is not "
                     "the default for the dtype. Non-default fill_values "
                     "are not supported. Use the 'SparseDtype()' "

pandas/core/dtypes/dtypes.py

@@ -732,7 +732,7 @@ def construct_from_string(cls, string: str_type):
         datetime64[ns, UTC]
         """
         if isinstance(string, str):
-            msg = "Could not construct DatetimeTZDtype from '{string}'"
+            msg = f"Cannot construct a 'DatetimeTZDtype' from '{string}'"
             match = cls._match.match(string)
             if match:
                 d = match.groupdict()
@@ -743,10 +743,10 @@ def construct_from_string(cls, string: str_type):
                     #  pytz timezone (actually pytz.UnknownTimeZoneError).
                     # TypeError if we pass a nonsense tz;
                     # ValueError if we pass a unit other than "ns"
-                    raise TypeError(msg.format(string=string)) from err
-            raise TypeError(msg.format(string=string))
+                    raise TypeError(msg) from err
+            raise TypeError(msg)
 
-        raise TypeError("Could not construct DatetimeTZDtype")
+        raise TypeError("Cannot construct a 'DatetimeTZDtype'")
 
     def __str__(self) -> str_type:
         return "datetime64[{unit}, {tz}]".format(unit=self.unit, tz=self.tz)
@@ -883,7 +883,7 @@ def construct_from_string(cls, string):
                 return cls(freq=string)
             except ValueError:
                 pass
-        raise TypeError("could not construct PeriodDtype")
+        raise TypeError(f"Cannot construct a 'PeriodDtype' from '{string}'")
 
     def __str__(self) -> str_type:
         return self.name
@@ -1054,6 +1054,7 @@ def construct_from_string(cls, string):
             return cls(string)
 
         msg = (
+            f"Cannot construct a 'IntervalDtype' from '{string}'.\n\n"
             "Incorrectly formatted string passed to constructor. "
             "Valid formats include Interval or Interval[dtype] "
             "where dtype is numeric, datetime, or timedelta"

pandas/core/frame.py

@@ -1433,8 +1433,6 @@ def to_gbq(
         location=None,
         progress_bar=True,
         credentials=None,
-        verbose=None,
-        private_key=None,
     ):
         """
         Write a DataFrame to a Google BigQuery table.
@@ -1509,21 +1507,6 @@ def to_gbq(
             *New in version 0.8.0 of pandas-gbq*.
 
             .. versionadded:: 0.24.0
-        verbose : bool, deprecated
-            Deprecated in pandas-gbq version 0.4.0. Use the `logging module
-            to adjust verbosity instead
-            <https://pandas-gbq.readthedocs.io/en/latest/intro.html#logging>`__.
-        private_key : str, deprecated
-            Deprecated in pandas-gbq version 0.8.0. Use the ``credentials``
-            parameter and
-            :func:`google.oauth2.service_account.Credentials.from_service_account_info`
-            or
-            :func:`google.oauth2.service_account.Credentials.from_service_account_file`
-            instead.
-
-            Service account private key in JSON format. Can be file path
-            or string contents. This is useful for remote server
-            authentication (eg. Jupyter/IPython notebook on remote host).
 
         See Also
         --------
@@ -1544,8 +1527,6 @@ def to_gbq(
             location=location,
             progress_bar=progress_bar,
             credentials=credentials,
-            verbose=verbose,
-            private_key=private_key,
         )
 
     @classmethod

pandas/core/groupby/grouper.py

@@ -491,8 +491,11 @@ def get_grouper(
                     raise ValueError("multiple levels only valid with MultiIndex")
 
             if isinstance(level, str):
-                if obj.index.name != level:
-                    raise ValueError(f"level name {level} is not the name of the index")
+                if obj._get_axis(axis).name != level:
+                    raise ValueError(
+                        f"level name {level} is not the name "
+                        f"of the {obj._get_axis_name(axis)}"
+                    )
             elif level > 0 or level < -1:
                 raise ValueError("level > 0 or level < -1 only valid with MultiIndex")
 

pandas/core/ops/__init__.py

@@ -462,7 +462,8 @@ def wrapper(left, right):
         res_name = get_op_result_name(left, right)
 
         lvalues = extract_array(left, extract_numpy=True)
-        result = arithmetic_op(lvalues, right, op, str_rep)
+        rvalues = extract_array(right, extract_numpy=True)
+        result = arithmetic_op(lvalues, rvalues, op, str_rep)
 
         return _construct_result(left, result, index=left.index, name=res_name)
 

pandas/core/ops/array_ops.py

@@ -24,17 +24,14 @@
 )
 from pandas.core.dtypes.generic import (
     ABCDatetimeArray,
-    ABCDatetimeIndex,
     ABCExtensionArray,
     ABCIndex,
     ABCIndexClass,
     ABCSeries,
     ABCTimedeltaArray,
-    ABCTimedeltaIndex,
 )
 from pandas.core.dtypes.missing import isna, notna
 
-from pandas.core.construction import extract_array
 from pandas.core.ops import missing
 from pandas.core.ops.dispatch import dispatch_to_extension_op, should_extension_dispatch
 from pandas.core.ops.invalid import invalid_comparison
@@ -178,22 +175,10 @@ def arithmetic_op(
 
     from pandas.core.ops import maybe_upcast_for_op
 
-    keep_null_freq = isinstance(
-        right,
-        (
-            ABCDatetimeIndex,
-            ABCDatetimeArray,
-            ABCTimedeltaIndex,
-            ABCTimedeltaArray,
-            Timestamp,
-        ),
-    )
-
-    # NB: We assume that extract_array has already been called on `left`, but
-    #  cannot make the same assumption about `right`.  This is because we need
-    #  to define `keep_null_freq` before calling extract_array on it.
+    # NB: We assume that extract_array has already been called
+    #  on `left` and `right`.
     lvalues = left
-    rvalues = extract_array(right, extract_numpy=True)
+    rvalues = right
 
     rvalues = maybe_upcast_for_op(rvalues, lvalues.shape)
 
@@ -203,7 +188,7 @@ def arithmetic_op(
         # TimedeltaArray, DatetimeArray, and Timestamp are included here
         #  because they have `freq` attribute which is handled correctly
         #  by dispatch_to_extension_op.
-        res_values = dispatch_to_extension_op(op, lvalues, rvalues, keep_null_freq)
+        res_values = dispatch_to_extension_op(op, lvalues, rvalues)
 
     else:
         with np.errstate(all="ignore"):

pandas/core/ops/dispatch.py

@@ -5,8 +5,6 @@
 
 import numpy as np
 
-from pandas.errors import NullFrequencyError
-
 from pandas.core.dtypes.common import (
     is_datetime64_dtype,
     is_extension_array_dtype,
@@ -97,10 +95,7 @@ def should_series_dispatch(left, right, op):
 
 
 def dispatch_to_extension_op(
-    op,
-    left: Union[ABCExtensionArray, np.ndarray],
-    right: Any,
-    keep_null_freq: bool = False,
+    op, left: Union[ABCExtensionArray, np.ndarray], right: Any,
 ):
     """
     Assume that left or right is a Series backed by an ExtensionArray,
@@ -111,9 +106,6 @@ def dispatch_to_extension_op(
     op : binary operator
     left : ExtensionArray or np.ndarray
     right : object
-    keep_null_freq : bool, default False
-        Whether to re-raise a NullFrequencyError unchanged, as opposed to
-        catching and raising TypeError.
 
     Returns
     -------
@@ -131,20 +123,7 @@ def dispatch_to_extension_op(
 
     # The op calls will raise TypeError if the op is not defined
     # on the ExtensionArray
-
-    try:
-        res_values = op(left, right)
-    except NullFrequencyError:
-        # DatetimeIndex and TimedeltaIndex with freq == None raise ValueError
-        # on add/sub of integers (or int-like).  We re-raise as a TypeError.
-        if keep_null_freq:
-            # TODO: remove keep_null_freq after Timestamp+int deprecation
-            #  GH#22535 is enforced
-            raise
-        raise TypeError(
-            "incompatible type for a datetime/timedelta "
-            "operation [{name}]".format(name=op.__name__)
-        )
+    res_values = op(left, right)
     return res_values
 
 

pandas/core/ops/methods.py

@@ -162,7 +162,6 @@ def _create_methods(cls, arith_method, comp_method, bool_method, special):
     have_divmod = issubclass(cls, ABCSeries)
     # divmod is available for Series
 
-    # yapf: disable
     new_methods = dict(
         add=arith_method(cls, operator.add, special),
         radd=arith_method(cls, radd, special),
@@ -181,8 +180,8 @@ def _create_methods(cls, arith_method, comp_method, bool_method, special):
         rtruediv=arith_method(cls, rtruediv, special),
         rfloordiv=arith_method(cls, rfloordiv, special),
         rpow=arith_method(cls, rpow, special),
-        rmod=arith_method(cls, rmod, special))
-    # yapf: enable
+        rmod=arith_method(cls, rmod, special),
+    )
     new_methods["div"] = new_methods["truediv"]
     new_methods["rdiv"] = new_methods["rtruediv"]
     if have_divmod:

pandas/core/tools/datetimes.py

@@ -322,13 +322,13 @@ def _convert_listlike_datetimes(
         if isinstance(arg, IntegerArray):
             # Send only non-na values to array_with_unit_to_datetime
             mask_na = arg.isna()
-            result_np, tz_parsed = tslib.array_with_unit_to_datetime(
+            result, tz_parsed = tslib.array_with_unit_to_datetime(
                 np.compress(np.logical_not(mask_na), arg), unit, errors=errors
             )
             # Insert na values back in proper positions
             ins_index = np.ravel(np.argwhere(mask_na))
             ins_index -= range(ins_index.shape[0])
-            result = np.insert(result_np, ins_index, None)
+            result = np.insert(result, ins_index, None)
         else:
             result, tz_parsed = tslib.array_with_unit_to_datetime(
                 arg, unit, errors=errors

pandas/io/excel/_base.py

@@ -903,5 +903,9 @@ def __exit__(self, exc_type, exc_value, traceback):
         self.close()
 
     def __del__(self):
-        # Ensure we don't leak file descriptors
-        self.close()
+        # Ensure we don't leak file descriptors, but put in try/except in case
+        # attributes are already deleted
+        try:
+            self.close()
+        except AttributeError:
+            pass

pandas/io/formats/css.py

@@ -18,8 +18,7 @@ def expand(self, prop, value):
             mapping = self.SIDE_SHORTHANDS[len(tokens)]
         except KeyError:
             warnings.warn(
-                'Could not expand "{prop}: {val}"'.format(prop=prop, val=value),
-                CSSWarning,
+                f'Could not expand "{prop}: {value}"', CSSWarning,
             )
             return
         for key, idx in zip(self.SIDES, mapping):
@@ -110,14 +109,14 @@ def __call__(self, declarations_str, inherited=None):
 
         # 3. TODO: resolve other font-relative units
         for side in self.SIDES:
-            prop = "border-{side}-width".format(side=side)
+            prop = f"border-{side}-width"
             if prop in props:
                 props[prop] = self.size_to_pt(
                     props[prop], em_pt=font_size, conversions=self.BORDER_WIDTH_RATIOS
                 )
             for prop in [
-                "margin-{side}".format(side=side),
-                "padding-{side}".format(side=side),
+                f"margin-{side}",
+                f"padding-{side}",
             ]:
                 if prop in props:
                     # TODO: support %
@@ -206,9 +205,9 @@ def _error():
 
         val = round(val, 5)
         if int(val) == val:
-            size_fmt = "{fmt:d}pt".format(fmt=int(val))
+            size_fmt = f"{int(val):d}pt"
         else:
-            size_fmt = "{fmt:f}pt".format(fmt=val)
+            size_fmt = f"{val:f}pt"
         return size_fmt
 
     def atomize(self, declarations):