code: def geom_violin(
      mapping=None,
      *,
      data=None,
      stat=None,
      position=None,
      show_legend=None,
      sampling=None,
      tooltips=None,
      orientation=None,
      show_half=None,
      quantiles=None,
      quantile_lines=None,
      scale=None,
      trim=None,
      tails_cutoff=None,
      kernel=None,
      bw=None,
      adjust=None,
      n=None,
      fs_max=None,
      color_by=None,
      fill_by=None,
      **other_args,
  ):
      """
      A violin plot is a mirrored density plot with an additional grouping as for a boxplot.
  
      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='ydensity'
          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.
      sampling : `FeatureSpec`
          Result of the call to the `sampling_xxx()` function.
          To prevent any sampling for this layer pass value "none" (string "none").
      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'.
      show_half : float, default=0
          If -1, only half of each violin is drawn.
          If 1, another half is drawn.
          If 0, violins look as usual.
      quantiles : list of float, default=[0.25, 0.5, 0.75]
          Draw horizontal lines at the given quantiles of the density estimate.
      quantile_lines : bool, default=False
          Show the quantile lines.
      scale : {'area', 'count', 'width'}, default='area'
          If 'area', all violins have the same area.
          If 'count', areas are scaled proportionally to the number of observations.
          If 'width', all violins have the same maximum width.
      trim : bool, default=True
          Trim the tails of the violins to the range of the data.
      tails_cutoff : float, default=3.0
          Extend domain of each violin on `tails_cutoff * bw` if `trim=False`.
      kernel : str, default='gaussian'
          The kernel we use to calculate the density function.
          Choose among 'gaussian', 'cosine', 'optcosine', 'rectangular' (or 'uniform'),
          'triangular', 'biweight' (or 'quartic'), 'epanechikov' (or 'parabolic').
      bw : str or float
          The method (or exact value) of bandwidth.
          Either a string (choose among 'nrd0' and 'nrd'), or a float.
      adjust : float
          Adjust the value of bandwidth by multiplying it. Change how smooth the frequency curve is.
      n : int, default=512
          The number of sampled points for plotting the function.
      fs_max : int, default=500
          Maximum size of data to use density computation with 'full scan'.
          For bigger data, less accurate but more efficient density computation is applied.
      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:
  
      - ..violinwidth.. : density scaled for the violin plot, according to area, counts or to a constant maximum width (mapped by default).
      - ..density.. : density estimate.
      - ..count.. : density * number of points.
      - ..scaled.. : density estimate, scaled to maximum of 1.
      - ..quantile.. : quantile estimate.
  
      `geom_violin()` understands the following aesthetics mappings:
  
      - x : x-axis coordinates.
      - y : y-axis coordinates.
      - 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'.
      - weight : used by 'ydensity' stat to compute weighted density.
      - quantile : quantile values to draw quantile lines and fill quantiles of the geometry by color.
  
      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_violin()
  
      |
  
      .. 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', 'y')) + \\
              geom_violin(aes(fill='..quantile..'), scale='count', \\
                          quantiles=[.02, .25, .5, .75, .98], quantile_lines=True)
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 10
  
          import numpy as np
          from lets_plot import *
          LetsPlot.setup_html()
          n = 3
          np.random.seed(42)
          x = ['a'] * n + ['b'] * n + ['c'] * n
          y = 3 * list(range(n))
          vw = np.random.uniform(size=3*n)
          ggplot({'x': x, 'y': y, 'vw': vw}, aes('x', 'y')) + \\
              geom_violin(aes(violinwidth='vw', fill='x'), stat='identity')
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 10-11
  
          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(), aes('variable', 'value')) + \\
              geom_violin(aes(color='variable', fill='variable'), \\
                          size=2, alpha=.5, scale='width') + \\
              geom_boxplot(aes(fill='variable'), width=.2)
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 10-13
  
          import numpy as np
          from lets_plot import *
          LetsPlot.setup_html()
          n = 100
          np.random.seed(42)
          x = np.random.choice(["a", "b", "c", "d"], size=n)
          y1 = np.random.normal(size=n)
          y2 = np.random.normal(size=n)
          ggplot({'x': x, 'y1': y1, 'y2': y2}) + \\
              geom_violin(aes('x', 'y1'), show_half=-1, \\
                          trim=False, fill='#ffffb2') + \\
              geom_violin(aes('x', 'y2'), show_half=1, \\
                          trim=False, fill='#74c476')
  
      """
      if "draw_quantiles" in other_args:
          raise ValueError(
              "The parameter 'draw_quantiles' is no longer supported.\n"
              "Use parameters 'quantile_lines', 'quantiles' as needed."
          )
  
      return _geom(
          "violin",
          mapping=mapping,
          data=data,
          stat=stat,
          position=position,
          show_legend=show_legend,
          sampling=sampling,
          tooltips=tooltips,
          orientation=orientation,
          show_half=show_half,
          quantiles=quantiles,
          quantile_lines=quantile_lines,
          scale=scale,
          trim=trim,
          tails_cutoff=tails_cutoff,
          kernel=kernel,
          bw=bw,
          adjust=adjust,
          n=n,
          fs_max=fs_max,
          color_by=color_by,
          fill_by=fill_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 23 for calling a global function with example usage: geom_violin(mapping) and returns: _geom