Repository: ManimCommunity/manim
File: manim/mobject/coordinate_systems.py (Python)

Code before:
    z_normal
        The direction of the normal.
    num_axis_pieces
        The number of pieces used to construct the axes.
    light_source
        The direction of the light source.
    depth
        Currently non-functional.
    gloss
        Currently non-functional.
    kwargs : Any
        Additional arguments to be passed to :class:`Axes`.
    """

    def __init__(
        self,
        x_range: Optional[Union[Sequence[int], np.ndarray]] = (-6, 6, 1),
        y_range: Optional[Union[Sequence[int], np.ndarray]] = (-5, 5, 1),
        z_range: Optional[Union[Sequence[int], np.ndarray]] = (-4, 4, 1),
        x_length: Optional[float] = config.frame_height + 2.5,
        y_length: Optional[float] = config.frame_height + 2.5,
        z_length: Optional[float] = config.frame_height - 1.5,
        z_axis_config: Optional[dict] = None,
        z_normal: Union[Sequence[float], np.ndarray] = DOWN,
        num_axis_pieces: int = 20,
        light_source: Union[Sequence[float], np.ndarray] = 9 * DOWN
        + 7 * LEFT
        + 10 * OUT,
        # opengl stuff (?)
        depth=None,
        gloss=0.5,
        **kwargs,
    ):

        Axes.__init__(
            self,
            x_range=x_range,
            x_length=x_length,
            y_range=y_range,
            y_length=y_length,
            **kwargs,
        )

        self.z_range = z_range
        self.z_length = z_length

        self.z_axis_config = {}
        self.update_default_configs((self.z_axis_config,), (z_axis_config,))

        self.z_normal = z_normal
        self.num_axis_pieces = num_axis_pieces

Review comment (suggestion):
Same as above
```suggestion
        light_source: Sequence[float] = 9 * DOWN
```

Code after:

    def get_riemann_rectangles(
        self,
        graph: "ParametricFunction",
        x_range: Optional[Sequence[float]] = None,
        dx: Optional[float] = 0.1,
        input_sample_type: str = "left",
        stroke_width: float = 1,
        stroke_color: Color = BLACK,
        fill_opacity: float = 1,
        color: Union[Iterable[Color], Color] = np.array((BLUE, GREEN)),
        show_signed_area: bool = True,
        bounded_graph: "ParametricFunction" = None,
        blend: bool = False,
        width_scale_factor: float = 1.001,
    ) -> VGroup:
        """This method returns the :class:`~.VGroup` of the Riemann Rectangles for
        a particular curve.

        Parameters
        ----------
        graph
            The graph whose area will be approximated by Riemann rectangles.

        x_range
            The minimum and maximum x-values of the rectangles. ``x_range = [x_min, x_max]``.

        dx
            The change in x-value that separates each rectangle.

        input_sample_type
            Can be any of ``"left"``, ``"right"`` or ``"center"``. Refers to where
            the sample point for the height of each Riemann Rectangle
            will be inside the segments of the partition.

        stroke_width
            The stroke_width of the border of the rectangles.

        stroke_color
            The color of the border of the rectangle.

        fill_opacity
            The opacity of the rectangles.

        color
            The colors of the rectangles. Creates a balanced gradient if multiple colors are passed.

        show_signed_area
            Indicates negative area when the curve dips below the x-axis by inverting its color.

        blend