code: def geom_pie(
      mapping=None,
      *,
      data=None,
      stat=None,
      position=None,
      show_legend=None,
      sampling=None,
      tooltips=None,
      labels=None,
      map=None,
      map_join=None,
      use_crs=None,
      hole=None,
      stroke_side=None,
      spacer_width=None,
      spacer_color=None,
      size_unit=None,
      color_by=None,
      fill_by=None,
      **other_args,
  ):
      """
      Draw pie chart.
  
      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` or `GeoDataFrame`
          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='count2d'
          The statistical transformation to use on the data for this layer, as a string.
          Supported transformations: 'identity' (leaves the data unchanged),
          'count2d' (counts number of points with same x,y coordinate).
      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").
      tooltips : `layer_tooltips`
          Result of the call to the `layer_tooltips()` function.
          Specify appearance, style and content.
      labels : `layer_labels`
          Result of the call to the `layer_labels()` function.
          Specify style and content of the annotations.
      map : `GeoDataFrame` or `Geocoder`
          Data containing coordinates of points.
      map_join : str or list
          Keys used to join map coordinates with data.
          First value in pair - column/columns in `data`.
          Second value in pair - column/columns in `map`.
      use_crs : str, optional, default="EPSG:4326" (aka WGS84)
          EPSG code of the coordinate reference system (CRS) or the keyword "provided".
          If an EPSG code is given, then all the coordinates in `GeoDataFrame` (see the `map` parameter)
          will be projected to this CRS.
          Specify "provided" to disable any further re-projection and to keep the `GeoDataFrame’s` original CRS.
      hole : float, default=0.0
          A multiplicative factor applied to the pie diameter to draw donut-like chart.
          Accept values between 0 and 1.
      stroke_side : {'outer', 'inner', 'both'}, default='both'
          Define which arcs of pie sector should have a stroke.
      spacer_width : float, default=0.75
          Line width between sectors.
          Spacers are not applied to exploded sectors and to sides of adjacent sectors.
      spacer_color : str
          Color for spacers between sectors. By default, the "paper" color is used.
      size_unit : {'x', 'y'}
          Relate the size of the pie chart to the length of the unit step along one of the axes.
          If None, no fitting is performed.
      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 source aesthetic for geometry filling.
      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:
  
      - ..count.. : number of points with same (x,y) coordinate.
      - ..sum.. : total number of points with same (x,y) coordinate.
      - ..prop.. : groupwise proportion.
      - ..proppct.. : groupwise proportion in percent.
      - ..sumprop.. : proportion of points with same (x,y) coordinate among all points in the dataset.
      - ..sumpct.. : proportion of points with same (x,y) coordinate among all points in the dataset in percent.
  
      `geom_pie()` understands the following aesthetics mappings:
  
      - x : x-axis value.
      - y : y-axis value.
      - slice : values associated to pie sectors.
      - explode : values to explode slices away from their center point, detaching it from the main pie.
      - size : pie diameter.
      - 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").
      - alpha : transparency level of the pie. Accept values between 0 and 1.
      - weight : used by 'count2d' stat to compute weighted sum instead of simple count.
      - stroke : width of inner and outer arcs of pie sector.
      - color : color of inner and outer arcs of pie sector.
  
      |
  
      The `data` and `map` parameters of `GeoDataFrame` type support shapes `Point` and `MultiPoint`.
  
      The `map` parameter of `Geocoder` type implicitly invokes `centroids()` function.
  
      |
  
      The conventions for the values of `map_join` parameter are as follows:
  
      - Joining data and `GeoDataFrame` object
  
        Data has a column named 'State_name' and `GeoDataFrame` has a matching column named 'state':
  
        - map_join=['State_Name', 'state']
        - map_join=[['State_Name'], ['state']]
  
      - Joining data and `Geocoder` object
  
        Data has a column named 'State_name'. The matching key in `Geocoder` is always 'state' (providing it is a state-level geocoder) and can be omitted:
  
        - map_join='State_Name'
        - map_join=['State_Name']
  
      - Joining data by composite key
  
        Joining by composite key works like in examples above, but instead of using a string for a simple key you need to use an array of strings for a composite key. The names in the composite key must be in the same order as in the US street addresses convention: 'city', 'county', 'state', 'country'. For example, the data has columns 'State_name' and 'County_name'. Joining with a 2-keys county level `Geocoder` object (the `Geocoder` keys 'county' and 'state' are omitted in this case):
  
        - map_join=['County_name', 'State_Name']
  
      |
  
      Examples
      --------
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 4
  
          from lets_plot import *
          LetsPlot.setup_html()
          data = {'name': ['a', 'b', 'c', 'd', 'b'], 'value': [40, 90, 10, 50, 20]}
          ggplot(data) + geom_pie(aes(slice='value', fill='name'), stat='identity')
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 4
  
          from lets_plot import *
          LetsPlot.setup_html()
          data = {'name': ['a', 'b', 'c', 'd', 'b'], 'value': [40, 90, 10, 50, 20]}
          ggplot(data) + geom_pie(aes(fill='name', weight='value'), size=.5, size_unit='x')
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 4-6
  
          from lets_plot import *
          LetsPlot.setup_html()
          data = {'name': ['a', 'b', 'c', 'd', 'b'], 'value': [40, 90, 10, 50, 20], 'explode': [0, 0, 0.2, 0, 0]}
          ggplot(data) + geom_pie(aes(fill='name', weight='value', explode='explode'), \\
                                  size=15, hole=0.2, color='black', stroke=2, stroke_side='both', \\
                                  spacer_color='black', spacer_width=2)
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 5-9
  
          from lets_plot import *
          from lets_plot.mapping import *
          LetsPlot.setup_html()
          data = {'name': ['a', 'b', 'c', 'd', 'b'], 'value': [40, 90, 10, 50, 20]}
          ggplot(data) + geom_pie(aes(fill=as_discrete('name', order_by='..count..'), weight='value'), \\
                                  size=15, hole=0.2, \\
                                  tooltips=layer_tooltips().format('@{..prop..}', '.0%') \\
                                                           .line('count|@{..count..} (@{..prop..})') \\
                                                           .line('total|@{..sum..}'))
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 5-7
  
          from lets_plot import *
          from lets_plot.mapping import *
          LetsPlot.setup_html()
          data = {'name': ['a', 'b', 'c', 'd', 'b'], 'value': [40, 90, 10, 50, 20]}
          ggplot(data) + geom_pie(aes(fill=as_discrete('name', order_by='..count..'), weight='value'), \\
                                  size=15, hole=0.2, \\
                                  labels=layer_labels(['..proppct..']).format('..proppct..', '{.1f}%'))
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 9-10
  
          from lets_plot import *
          from lets_plot.geo_data import *
          LetsPlot.setup_html()
          data = {"city": ["New York", "New York", "Philadelphia", "Philadelphia"], \\
                  "est_pop_2020": [4_381_593, 3_997_959, 832_685, 748_846], \\
                  "sex": ["female", "male", "female", "male"]}
          centroids = geocode_cities(data["city"]).get_centroids()
          ggplot() + geom_livemap() + \\
              geom_pie(aes(slice="est_pop_2020", fill="sex", size="est_pop_2020"), \\
                       stat='identity', data=data, map=centroids, map_join="city") + \\
              scale_size(guide='none')
  
      """
      if "stroke_color" in other_args:
          print(
              "WARN: The parameter 'stroke_color' for pie is no longer supported."
          )
          other_args.pop("stroke_color")
  
      return _geom(
          "pie",
          mapping=mapping,
          data=data,
          stat=stat,
          position=position,
          show_legend=show_legend,
          sampling=sampling,
          tooltips=tooltips,
          labels=labels,
          map=map,
          map_join=map_join,
          use_crs=use_crs,
          hole=hole,
          stroke_side=stroke_side,
          spacer_width=spacer_width,
          spacer_color=spacer_color,
          size_unit=size_unit,
          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 43 for calling a global function with example usage: geom_pie(mapping) and returns: _geom