pandas-dev#25802 Updated type hints to python3 syntax (array files)

Author: gwrome

pandas/core/arrays/array_.py

@@ -4,18 +4,18 @@
 
 from pandas._libs import lib, tslibs
 
+from pandas.core.arrays.base import ExtensionArray
 from pandas.core.dtypes.common import (
     is_datetime64_ns_dtype, is_extension_array_dtype, is_timedelta64_ns_dtype)
 from pandas.core.dtypes.dtypes import ExtensionDtype, registry
 
 from pandas import compat
 
 
-def array(data,         # type: Sequence[object]
-          dtype=None,   # type: Optional[Union[str, np.dtype, ExtensionDtype]]
-          copy=True,    # type: bool
-          ):
-    # type: (...) -> ExtensionArray
+def array(data: Sequence[object],
+          dtype: Optional[Union[str, np.dtype, ExtensionDtype]] = None,
+          copy: bool = True,
+          ) -> ExtensionArray:
     """
     Create an array.
 

pandas/core/arrays/base.py

@@ -214,8 +214,7 @@ def __getitem__(self, item):
         """
         raise AbstractMethodError(self)
 
-    def __setitem__(self, key, value):
-        # type: (Union[int, np.ndarray], Any) -> None
+    def __setitem__(self, key: Union[int, np.ndarray], value: Any) -> None:
         """
         Set one or more values inplace.
 
@@ -262,8 +261,7 @@ def __setitem__(self, key, value):
             type(self), '__setitem__')
         )
 
-    def __len__(self):
-        # type: () -> int
+    def __len__(self) -> int:
         """
         Length of this array
 
@@ -287,32 +285,28 @@ def __iter__(self):
     # Required attributes
     # ------------------------------------------------------------------------
     @property
-    def dtype(self):
-        # type: () -> ExtensionDtype
+    def dtype(self) -> ExtensionDtype:
         """
         An instance of 'ExtensionDtype'.
         """
         raise AbstractMethodError(self)
 
     @property
-    def shape(self):
-        # type: () -> Tuple[int, ...]
+    def shape(self) -> Tuple[int, ...]:
         """
         Return a tuple of the array dimensions.
         """
         return (len(self),)
 
     @property
-    def ndim(self):
-        # type: () -> int
+    def ndim(self) -> int:
         """
         Extension Arrays are only allowed to be 1-dimensional.
         """
         return 1
 
     @property
-    def nbytes(self):
-        # type: () -> int
+    def nbytes(self) -> int:
         """
         The number of bytes needed to store this object in memory.
         """
@@ -343,8 +337,7 @@ def astype(self, dtype, copy=True):
         """
         return np.array(self, dtype=dtype, copy=copy)
 
-    def isna(self):
-        # type: () -> Union[ExtensionArray, np.ndarray]
+    def isna(self) -> Union['ExtensionArray', np.ndarray]:
         """
         A 1-D array indicating if each value is missing.
 
@@ -366,8 +359,7 @@ def isna(self):
         """
         raise AbstractMethodError(self)
 
-    def _values_for_argsort(self):
-        # type: () -> np.ndarray
+    def _values_for_argsort(self) -> np.ndarray:
         """
         Return values for sorting.
 
@@ -482,8 +474,11 @@ def dropna(self):
         """
         return self[~self.isna()]
 
-    def shift(self, periods=1, fill_value=None):
-        # type: (int, object) -> ExtensionArray
+    def shift(
+            self,
+            periods: int = 1,
+            fill_value: object = None,
+    ) -> 'ExtensionArray':
         """
         Shift values by desired number.
 
@@ -598,8 +593,7 @@ def searchsorted(self, value, side="left", sorter=None):
         arr = self.astype(object)
         return arr.searchsorted(value, side=side, sorter=sorter)
 
-    def _values_for_factorize(self):
-        # type: () -> Tuple[np.ndarray, Any]
+    def _values_for_factorize(self) -> Tuple[np.ndarray, Any]:
         """
         Return an array and missing value suitable for factorization.
 
@@ -623,8 +617,10 @@ def _values_for_factorize(self):
         """
         return self.astype(object), np.nan
 
-    def factorize(self, na_sentinel=-1):
-        # type: (int) -> Tuple[np.ndarray, ExtensionArray]
+    def factorize(
+            self,
+            na_sentinel: int = -1,
+    ) -> Tuple[np.ndarray, 'ExtensionArray']:
         """
         Encode the extension array as an enumerated type.
 
@@ -726,8 +722,12 @@ def repeat(self, repeats, axis=None):
     # Indexing methods
     # ------------------------------------------------------------------------
 
-    def take(self, indices, allow_fill=False, fill_value=None):
-        # type: (Sequence[int], bool, Optional[Any]) -> ExtensionArray
+    def take(
+            self,
+            indices: Sequence[int],
+            allow_fill: bool = False,
+            fill_value: Optional[Any] = None
+    ) -> 'ExtensionArray':
         """
         Take elements from an array.
 
@@ -816,8 +816,7 @@ def take(self, indices, allow_fill=False, fill_value=None):
         # pandas.api.extensions.take
         raise AbstractMethodError(self)
 
-    def copy(self, deep=False):
-        # type: (bool) -> ExtensionArray
+    def copy(self, deep: bool = False) -> 'ExtensionArray':
         """
         Return a copy of the array.
 
@@ -853,8 +852,10 @@ def __repr__(self):
                                length=len(self),
                                dtype=self.dtype)
 
-    def _formatter(self, boxed=False):
-        # type: (bool) -> Callable[[Any], Optional[str]]
+    def _formatter(
+            self,
+            boxed: bool = False,
+    ) -> Callable[[Any], Optional[str]]:
         """Formatting function for scalar values.
 
         This is used in the default '__repr__'. The returned formatting
@@ -881,8 +882,7 @@ def _formatter(self, boxed=False):
             return str
         return repr
 
-    def _formatting_values(self):
-        # type: () -> np.ndarray
+    def _formatting_values(self) -> np.ndarray:
         # At the moment, this has to be an array since we use result.dtype
         """
         An array of values to be printed in, e.g. the Series repr
@@ -898,8 +898,10 @@ def _formatting_values(self):
     # ------------------------------------------------------------------------
 
     @classmethod
-    def _concat_same_type(cls, to_concat):
-        # type: (Sequence[ExtensionArray]) -> ExtensionArray
+    def _concat_same_type(
+            cls,
+            to_concat: Sequence['ExtensionArray']
+    ) -> 'ExtensionArray':
         """
         Concatenate multiple array
 
@@ -921,8 +923,7 @@ def _concat_same_type(cls, to_concat):
     _can_hold_na = True
 
     @property
-    def _ndarray_values(self):
-        # type: () -> np.ndarray
+    def _ndarray_values(self) -> np.ndarray:
         """
         Internal pandas method for lossy conversion to a NumPy ndarray.
 

pandas/core/arrays/datetimelike.py

@@ -58,8 +58,7 @@ def _get_attributes_dict(self):
         return {k: getattr(self, k, None) for k in self._attributes}
 
     @property
-    def _scalar_type(self):
-        # type: () -> Union[type, Tuple[type]]
+    def _scalar_type(self) -> Union[type, Tuple[type]]:
         """The scalar associated with this datelike
 
         * PeriodArray : Period
@@ -68,8 +67,10 @@ def _scalar_type(self):
         """
         raise AbstractMethodError(self)
 
-    def _scalar_from_string(self, value):
-        # type: (str) -> Union[Period, Timestamp, Timedelta, NaTType]
+    def _scalar_from_string(
+            self,
+            value: str,
+    ) -> Union[Period, Timestamp, Timedelta, NaTType]:
         """
         Construct a scalar type from a string.
 
@@ -89,8 +90,10 @@ def _scalar_from_string(self, value):
         """
         raise AbstractMethodError(self)
 
-    def _unbox_scalar(self, value):
-        # type: (Union[Period, Timestamp, Timedelta, NaTType]) -> int
+    def _unbox_scalar(
+            self,
+            value: Union[Period, Timestamp, Timedelta, NaTType],
+    ) -> int:
         """
         Unbox the integer value of a scalar `value`.
 
@@ -109,8 +112,10 @@ def _unbox_scalar(self, value):
         """
         raise AbstractMethodError(self)
 
-    def _check_compatible_with(self, other):
-        # type: (Union[Period, Timestamp, Timedelta, NaTType]) -> None
+    def _check_compatible_with(
+            self,
+            other: Union[Period, Timestamp, Timedelta, NaTType],
+    ) -> None:
         """
         Verify that `self` and `other` are compatible.
 
@@ -350,8 +355,7 @@ def __iter__(self):
         return (self._box_func(v) for v in self.asi8)
 
     @property
-    def asi8(self):
-        # type: () -> np.ndarray
+    def asi8(self) -> np.ndarray:
         """
         Integer representation of the values.
 
@@ -402,8 +406,7 @@ def shape(self):
         return (len(self),)
 
     @property
-    def size(self):
-        # type: () -> int
+    def size(self) -> int:
         """The number of elements in this array."""
         return np.prod(self.shape)
 
@@ -461,10 +464,9 @@ def __getitem__(self, key):
 
     def __setitem__(
             self,
-            key,    # type: Union[int, Sequence[int], Sequence[bool], slice]
-            value,  # type: Union[NaTType, Any, Sequence[Any]]
-    ):
-        # type: (...) -> None
+            key: Union[int, Sequence[int], Sequence[bool], slice],
+            value: Union[NaTType, Any, Sequence[Any]]
+    ) -> None:
         # I'm fudging the types a bit here. "Any" above really depends
         # on type(self). For PeriodArray, it's Period (or stuff coercible
         # to a period in from_sequence). For DatetimeArray, it's Timestamp...

pandas/core/arrays/datetimes.py

@@ -275,7 +275,7 @@ class DatetimeArray(dtl.DatetimeLikeArrayMixin,
     # Constructors
 
     _attributes = ["freq", "tz"]
-    _dtype = None  # type: Union[np.dtype, DatetimeTZDtype]
+    _dtype: Union[np.dtype, DatetimeTZDtype] = None
     _freq = None
 
     def __init__(self, values, dtype=_NS_DTYPE, freq=None, copy=False):
@@ -514,8 +514,7 @@ def _box_func(self):
         return lambda x: Timestamp(x, freq=self.freq, tz=self.tz)
 
     @property
-    def dtype(self):
-        # type: () -> Union[np.dtype, DatetimeTZDtype]
+    def dtype(self) -> Union[np.dtype, DatetimeTZDtype]:
         """
         The dtype for the DatetimeArray.
 

pandas/core/arrays/integer.py

@@ -452,8 +452,7 @@ def astype(self, dtype, copy=True):
         return astype_nansafe(data, dtype, copy=None)
 
     @property
-    def _ndarray_values(self):
-        # type: () -> np.ndarray
+    def _ndarray_values(self) -> np.ndarray:
         """Internal pandas method for lossy conversion to a NumPy ndarray.
 
         This method is not part of the pandas interface.
@@ -509,8 +508,7 @@ def value_counts(self, dropna=True):
 
         return Series(array, index=index)
 
-    def _values_for_argsort(self):
-        # type: () -> np.ndarray
+    def _values_for_argsort(self) -> np.ndarray:
         """Return values for sorting.
 
         Returns

pandas/core/arrays/period.py

@@ -183,8 +183,12 @@ def _simple_new(cls, values, freq=None, **kwargs):
         return cls(values, freq=freq, **kwargs)
 
     @classmethod
-    def _from_sequence(cls, scalars, dtype=None, copy=False):
-        # type: (Sequence[Optional[Period]], PeriodDtype, bool) -> PeriodArray
+    def _from_sequence(
+            cls,
+            scalars: Sequence[Optional[Period]],
+            dtype: PeriodDtype = None,
+            copy: bool = False,
+    ) -> 'PeriodArray':
         if dtype:
             freq = dtype.freq
         else:
@@ -246,8 +250,7 @@ def _generate_range(cls, start, end, periods, freq, fields):
     # -----------------------------------------------------------------
     # DatetimeLike Interface
 
-    def _unbox_scalar(self, value):
-        # type: (Union[Period, NaTType]) -> int
+    def _unbox_scalar(self, value: Union[Period, NaTType]) -> int:
         if value is NaT:
             return value.value
         elif isinstance(value, self._scalar_type):
@@ -258,8 +261,7 @@ def _unbox_scalar(self, value):
             raise ValueError("'value' should be a Period. Got '{val}' instead."
                              .format(val=value))
 
-    def _scalar_from_string(self, value):
-        # type: (str) -> Period
+    def _scalar_from_string(self, value: str) -> Period:
         return Period(value, freq=self.freq)
 
     def _check_compatible_with(self, other):
@@ -540,14 +542,9 @@ def _sub_period(self, other):
     @Appender(dtl.DatetimeLikeArrayMixin._addsub_int_array.__doc__)
     def _addsub_int_array(
             self,
-            other,      # type: Union[ExtensionArray, np.ndarray[int]]
-            op          # type: Callable[Any, Any]
-    ):
-        # type: (...) -> PeriodArray
-
-        # TODO: ABCIndexClass is a valid type for other but had to be excluded
-        # due to length of Py2 compatability comment; add back in once migrated
-        # to Py3 syntax
+            other: Union[ExtensionArray, np.ndarray, ABCIndexClass],
+            op: Callable[[Any], Any]
+    ) -> 'PeriodArray':
         assert op in [operator.add, operator.sub]
         if op is operator.sub:
             other = -other
@@ -716,8 +713,11 @@ def _raise_on_incompatible(left, right):
 # -------------------------------------------------------------------
 # Constructor Helpers
 
-def period_array(data, freq=None, copy=False):
-    # type: (Sequence[Optional[Period]], Optional[Tick], bool) -> PeriodArray
+def period_array(
+        data: Sequence[Optional[Period]],
+        freq: Optional[Tick] = None,
+        copy: bool = False,
+) -> PeriodArray:
     """
     Construct a new PeriodArray from a sequence of Period scalars.