code: def fuzzybreaks(
      scale,
      breaks=None,
      boundary=None,
      binwidth=None,
      bins=30,
      right=True,
  ) -> FloatArray:
      """
      Compute fuzzy breaks
  
      For a continuous scale, fuzzybreaks "preserve" the range of
      the scale. The fuzzing is close to numerical roundoff and
      is visually imperceptible.
  
      Parameters
      ----------
      scale : scale
          Scale
      breaks : array_like
          Sequence of break points. If provided and the scale is not
          discrete, they are returned.
      boundary : float
          First break. If `None` a suitable on is computed using
          the range of the scale and the binwidth.
      binwidth : float
          Separation between the breaks
      bins : int
          Number of bins
      right : bool
          If `True` the right edges of the bins are part of the
          bin. If `False` then the left edges of the bins are part
          of the bin.
  
      Returns
      -------
      out : array_like
      """
      from mizani.utils import round_any
  
      # Bins for categorical data should take the width
      # of one level, and should show up centered over
      # their tick marks. All other parameters are ignored.
      if isinstance(scale, scale_discrete):
          breaks = scale.get_breaks()
          return -0.5 + np.arange(1, len(breaks) + 2)
      else:
          if breaks is not None:
              breaks = scale.transform(breaks)
  
      if breaks is not None:
          return breaks
  
      recompute_bins = binwidth is not None
      srange = scale.limits
  
      if binwidth is None or np.isnan(binwidth):
          binwidth = (srange[1] - srange[0]) / bins
  
      if boundary is None or np.isnan(boundary):
          boundary = round_any(srange[0], binwidth, np.floor)
  
      if recompute_bins:
          bins = int(np.ceil((srange[1] - boundary) / binwidth))
  
      # To minimise precision errors, we do not pass the boundary and
      # binwidth into np.arange as params. The resulting breaks
      # can then be adjusted with finer(epsilon based rather than
      # some arbitrary small number) precision.
      breaks = np.arange(boundary, srange[1] + binwidth, binwidth)
      return _adjust_breaks(breaks, right)
  
file_path: plotnine/plotnine/stats/binning.py
imports: from __future__ import annotations
  import typing
  import numpy
  import pandas
  from ..exceptions import PlotnineError
  from ..scales.scale_discrete import scale_discrete
label_desc: Use image node_id 6 for calling a global function with example usage: fuzzybreaks(scale, breaks, boundary, binwidth, bins, right) and returns: _adjust_breaks, unknown, breaks