Cleaned up work comments.

Author: aijams

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))