code: def _plotting_context(context=None, font_scale=1, rc=None):
      """
      Return a parameter dict to scale elements of the figure.
  
      NOTE: This is an internal method from Seaborn that is simply used to
      create a default aesthetic in yellowbrick. If you'd like to use these
      styles then import Seaborn!
  
      This affects things like the size of the labels, lines, and other
      elements of the plot, but not the overall style. The base context
      is "notebook", and the other contexts are "paper", "talk", and "poster",
      which are version of the notebook parameters scaled by .8, 1.3, and 1.6,
      respectively.
  
      This function returns an object that can be used in a ``with`` statement
      to temporarily change the context parameters.
  
      Parameters
      ----------
      context : dict, None, or one of {paper, notebook, talk, poster}
          A dictionary of parameters or the name of a preconfigured set.
      font_scale : float, optional
          Separate scaling factor to independently scale the size of the
          font elements.
      rc : dict, optional
          Parameter mappings to override the values in the preset seaborn
          context dictionaries. This only updates parameters that are
          considered part of the context definition.
  
      """
      if isinstance(context, dict):
          context_dict = context
  
      else:
          # Set up dictionary of default parameters
          base_context = {
              "figure.figsize": np.array([8, 5.5]),
              "font.size": 12,
              "axes.labelsize": 11,
              "axes.titlesize": 12,
              "xtick.labelsize": 10,
              "ytick.labelsize": 10,
              "legend.fontsize": 10,
              "grid.linewidth": 1,
              "lines.linewidth": 1.75,
              "patch.linewidth": 0.3,
              "lines.markersize": 7,
              "lines.markeredgewidth": 0,
              "xtick.major.width": 1,
              "ytick.major.width": 1,
              "xtick.minor.width": 0.5,
              "ytick.minor.width": 0.5,
              "xtick.major.pad": 7,
              "ytick.major.pad": 7,
          }
  
          # Scale all the parameters by the same factor depending on the context
          scaling = dict(paper=0.8, notebook=1, talk=1.3, poster=1.6)[
              "notebook"
          ]
          context_dict = {
              k: v * scaling for k, v in base_context.items()
          }
  
          # Now independently scale the fonts
          font_keys = [
              "axes.labelsize",
              "axes.titlesize",
              "legend.fontsize",
              "xtick.labelsize",
              "ytick.labelsize",
              "font.size",
          ]
          font_dict = {
              k: context_dict[k] * font_scale for k in font_keys
          }
          context_dict.update(font_dict)
  
      # Implement hack workaround for matplotlib bug
      # See https://github.com/mwaskom/seaborn/issues/344
      # There is a bug in matplotlib 1.4.2 that makes points invisible when
      # they don't have an edgewidth. It will supposedly be fixed in 1.4.3.
      if mpl.__version__ == "1.4.2":
          context_dict["lines.markeredgewidth"] = 0.01
  
      # Override these settings with the provided rc dictionary
      if rc is not None:
          rc = {k: v for k, v in rc.items() if k in _context_keys}
          context_dict.update(rc)
  
      # Wrap in a _PlottingContext object so this can be used in a with statement
      context_object = _PlottingContext(context_dict)
  
      return context_object
  
imports: import functools
  import numpy
  import matplotlib
  from distutils.version import LooseVersion
  from ..None import _orig_rc_params
  from .palettes import color_palette, set_color_codes
label_desc: Use image node_id 6 for calling a global function with example usage: _plotting_context(context, font_scale, rc) and returns: context_object