Apply suggestions from code review

trygvrad · timhoffm · trygvrad · commit dd8f0c6e06e4 · 2025-07-13T12:59:31.000+02:00
Co-authored-by: Tim Hoffmann &lt;2836374+timhoffm@users.noreply.github.com&gt;
diff --git a/lib/matplotlib/colors.py b/lib/matplotlib/colors.py
@@ -3352,7 +3352,7 @@ def n_components(self):
 
     @property
     def norms(self):
-        """The individual norms held by this `MultiNorm`"""
+        """The individual norms held by this `MultiNorm`."""
         return self._norms
 
     @property
@@ -3361,10 +3361,10 @@ def vmin(self):
         return tuple(n.vmin for n in self._norms)
 
     @vmin.setter
-    def vmin(self, value):
-        value = np.broadcast_to(value, self.n_components)
+    def vmin(self, values):
+        values = np.broadcast_to(values, self.n_components)
         with self.callbacks.blocked():
-            for norm, v in zip(self.norms, value):
+            for norm, v in zip(self.norms, values):
                 if v is not None:
                     norm.vmin = v
         self._changed()
@@ -3375,10 +3375,10 @@ def vmax(self):
         return tuple(n.vmax for n in self._norms)
 
     @vmax.setter
-    def vmax(self, value):
-        value = np.broadcast_to(value, self.n_components)
+    def vmax(self, values):
+        value = np.broadcast_to(values, self.n_components)
         with self.callbacks.blocked():
-            for norm, v in zip(self.norms, value):
+            for norm, v in zip(self.norms, values):
                 if v is not None:
                     norm.vmax = v
         self._changed()
@@ -3389,10 +3389,10 @@ def clip(self):
         return tuple(n.clip for n in self._norms)
 
     @clip.setter
-    def clip(self, value):
-        value = np.broadcast_to(value, self.n_components)
+    def clip(self, values):
+        values = np.broadcast_to(values, self.n_components)
         with self.callbacks.blocked():
-            for norm, v in zip(self.norms, value):
+            for norm, v in zip(self.norms, values):
                 if v is not None:
                     norm.clip = v
         self._changed()
@@ -3404,15 +3404,15 @@ def _changed(self):
         """
         self.callbacks.process('changed')
 
-    def __call__(self, value, clip=None, structured_output=None):
+    def __call__(self, values, clip=None, structured_output=None):
         """
         Normalize the data and return the normalized data.
 
-        Each component of the input is assigned to the constituent norm.
+        Each component of the input is normalized via the constituent norm.
 
         Parameters
         ----------
-        value : array-like
+        values : array-like
             Data to normalize, as tuple, scalar array or structured array.
 
             - If tuple, must be of length `n_components`
@@ -3439,44 +3439,44 @@ def __call__(self, value, clip=None, structured_output=None):
         Notes
         -----
         If not already initialized, ``self.vmin`` and ``self.vmax`` are
-        initialized using ``self.autoscale_None(value)``.
+        initialized using ``self.autoscale_None(values)``.
         """
         if clip is None:
             clip = self.clip
         elif not np.iterable(clip):
             clip = [clip]*self.n_components
 
         if structured_output is None:
-            if isinstance(value, np.ndarray) and value.dtype.fields is not None:
+            if isinstance(values, np.ndarray) and values.dtype.fields is not None:
                 structured_output = True
             else:
                 structured_output = False
 
-        value = self._iterable_components_in_data(value, self.n_components)
+        values = self._iterable_components_in_data(values, self.n_components)
 
-        result = tuple(n(v, clip=c) for n, v, c in zip(self.norms, value, clip))
+        result = tuple(n(v, clip=c) for n, v, c in zip(self.norms, values, clip))
 
         if structured_output:
             result = self._ensure_multicomponent_data(result, self.n_components)
 
         return result
 
-    def inverse(self, value):
+    def inverse(self, values):
         """
-        Map the normalized value (i.e., index in the colormap) back to image data value.
+        Map the normalized values (i.e., index in the colormap) back to data values.
 
         Parameters
         ----------
-        value
-            Normalized value, as tuple, scalar array or structured array.
+        values
+            Normalized values, as tuple, scalar array or structured array.
 
             - If tuple, must be of length `n_components`
             - If scalar array, the first axis must be of length `n_components`
             - If structured array, must have `n_components` fields.
 
         """
-        value = self._iterable_components_in_data(value, self.n_components)
-        result = [n.inverse(v) for n, v in zip(self.norms, value)]
+        values = self._iterable_components_in_data(values, self.n_components)
+        result = [n.inverse(v) for n, v in zip(self.norms, values)]
         return result
 
     def autoscale(self, A):
@@ -3487,8 +3487,8 @@ def autoscale(self, A):
         Parameters
         ----------
         A
-            Data, must be of length `n_components` or be a structured array or scalar
-            with `n_components` fields.
+            Data, must be of length `n_components` or be a structured scalar or
+            structured array with `n_components` fields.
         """
         with self.callbacks.blocked():
             # Pause callbacks while we are updating so we only get
@@ -3561,7 +3561,7 @@ def _ensure_multicomponent_data(data, n_components):
         Parameters
         ----------
         n_components : int
-            -  number of omponents in the data
+            Number of omponents in the data.
         data : np.ndarray, PIL.Image or None
 
         Returns
diff --git a/lib/matplotlib/colors.pyi b/lib/matplotlib/colors.pyi
@@ -430,30 +430,30 @@ class MultiNorm(Norm):
     @property  # type: ignore[override]
     def vmin(self) -> tuple[float | None, ...]: ...
     @vmin.setter
-    def vmin(self, value: ArrayLike | float | None) -> None: ...
+    def vmin(self, values: ArrayLike | float | None) -> None: ...
     @property  # type: ignore[override]
     def vmax(self) -> tuple[float | None, ...]: ...
     @vmax.setter
-    def vmax(self, value: ArrayLike | float | None) -> None: ...
+    def vmax(self, valued: ArrayLike | float | None) -> None: ...
     @property  # type: ignore[override]
     def clip(self) -> tuple[bool, ...]: ...
     @clip.setter
-    def clip(self, value: ArrayLike | bool) -> None: ...
+    def clip(self, values: ArrayLike | bool) -> None: ...
     @overload
-    def __call__(self, value: tuple, clip: ArrayLike | bool | None = ..., structured_output: Literal[False] = ...) -> tuple: ...
+    def __call__(self, values: tuple, clip: ArrayLike | bool | None = ..., structured_output: Literal[False] = ...) -> tuple: ...
     @overload
-    def __call__(self, value: tuple, structured_output: Literal[True], clip: ArrayLike | bool | None = ...) -> np.ma.MaskedArray: ...
+    def __call__(self, values: tuple, structured_output: Literal[True], clip: ArrayLike | bool | None = ...) -> np.ma.MaskedArray: ...
     @overload
-    def __call__(self, value: np.ndarray, clip: ArrayLike | bool | None = ..., structured_output: None | Literal[True] = ...) -> np.ma.MaskedArray: ...
+    def __call__(self, values: np.ndarray, clip: ArrayLike | bool | None = ..., structured_output: None | Literal[True] = ...) -> np.ma.MaskedArray: ...
     @overload
-    def __call__(self, value: np.ndarray, structured_output: Literal[False], clip: ArrayLike | bool | None = ...) -> tuple: ...
+    def __call__(self, values: np.ndarray, structured_output: Literal[False], clip: ArrayLike | bool | None = ...) -> tuple: ...
     @overload
-    def __call__(self, value: ArrayLike, structured_output: Literal[False], clip: ArrayLike | bool | None = ...) -> tuple: ...
+    def __call__(self, values: ArrayLike, structured_output: Literal[False], clip: ArrayLike | bool | None = ...) -> tuple: ...
     @overload
-    def __call__(self, value: ArrayLike, structured_output: Literal[True], clip: ArrayLike | bool | None = ...) -> np.ma.MaskedArray: ...
+    def __call__(self, values: ArrayLike, structured_output: Literal[True], clip: ArrayLike | bool | None = ...) -> np.ma.MaskedArray: ...
     @overload
-    def __call__(self, value: ArrayLike, clip: ArrayLike | bool | None = ..., structured_output: None = ...) -> ArrayLike: ...
-    def inverse(self, value: ArrayLike) -> list: ...  # type: ignore[override]
+    def __call__(self, values: ArrayLike, clip: ArrayLike | bool | None = ..., structured_output: None = ...) -> ArrayLike: ...
+    def inverse(self, values: ArrayLike) -> list: ...  # type: ignore[override]
     def autoscale(self, A: ArrayLike) -> None: ...
     def autoscale_None(self, A: ArrayLike) -> None: ...
     def scaled(self) -> bool: ...
