code: def geom_abline(
      mapping=None,
      *,
      data=None,
      stat=None,
      position=None,
      show_legend=None,
      sampling=None,
      slope=None,
      intercept=None,
      color_by=None,
      **other_args,
  ):
      """
      Add a straight line with specified slope and intercept to the plot.
  
      Parameters
      ----------
      mapping : `FeatureSpec`
          Set of aesthetic mappings created by `aes()` function.
          Aesthetic mappings describe the way that variables in the data are
          mapped to plot "aesthetics".
      data : dict or Pandas or Polars `DataFrame`
          The data to be displayed in this layer. If None, the default, the data
          is inherited from the plot data as specified in the call to ggplot.
      stat : str, default='identity'
          The statistical transformation to use on the data for this layer, as a string.
      position : str or `FeatureSpec`, default='identity'
          Position adjustment, either as a string ('identity', 'stack', 'dodge', ...),
          or the result of a call to a position adjustment function.
      show_legend : bool, default=True
          False - do not show legend for this layer.
      sampling : `FeatureSpec`
          Result of the call to the `sampling_xxx()` function.
          To prevent any sampling for this layer pass value "none" (string "none").
      slope : float
          The line slope.
      intercept : float
          The value of y at the point where the line crosses the y axis.
      color_by : {'fill', 'color', 'paint_a', 'paint_b', 'paint_c'}, default='color'
          Define the color aesthetic for the geometry.
      other_args
          Other arguments passed on to the layer.
          These are often aesthetics settings used to set an aesthetic to a fixed value,
          like color='red', fill='blue', size=3 or shape=21.
          They may also be parameters to the paired geom/stat.
  
      Returns
      -------
      `LayerSpec`
          Geom object specification.
  
      Notes
      -----
      Unlike most other geoms, this geom does not affect the x and y scales.
  
      `geom_abline()` understands the following aesthetics mappings:
  
      - slope : line slope.
      - intercept : line y-intercept.
      - alpha : transparency level of a layer. Accept values between 0 and 1.
      - color (colour) : color of the geometry lines. String in the following formats: RGB/RGBA (e.g. "rgb(0, 0, 255)"); HEX (e.g. "#0000FF"); color name (e.g. "red"); role name ("pen", "paper" or "brush").
      - size : lines width.
      - linetype : type of the line. Codes and names: 0 = 'blank', 1 = 'solid', 2 = 'dashed', 3 = 'dotted', 4 = 'dotdash', 5 = 'longdash', 6 = 'twodash'.
  
      Examples
      --------
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 3
  
          from lets_plot import *
          LetsPlot.setup_html()
          ggplot() + geom_abline(slope=0)
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 17-18
  
          import numpy as np
          import pandas as pd
          from lets_plot import *
          LetsPlot.setup_html()
          n, m = 10, 3
          np.random.seed(42)
          ids = np.arange(m).astype(str)
          x = np.linspace(0, 1, n)
          y = x + np.random.uniform(size=(m, n))
          df = pd.DataFrame({'id': np.repeat(ids, n),
                             'x': np.tile(x, m),
                             'y': y.reshape(m * n)})
          slope = np.corrcoef(y, x)[0, :-1] * y.std(axis=1) / x.std()
          intercept = y.mean(axis=1) - slope * x.mean()
          reg_df = pd.DataFrame({'id': ids, 'slope': slope, 'intercept': intercept})
          ggplot() + \\
              geom_abline(aes(slope='slope', intercept='intercept', color='id'), \\
                          data=reg_df, size=1, linetype='dashed') + \\
              geom_point(aes(x='x', y='y', color='id', fill='id'), \\
                         data=df, size=4, shape=21, alpha=.5)
  
      """
      return _geom(
          "abline",
          mapping=mapping,
          data=data,
          stat=stat,
          position=position,
          show_legend=show_legend,
          sampling=sampling,
          slope=slope,
          intercept=intercept,
          color_by=color_by,
          **other_args,
      )
  
imports: from lets_plot.geo_data_internals.utils import is_geocoder
  from .core import FeatureSpec, LayerSpec
  from .util import as_annotated_data, is_geo_data_frame, geo_data_frame_to_crs, get_geo_data_frame_meta
label_desc: Use image node_id 19 for calling a global function with example usage: geom_abline(mapping) and returns: _geom