code: def hexbin(
      x: Any,
      y: Any,
      size: float,
      orientation: str = "pointytop",
      aspect_scale: float = 1,
  ) -> Any:
      """Perform an equal-weight binning of data points into hexagonal tiles.
  
      For more sophisticated use cases, e.g. weighted binning or scaling
      individual tiles proportional to some other quantity, consider using
      HoloViews.
  
      Args:
          x (array[float]) :
              A NumPy array of x-coordinates for binning
  
          y (array[float]) :
              A NumPy array of y-coordinates for binning
  
          size (float) :
              The size of the hexagonal tiling.
  
              The size is defined as the distance from the center of a hexagon
              to the top corner for "pointytop" orientation, or from the center
              to a side corner for "flattop" orientation.
  
          orientation (str, optional) :
              Whether the hex tile orientation should be "pointytop" or
              "flattop". (default: "pointytop")
  
          aspect_scale (float, optional) :
              Match a plot's aspect ratio scaling.
  
              When working with a plot with ``aspect_scale != 1``, this
              parameter can be set to match the plot, in order to draw
              regular hexagons (instead of "stretched" ones).
  
              This is roughly equivalent to binning in "screen space", and
              it may be better to use axis-aligned rectangular bins when
              plot aspect scales are not one.
  
      Returns:
          DataFrame
  
          The resulting DataFrame will have columns *q* and *r* that specify
          hexagon tile locations in axial coordinates, and a column *counts* that
          provides the count for each tile.
  
      .. warning::
          Hex binning only functions on linear scales, i.e. not on log plots.
  
      """
      pd: Any = import_required(
          "pandas", "hexbin requires pandas to be installed"
      )
  
      q, r = cartesian_to_axial(
          x, y, size, orientation, aspect_scale=aspect_scale
      )
  
      df = pd.DataFrame(dict(r=r, q=q))
  
      return df.groupby(["q", "r"]).size().reset_index(name="counts")
  
file_path: bokeh/src/bokeh/util/hex.py
imports: from __future__ import annotations
  import logging
  from typing import Any
  import numpy
  from .dependencies import import_required
label_desc: Use image node_id 3 for calling a global function with example usage: hexbin(x, y, size, orientation, aspect_scale) and returns: df