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.
code: def limits(self):
      if self.is_empty():
          return (0, 1)
  
      if self._limits is None:
          return self.range.range
      elif callable(self._limits):
          # Function works in the dataspace, but the limits are
          # stored in transformed space. The range of the scale is
          # in transformed space (i.e. with in the domain of the scale)
          _range = self.inverse(self.range.range)
          return self.trans.transform(self._limits(_range))
      elif (
          self._limits is not None
          and not self.range.is_empty()
          and
          # Fall back to the range if the limits
          # are not set or if any is None or NaN
          len(self._limits) == len(self.range.range)
      ):
          l1, l2 = self._limits
          r1, r2 = self.range.range
          if l1 is None:
              l1 = self.trans.transform([r1])[0]
          if l2 is None:
              l2 = self.trans.transform([r2])[0]
          return l1, l2
  
      return self._limits
  
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 5 for calling the scale_continuous obj's underlying member method code with example usage: obj.limits() and returns: self, int,  int, self, self, l1,  l2