code: def geom_boxplot(
      mapping=None,
      *,
      data=None,
      stat=None,
      position=None,
      show_legend=None,
      tooltips=None,
      orientation=None,
      fatten=None,
      outlier_alpha=None,
      outlier_color=None,
      outlier_fill=None,
      outlier_shape=None,
      outlier_size=None,
      outlier_stroke=None,
      varwidth=None,
      whisker_width=None,
      color_by=None,
      fill_by=None,
      **other_args,
  ):
      """
      Display the distribution of data based on a five number summary
      ("minimum", first quartile (Q1), median, third quartile (Q3), and "maximum"),
      and "outlying" points individually.
  
      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='boxplot'
          The statistical transformation to use on the data for this layer, as a string.
      position : str or `FeatureSpec`, default='dodge'
          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.
      tooltips : `layer_tooltips`
          Result of the call to the `layer_tooltips()` function.
          Specify appearance, style and content.
      orientation : str, default='x'
          Specify the axis that the layer's stat and geom should run along.
          Possible values: 'x', 'y'.
      fatten : float, default=2.0
          A multiplicative factor applied to size of the middle bar.
      outlier_alpha : float
          Default transparency aesthetic for outliers.
      outlier_color : str
          Default color aesthetic for outliers.
      outlier_fill : str
          Default fill aesthetic for outliers.
      outlier_shape : int
          Default shape aesthetic for outliers, an integer from 0 to 25.
      outlier_size : float
          Default size aesthetic for outliers.
      outlier_stroke : float
          Default width of the border for outliers.
      varwidth : bool, default=False
          If False, make a standard box plot.
          If True, boxes are drawn with widths proportional to the square-roots
          of the number of observations in the groups.
      whisker_width : float, default=0.5
          A multiplicative factor applied to the box width to draw horizontal segments on whiskers.
      color_by : {'fill', 'color', 'paint_a', 'paint_b', 'paint_c'}, default='color'
          Define the color aesthetic for the geometry.
      fill_by : {'fill', 'color', 'paint_a', 'paint_b', 'paint_c'}, default='fill'
          Define the fill 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
      -----
      Computed variables:
  
      - ..lower.. : lower hinge, 25% quantile.
      - ..middle.. : median, 50% quantile.
      - ..upper.. : upper hinge, 75% quantile.
      - ..ymin.. : lower whisker = smallest observation greater than or equal to lower hinge - 1.5 * IQR.
      - ..ymax.. : upper whisker = largest observation less than or equal to upper hinge + 1.5 * IQR.
  
      `geom_boxplot()` understands the following aesthetics mappings:
  
      - x : x-axis coordinates.
      - lower : lower hinge.
      - middle : median.
      - upper : upper hinge.
      - ymin : lower whisker.
      - ymax : upper whisker.
      - 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").
      - fill : fill color. 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 of border. Codes and names: 0 = 'blank', 1 = 'solid', 2 = 'dashed', 3 = 'dotted', 4 = 'dotdash', 5 = 'longdash', 6 = 'twodash'.
      - width : width of boxplot. Typically ranges between 0 and 1. Values that are greater than 1 lead to overlapping of the boxes.
  
      Examples
      --------
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 9
  
          import numpy as np
          from lets_plot import *
          LetsPlot.setup_html()
          n = 100
          np.random.seed(42)
          x = np.random.choice(['a', 'b', 'c'], size=n)
          y = np.random.normal(size=n)
          ggplot({'x': x, 'y': y}, aes(x='x', y='y')) + \\
              geom_boxplot()
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 9-10
  
          import numpy as np
          from lets_plot import *
          LetsPlot.setup_html()
          n = 100
          np.random.seed(42)
          x = np.random.choice(['a', 'b', 'b', 'c'], size=n)
          y = np.random.normal(size=n)
          ggplot({'x': x, 'y': y}, aes(x='x', y='y')) + \\
              geom_boxplot(fatten=5, varwidth=True, \\
                           outlier_shape=8, outlier_size=2)
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 16-17
  
          import numpy as np
          import pandas as pd
          from lets_plot import *
          LetsPlot.setup_html()
          n = 100
          np.random.seed(42)
          x = np.random.choice(['a', 'b', 'c'], size=n)
          y = np.random.normal(size=n)
          df = pd.DataFrame({'x': x, 'y': y})
          agg_df = df.groupby('x').agg({'y': [
              'min', lambda s: np.quantile(s, 1/3),
              'median', lambda s: np.quantile(s, 2/3), 'max'
          ]}).reset_index()
          agg_df.columns = ['x', 'y0', 'y33', 'y50', 'y66', 'y100']
          ggplot(agg_df, aes(x='x')) + \\
              geom_boxplot(aes(ymin='y0', lower='y33', middle='y50', \\
                               upper='y66', ymax='y100'), stat='identity')
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 10-13
  
          import numpy as np
          import pandas as pd
          from lets_plot import *
          LetsPlot.setup_html()
          n, m = 100, 5
          np.random.seed(42)
          df = pd.DataFrame({'x%s' % i: np.random.normal(size=n) \\
                             for i in range(1, m + 1)})
          ggplot(df.melt()) + \\
              geom_boxplot(aes(x='variable', y='value', color='variable', \\
                               fill='variable'), \\
                           outlier_shape=21, outlier_size=1.5, size=2, \\
                           alpha=.5, width=.5, show_legend=False)
  
      """
      boxplot_layer = _geom(
          "boxplot",
          mapping=mapping,
          data=data,
          stat=stat,
          position=position,
          show_legend=show_legend,
          sampling=None,
          tooltips=tooltips,
          orientation=orientation,
          fatten=fatten,
          varwidth=varwidth,
          whisker_width=whisker_width,
          color_by=color_by,
          fill_by=fill_by,
          **other_args,
      )
      if stat is None or stat == "boxplot":
          outlier_param = (
              lambda name, value: value
              if value is not None
              else other_args.get(name)
          )
          outlier_fatten = 4
          size = outlier_param("size", outlier_size)
          if size is not None:
              size *= outlier_fatten
          boxplot_layer += _geom(
              "point",
              mapping=mapping,
              data=data,
              stat="boxplot_outlier",
              position=position,
              show_legend=False,
              sampling=None,
              orientation=orientation,
              alpha=outlier_alpha,
              color=outlier_param("color", outlier_color),
              fill=outlier_param("fill", outlier_fill),
              shape=outlier_param("shape", outlier_shape),
              size=size,
              stroke=outlier_param("stroke", outlier_stroke),
              color_by=color_by,
              fill_by=fill_by,
          )
      return boxplot_layer
  
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 22 for calling a global function with example usage: geom_boxplot(mapping) and returns: boxplot_layer