Cleaned up work comments.

pandas/core/arrays/_mixins.py

@@ -155,83 +155,6 @@ def view(self, dtype: Dtype | None = None) -> ArrayLike:
  # "ExtensionDtype | dtype[Any]"; expected "dtype[Any] | _HasDType[dtype[Any]]"
  return arr.view(dtype=dtype) # type: ignore[arg-type]
 
-
- # Notes on take method fix
- # Please remove these once this fix is ready to submit.
- # =======================================================================
-
- # One of the base classes to this class: ExtensionArray, provides
- # the dtype property, but abstractly, so it leaves the implementation
- # of dtype storage up to its derived classes. Some of these derived
- # classes don't provide a setter method for their dtype property, so
- # I can't set the dtype here and expect it to work for all classes that
- # inherit this take method.
-
- # How can I produce an extension array of the same type as self,
- # having a floating-point dtype if self has an integer dtype or otherwise
- # the same dtype as self?
-
- # Constructing a new object of the same type as self doesn't always
- # work since the constructors of some derived classes of this class
- # don't accept a dtype parameter, which I need to pass to set the
- # result's dtype to a floating-point type.
-
- # All tests pass when I create a new extension array object with the
- # appropriate dtype (in the integer-dtype source case), however MyPy
- # complains about the missing dtype argument in the call to type(self)
- # below. By creating a new array object, this call produces an array
- # with a floating point dtype, even when the source dtype is integral.
- # I think this happens because the new array is created with the newly
- # produced data from the underlying take method, which has the
- # appropriate underlying dtype.
-
- # Essentially, these extension arrays are wrappers around Numpy arrays
- # which have their own dtype and store the data. Thus, the new
- # extension array inherits the dtype from the Numpy array used
- # to create it.
-
- # Unfortunately, some of the derived constructors of this class have a
- # positional dtype argument, while some do not. If I call a constructor
- # without specifying this argument, mypy will complain about the
- # missing argument in the case of constructors that require it, but
- # if I call the constructor with the dtype argument, the constructors
- # that don't have it will fail at runtime since they don't recognize
- # it.
-
- # How can I get around this issue?
- # Ideas:
- # Modify the extension array type to allow modification of its dtype
- # after construction.
-
- # Add a conditional branch to this method to call derived constructors
- # with or without the dtype argument, depending on their class.
- # This approach has the disadvantage of hardcoding information about
- # derived classes in this base class, which means that if someone
- # changes a constructor of a derived class to remove the dtype argument,
- # this method will break.
-
- # Classes derived from this class include:
-
- # Categorical
- # DatetimeLikeArrayMixin
- # DatelikeOps
- # PeriodArray
- # DatetimeArray
- # TimelikeOps
- # TimedeltaArray
- # NumpyExtensionArray
- # StringArray
-
- # The types of extension arrays (within Pandas) derived from this class are:
- # Class name Constructor takes dtype argument Dtype argument required
- # Categorical yes no
- # PeriodArray yes no
- # DatetimeArray
- # TimedeltaArray
- # StringArray yes no
- # NumpyExtensionArray no no
-
-
  def take(
  self,
  indices: TakeIndexer,

pandas/core/arrays/numpy_.py

@@ -363,6 +363,9 @@ def take(
  Take entries from this array at each index in a list of indices,
  producing an array containing only those entries.
  """
+ result = super().take(
+ indices, allow_fill=allow_fill, fill_value=fill_value, axis=axis
+ )
  # See GH#62448.
  if self.dtype.numpy_dtype in [
  np.uint8,
@@ -372,51 +375,11 @@ def take(
  np.int8,
  np.int16,
  np.int32,
- np.int64
+ np.int64,
  ]:
- # In this case, the resulting extension array should have a floating-point
- # dtype to match the result of the underlying take method when
- # NaN values need to be incorporated into it.
- # This occurs when allow_fill is True and fill_value is None.
- # (fill_value may be an arbitrary Python object, in which case
- # the result will be an array of objects.)
-
- # Call the take method of NDArrayBackedExtensionArray
-
- # TODO: How is the dtype of a newly constructed NumpyExtensionArray set?
- # It's set to match the dtype of its underlying array.
-
- result = super().take(
- indices,
- allow_fill=allow_fill,
- fill_value=fill_value,
- axis=axis
- )
  return type(self)(result, copy=False)
-
- # In this case, the resulting extension array will have a dtype
- # that matches that of the underlying Numpy array and we can link
- # to the underlying array without manipulating the extension's
- # dtype.
-
- return super().take(
- indices,
- allow_fill=allow_fill,
- fill_value=fill_value,
- axis=axis
- )
- # result array dtype = self dtype
-
- # Implementation steps:
- # Determine requirements for this method, including:
- # Argument types [done]
- # Return type [done]
- # Return dtype [done]
- # Write tests to check whether this method satisfies these requirements. [done]
- # Figure out what base class method to call to implement the take functionality. [done]
- # Implement the call. [done]
- # Check whether this method satisfies its requirements by running the tests.
-
+
+ return result
 
  # ------------------------------------------------------------------------
  # Reductions

pandas/tests/arrays/numpy_/test_numpy.py

@@ -326,7 +326,10 @@ def test_factorize_unsigned():
 
 
 # TODO: Add the smaller width dtypes to the parameter sets of these tests.
-@pytest.mark.parametrize("dtype", [np.uint8, np.uint16, np.uint32, np.uint64, np.int8, np.int16, np.int32, np.int64])
+@pytest.mark.parametrize(
+ "dtype",
+ [np.uint8, np.uint16, np.uint32, np.uint64, np.int8, np.int16, np.int32, np.int64],
+)
 def test_take_assigns_floating_point_dtype(dtype):
  # GH#62448.
  array = NumpyExtensionArray(np.array([1, 2, 3], dtype=dtype))
@@ -339,7 +342,11 @@ def test_take_assigns_floating_point_dtype(dtype):
 
  assert result.dtype.numpy_dtype == np.float64
 
-@pytest.mark.parametrize("dtype", [np.uint8, np.uint16, np.uint32, np.uint64, np.int8, np.int16, np.int32, np.int64])
+
+@pytest.mark.parametrize(
+ "dtype",
+ [np.uint8, np.uint16, np.uint32, np.uint64, np.int8, np.int16, np.int32, np.int64],
+)
 def test_take_assigns_integer_dtype_when_fill_disallowed(dtype):
  # GH#62448.
  array = NumpyExtensionArray(np.array([1, 2, 3], dtype=dtype))