class_docstr: Base class for all continuous scales
  
  Parameters
  ----------
  {superclass_parameters}
  trans : str | callable
      Name of a trans function or a trans function.
      See :mod:`mizani.transforms` for possible options.
  oob : callable, default=mizani.bounds.censor
      Function to deal with out of bounds (limits)
      data points. Default is to turn them into
      `np.nan`, which then get dropped.
  minor_breaks : list | int | callable, default=None
      If a list-like, it is the minor breaks points.
      If an integer, it is the number of minor breaks between
      any set of major breaks.
      If a function, it should have the signature
      `func(limits)` and return a list-like of consisting
      of the minor break points.
      If `None`, no minor breaks are calculated.
      The default is to automatically calculate them.
  rescaler : callable, default=mizani.bounds.rescale
      Function to rescale data points so that they can
      be handled by the palette. Default is to rescale
      them onto the [0, 1] range. Scales that inherit
      from this class may have another default.
  
  Notes
  -----
  If using the class directly all arguments must be
  keyword arguments.
docstr: Generate breaks for the axis or legend
  
  Parameters
  ----------
  limits : list_like | None
      If None the self.limits are used
      They are expected to be in transformed
      space.
  
  Returns
  -------
  out : array_like
  
  Notes
  -----
  Breaks are calculated in data space and
  returned in transformed space since all
  data is plotted in transformed space.
code: def get_breaks(
      self, limits: Optional[ScaleContinuousLimits] = None
  ) -> ScaleContinuousBreaks:
      """
      Generate breaks for the axis or legend
  
      Parameters
      ----------
      limits : list_like | None
          If None the self.limits are used
          They are expected to be in transformed
          space.
  
      Returns
      -------
      out : array_like
  
      Notes
      -----
      Breaks are calculated in data space and
      returned in transformed space since all
      data is plotted in transformed space.
      """
      if limits is None:
          limits = self.limits
  
      # To data space
      _limits = self.inverse(limits)
  
      if self.is_empty() or self.breaks is False or self.breaks is None:
          breaks = []
      elif self.breaks is True:
          # TODO: Fix this type mismatch in mizani with
          # a typevar so that type-in = type-out
          _tlimits = self.trans.breaks(_limits)
          breaks: ScaleContinuousBreaks = _tlimits  # pyright: ignore
      elif zero_range(_limits):
          breaks = [_limits[0]]
      elif callable(self.breaks):
          breaks = self.breaks(_limits)
      else:
          breaks = self.breaks
  
      breaks = self.transform(breaks)
      return breaks
  
imports: from __future__ import annotations
  import typing
  from contextlib import suppress
  from warnings import warn
  import numpy
  import pandas
  from mizani.bounds import censor, expand_range_distinct, rescale, zero_range
  from .._utils import match
  from ..doctools import document
  from ..exceptions import PlotnineError, PlotnineWarning
  from ..iapi import range_view, scale_view
  from ._expand import expand_range
  from .range import RangeContinuous
  from .scale import scale
label_desc: Use image node_id 19 for calling the scale_continuous obj's underlying member method code with example usage: obj.get_breaks(limits) and returns: breaks