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 labels for the axis or legend
  
  Parameters
  ----------
  breaks: None | array_like
      If None, use self.breaks.
code: def get_labels(
      self, breaks: Optional[ScaleContinuousBreaks] = None
  ) -> ScaleLabels:
      """
      Generate labels for the axis or legend
  
      Parameters
      ----------
      breaks: None | array_like
          If None, use self.breaks.
      """
      if breaks is None:
          breaks = self.get_breaks()
  
      breaks = self.inverse(breaks)
      labels: Sequence[str]
  
      if self.labels is False or self.labels is None:
          labels = []
      elif self.labels is True:
          labels = self.trans.format(breaks)  # type: ignore
      elif callable(self.labels):
          labels = self.labels(breaks)
      elif isinstance(self.labels, dict):
          labels = [
              str(self.labels[b]) if b in self.labels else str(b)
              for b in breaks
          ]
      else:
          # When user sets breaks and labels of equal size,
          # but the limits exclude some of the breaks.
          # We remove the corresponding labels
          from collections.abc import Sized
  
          labels = self.labels
          if (
              len(labels) != len(breaks)
              and isinstance(self.breaks, Sized)
              and len(labels) == len(self.breaks)
          ):
              _wanted_breaks = set(breaks)
              labels = [
                  l
                  for l, b in zip(labels, self.breaks)
                  if b in _wanted_breaks
              ]
  
      if len(labels) != len(breaks):
          raise PlotnineError("Breaks and labels are different lengths")
  
      return labels
  
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 22 for calling the scale_continuous obj's underlying member method code with example usage: obj.get_labels(breaks) and returns: labels