
    -e              	         d Z ddlmZ ddlZ ej        e          ZddlmZm	Z	m
Z
mZmZ ddlmZ ddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z# ddl$m%Z%m&Z&m'Z'm(Z( dd	l)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 d
dl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9 d
dl:m;Z;m<Z<m=Z= dZ>e G d de9e7e4e6                      Z?e G d de7e4e6                      Z@ G d de9e7e4e6          ZA G d de9e7e4e6          ZB G d de9e7          ZC G d de7          ZD G d de@          ZE G d de?          ZF G d de9e7e4e6          ZG G d  d!e7e4e6          ZH G d" d#e4e6          ZI G d$ d%e@          ZJ G d& d'e7e4e6          ZKe G d( d)e9                      ZL G d* d+eL          ZM G d, d-eL          ZN G d. d/eL          ZO G d0 d1e9          ZP G d2 d3e3e7          ZQ G d4 d5e7          ZR G d6 d7e7e4e6          ZS G d8 d9e3e7e4e6          ZT G d: d;e7e4e6          ZU G d< d=e@          ZV G d> d?e7          ZW G d@ dAe9e7          ZX G dB dCe9e7e4e6          ZY G dD dEe?          ZZ G dF dGe7          Z[ G dH dIe9e7          Z\ G dJ dKe9e8          Z] G dL dMe4e6          Z^ G dN dOe4e6          Z_ G dP dQe@          Z` G dR dSe9e7e4e6          Za G dT dUe7          Zb G dV dWe7          Zc G dX dYe7e4e6          Zd G dZ d[e7e4e6          ZedS )\aX   Display a variety of visual shapes whose attributes can be associated
with data columns from ``ColumnDataSources``.



The full list of glyphs is below:

.. toctree::
   :maxdepth: 1
   :glob:

   glyphs/*

All glyphs share a minimal common interface through the base class ``Glyph``:

.. bokeh-model:: Glyph
    :module: bokeh.models.glyphs

    )annotationsN   )	DirectionImageOriginPaletteStepModeenumeration)abstract)	AngleSpecBoolDataSpecDistanceSpecEnumFloatIncludeInstanceInstanceDefaultInt
MarkerSpecNullDistanceSpec
NumberSpecOverrideSizeSizeSpecString
StringSpecfieldvalue)AnchorBorderRadiusPadding
TextAnchor)	FillProps
HatchProps
ImageProps	LinePropsScalarFillPropsScalarHatchPropsScalarLineProps	TextProps   )ConnectedXYGlyph	FillGlyphGlyph
HatchGlyph	LineGlyph	TextGlyphXYGlyph)ColorMapperLinearColorMapperStackColorMapper)(AnnularWedgeAnnulusArcBezierBlockCircler,   Ellipser.   HArea	HAreaStepHBarHSpanHStripHexTileImage	ImageRGBA
ImageStackImageURLLineMarker	MultiLineMultiPolygonsPatchPatchesQuad	QuadraticRayRectScatterSegmentStepTextVArea	VAreaStepVBarVSpanVStripWedger2   c                      e Zd ZdZd fdZdZ e ed          d          Z e ed	          d
          Z	 e
dd          Z edd          Z edd          Z eed          Z eed          Z eed          Z xZS )rH   a   Base class for glyphs that are simple markers with line and
    fill properties, located at an (x, y) location with a specified
    size.

    .. note::
        For simplicity, all markers have both line and fill properties
        declared, however some marker types (`asterisk`, `cross`, `x`)
        only draw lines. For these markers, the fill values are simply
        ignored.

    returnNonec                :     t                      j        |i | d S Nsuper__init__selfargskwargs	__class__s      3lib/python3.11/site-packages/bokeh/models/glyphs.pyrb   zMarker.__init__   %    $)&)))))    )xysizeanglerk   z?
    The x-axis coordinates for the center of the markers.
    defaulthelprl   z?
    The y-axis coordinates for the center of the markers.
          ?z
    The factor by which to dilate the hit radius
    which is responsible for defining the range in which a
    marker responds to interactions with the Hover and Tap
    tools.
       zK
    The size (diameter) values for the markers in screen space units.
            z+
    The angles to rotate the markers.
    z,
    The {prop} values for the markers.
    rq   r\   r]   )__name__
__module____qualname____doc__rb   _argsr   r   rk   rl   r   hit_dilationr   rm   r   rn   r   r&   
line_propsr#   
fill_propsr$   hatch_props__classcell__rg   s   @rh   rH   rH      sH       
 
* * * * * * (E
55:: - 		 		 		A 	
55:: - 		 		 		A 4 + 	 	 	L 8A % 	 	 	D Ic ) 	 	 	E  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   rH   c                  >     e Zd ZdZd fdZ edd          Z xZS )		LRTBGlyphz) Base class for axis-aligned rectangles. r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zLRTBGlyph.__init__   ri   rj   r   
    Allows the box to have rounded corners.

    .. note::
        This property is experimental and may change at any point.
    ro   rv   )rw   rx   ry   rz   rb   r    border_radiusr   r   s   @rh   r   r      sV        33* * * * * * !L 2 	 	 	MMMMMrj   r   c                      e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z e ed          d	          Z e ed          d	          Z e ed          d	          Z eeej        d	          Z eed          Z eed          Z eed          Z xZS )r6   z Render annular wedges.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zAnnularWedge.__init__   ri   rj   z)examples/reference/models/AnnularWedge.py)rk   rl   inner_radiusouter_radiusstart_angle	end_angle	directionrk   z@
    The x-coordinates of the center of the annular wedges.
    ro   rl   z@
    The y-coordinates of the center of the annular wedges.
    r   z0
    The inner radii of the annular wedges.
    r   z0
    The outer radii of the annular wedges.
    r   zR
    The angles to start the annular wedges, as measured from the horizontal.
    r   zP
    The angles to end the annular wedges, as measured from the horizontal.
    E
    Which direction to stroke between the start and end angles.
    z3
    The {prop} values for the annular wedges.
    ru   rv   )rw   rx   ry   rz   rb   __example__r{   r   r   rk   rl   r   r   r   r   r   r   r   r   	anticlockr   r   r&   r}   r#   r~   r$   r   r   r   s   @rh   r6   r6      s        
* * * * * * >K_E
55:: - 		 		 		A 	
55:: - 		 		 		A  <n(=(= E 	 	 	L  <n(=(= E 	 	 	L )EE-$8$8 @ 	 	 	K 	%%"4"4 < 	 	 	I Y	(; C 	 	 	I  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   r6   c                  *    e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z e ed          d	          Z eed          Z eed          Z eed          Z xZS )r7   z Render annuli.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zAnnulus.__init__  ri   rj   z$examples/reference/models/Annulus.py)rk   rl   r   r   rk   z8
    The x-coordinates of the center of the annuli.
    ro   rl   z8
    The y-coordinates of the center of the annuli.
    r   z(
    The inner radii of the annuli.
    r   z(
    The outer radii of the annuli.
    z+
    The {prop} values for the annuli.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   rk   rl   r   r   r   r   r&   r}   r#   r~   r$   r   r   r   s   @rh   r7   r7     sD        
* * * * * * 9K6E
55:: - 		 		 		A 	
55:: - 		 		 		A  <n(=(= E 	 	 	L  <n(=(= E 	 	 	L  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   r7   c                  >    e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z e ed          d	          Z e ed          d	          Z eedd	          Z eed          Z xZS )r8   z Render arcs.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zArc.__init__>  ri   rj   z examples/reference/models/Arc.pyrk   rl   radiusr   r   r   rk   z6
    The x-coordinates of the center of the arcs.
    ro   rl   z6
    The y-coordinates of the center of the arcs.
    r   z
    Radius of the arc.
    r   zH
    The angles to start the arcs, as measured from the horizontal.
    r   zF
    The angles to end the arcs, as measured from the horizontal.
    r   r   z)
    The {prop} values for the arcs.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   rk   rl   r   r   r   r   r   r   r   r   r   r&   r}   r   r   s   @rh   r8   r8   8  sM        
* * * * * * 5KIE
55:: - 		 		 		A 	
55:: - 		 		 		A \%%// 9 	 	 	F )EE-$8$8 @ 	 	 	K 	%%"4"4 < 	 	 	I Y ; 	 	 	I  * 	 	 	JJJJJrj   r8   c                      e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z e ed          d	          Z e ed          d	          Z e ed          d	          Z e ed          d	          Z e ed          d	          Z eed          Z xZS )r9   z Render Bezier curves.

    For more information consult the `Wikipedia article for Bezier curve`_.

    .. _Wikipedia article for Bezier curve: http://en.wikipedia.org/wiki/Bezier_curve

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zBezier.__init__k  ri   rj   z#examples/reference/models/Bezier.py)x0y0x1y1cx0cy0cx1cy1r   3
    The x-coordinates of the starting points.
    ro   r   3
    The y-coordinates of the starting points.
    r   1
    The x-coordinates of the ending points.
    r   1
    The y-coordinates of the ending points.
    r   z4
    The x-coordinates of first control points.
    r   z4
    The y-coordinates of first control points.
    r   z5
    The x-coordinates of second control points.
    r   z5
    The y-coordinates of second control points.
    z2
    The {prop} values for the Bezier curves.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   r   r   r   r   r   r   r   r   r   r&   r}   r   r   s   @rh   r9   r9   a  s        * * * * * * 8K@E	EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B *UU5\\ 1 	 	 	C *UU5\\ 1 	 	 	C *UU5\\ 1 	 	 	C *UU5\\ 1 	 	 	C  * 	 	 	JJJJJrj   r9   c                      e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 edd	          Z edd	          Z eed          Z eed          Z eed          Z xZS )r:   zP Render rectangular regions, given a corner coordinate, width, and height.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zBlock.__init__  ri   rj   z"examples/reference/models/Block.py)rk   rl   widthheightrk   z9
    The x-coordinates of the centers of the blocks.
    ro   rl   z9
    The y-coordinates of the centers of the blocks.
    r+   z#
    The widths of the blocks.
    z$
    The heights of the blocks.
    z+
    The {prop} values for the blocks.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   rk   rl   r   r   r   r&   r}   r#   r~   r$   r   r   r   s   @rh   r:   r:     s.        
* * * * * * 7K)E
55:: - 		 		 		A 	
55:: - 		 		 		A Jq ( 	 	 	E Z ) 	 	 	F  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   r:   c                  v     e Zd ZdZd fdZdZdZ ed          Z e	 e
d	d
dd          d          Z xZS )r;   z Render circle markers. r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zCircle.__init__  ri   rj   z#examples/reference/models/Circle.pyrk   rl   a  
    The radius values for circle markers (in |data units|, by default).

    .. note::
        Circle markers are slightly unusual in that they support specifying
        a radius in addition to a size. Only one of ``radius`` or ``size``
        should be given.

    .. warning::
        Note that ``Circle`` glyphs are always drawn as circles on the screen,
        even in cases where the data space aspect ratio is not 1-1. In all
        cases where radius values are specified, the "distance" for the radius
        is measured along the dimension specified by ``radius_dimension``. If
        the aspect ratio is very large or small, the drawn circles may appear
        much larger or smaller than expected. See :bokeh-issue:`626` for more
        information.

    ru   rk   rl   maxmina  
    What dimension to measure circle radii along.

    When the data space aspect ratio is not 1-1, then the size of the drawn
    circles depends on what direction is used to measure the "distance" of
    the radius. This property allows that direction to be controlled.

    Setting this dimension to 'max' will calculate the radius on both the x
    and y dimensions and use the maximum of the two, 'min' selects the minimum.
    rv   )rw   rx   ry   rz   rb   r   r{   r   r   r   r	   radius_dimensionr   r   s   @rh   r;   r;     s        ""* * * * * * 8KE $ 	 	 	F& tKKS%?? 	G 		 		 		rj   r;   c                  D    e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z e ed          d	          Z edd	          Z eed          Z eed          Z eed          Z xZS )r<   z Render ellipses.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zEllipse.__init__  ri   rj   z$examples/reference/models/Ellipse.py)rk   rl   r   r   rn   rk   z;
    The x-coordinates of the centers of the ellipses.
    ro   rl   z;
    The y-coordinates of the centers of the ellipses.
    r   z%
    The widths of each ellipse.
    r   z&
    The heights of each ellipse.
    rt   zC
    The angle the ellipses are rotated from horizontal. [rad]
    z-
    The {prop} values for the ellipses.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   rk   rl   r   r   r   r   rn   r   r&   r}   r#   r~   r$   r   r   r   s   @rh   r<   r<     s]        
* * * * * * 9K2E
55:: - 		 		 		A 	
55:: - 		 		 		A Lw 7 	 	 	E \%%// 9 	 	 	F Ic ) 	 	 	E  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   r<   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z eed          Z eed          Z xZS )r=   z Render a horizontally directed area between two equal length sequences
    of x-coordinates with the same y-coordinates.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zHArea.__init__  ri   rj   z"examples/reference/models/HArea.pyr   x2rl   r   C
    The x-coordinates for the points of one side of the area.
    ro   r   I
    The x-coordinates for the points of the other side of the area.
    rl   7
    The y-coordinates for the points of the area.
    =
    The {prop} values for the horizontal directed area.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   r   r   rl   r   r'   r~   r$   r   r   r   s   @rh   r=   r=     s         * * * * * * 7KE	EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B 	
55:: - 		 		 		A  0 	 	 	J '* , 	 	 	KKKKKrj   r=   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z eedd	          Z eed          Z eed          Z xZS )r>   z Render a horizontally directed area between two equal length sequences
    of x-coordinates with the same y-coordinates using step lines.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zHAreaStep.__init__>  ri   rj   z&examples/reference/models/HAreaStep.pyr   r   r   ro   r   r   rl   r   beforea  
    Where the step "level" should be drawn in relation to the x and y
    coordinates. The parameter can assume one of three values:

    * ``before``: (default) Draw step levels before each y-coordinate (no step before the first point)
    * ``after``:  Draw step levels after each y-coordinate (no step after the last point)
    * ``center``: Draw step levels centered on each y-coordinate
    r   ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   r   r   rl   r   r   	step_moder   r'   r~   r$   r   r   r   s   @rh   r>   r>   7  s        * * * * * * ;KE	EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B 	
55:: - 		 		 		A Xx 7 	 	 	I  0 	 	 	J '* , 	 	 	KKKKKrj   r>   c                      e Zd ZdZd fdZdZdZ e ed          d	          Z	 ed
d	          Z
 edd	          Z e ed          d	          Z eed          Z eed          Z eed          Z xZS )r?   zo Render horizontal bars, given a center coordinate, ``height`` and
    (``left``, ``right``) coordinates.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zHBar.__init__i  ri   rj   z!examples/reference/models/HBar.py)rl   r   rightleftrl   zB
    The y-coordinates of the centers of the horizontal bars.
    ro   r+   z+
    The heights of the vertical bars.
    r   .
    The x-coordinates of the left edges.
    r   /
    The x-coordinates of the right edges.
    z4
    The {prop} values for the horizontal bars.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   rl   r   r   r   r   r&   r}   r#   r~   r$   r   r   r   s   @rh   r?   r?   b  s.        * * * * * * 6K,E
55:: - 		 		 		A Z ) 	 	 	F :a ' 	 	 	D JuuW~~ 5 	 	 	E  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   r?   c                  R    e Zd ZdZd fdZdZdZ edd	          Z edd
          Z	 e
 ed          d          Z e
 ed          d          Z e
dd	          Z edd          Z eed	          Z ed          Z eed	          Z eed	          Z xZS )rB   z; Render horizontal tiles on a regular hexagonal grid.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zHexTile.__init__  ri   rj   z$examples/reference/models/HexTile.py)qrrr   a  
    The radius (in |data units|) of the hex tiling.

    The radius is always measured along the cartesian y-axis for "pointy_top"
    orientation, and along the cartesian x-axis for "flat_top" orientation. If
    the aspect ratio of the underlying cartesian system is not 1-1, then the
    tiles may be "squished" in one direction. To ensure that the tiles are
    always regular hexagons, consider setting the ``match_aspect`` property of
    the plot to True.
    ru   z
    Match a plot's aspect ratio scaling.

    Use this parameter to match the aspect ratio scaling of a plot when using
    :class:`~bokeh.models.Plot.aspect_scale` with a value other than ``1.0``.

    ro   r   z:
    The "row" axial coordinates of the tile centers.
    r   z=
    The "column" axial coordinates of the tile centers.
    z.
    A scale factor for individual tiles.
    	pointytopz
    The orientation of the hex tiles.

    Use ``"pointytop"`` to orient the tile so that a pointed corner is at the top. Use
    ``"flattop"`` to orient the tile so that a flat side is at the top.
    z.
    The {prop} values for the hex tiles.
    Nrp   rv   )rw   rx   ry   rz   rb   r   r{   r   rm   aspect_scaler   r   r   r   scaler   orientationr   r&   r}   r   
line_colorr#   r~   r$   r   r   r   s   @rh   rB   rB     s~        
* * * * * * 9KE5 	 		 		 		D 5 , 	 	 	L 	
55:: - 		 		 		A 	
55:: - 		 		 		A Js " 	 	 	E & 4 	 	 	K  * 	 	 	J $'''J * 	 	 	J '* , 	 	 	KKKKKrj   rB   c                  :    e Zd Zd fdZ e ed          d          Z e ed          d          Z e ed	          d
          Z	 e ed          d          Z
 eed          Z edd          Z eedd          Z edd          Z xZS )	ImageBaser\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zImageBase.__init__  ri   rj   rk   8
    The x-coordinates to locate the image anchors.
    ro   rl   8
    The y-coordinates to locate the image anchors.
    dwz
    The widths of the plot regions that the images will occupy.

    .. note::
        This is not the number of pixels that an image is wide.
        That number is fixed by the image itself.
    dhz
    The height of the plot region that the image will occupy.

    .. note::
        This is not the number of pixels that an image is tall.
        That number is fixed by the image itself.
    z+
    The {prop} values for the images.
    ru   F
    Whether to always round fractional pixel locations in such a way
    as to make the images bigger.

    This setting may be useful if pixel rounding errors are causing
    images to have a gap between them, when they should appear flush.
    bottom_leftz3
    Defines the coordinate space of an image.
    O
    Position of the image should be anchored at the `x`, `y` coordinates.
    rv   )rw   rx   ry   rb   r   r   rk   rl   r   r   r   r   r%   image_propsr   dilater   r   originr   anchorr   r   s   @rh   r   r     sK       * * * * * * 	
55:: - 		 		 		A 	
55:: - 		 		 		A 
eeDkk 1 
	 
	 
	B 
eeDkk 1 
	 
	 
	B '* , 	 	 	K T%  	 	 	F T+} < 	 	 	F VM 1 	 	 	FFFFFrj   r   c                       e Zd ZdZd fdZdZddiZ e ed          d	
          Z	 e
e eed          d
                               ee          d           Z xZS )rC   a   Render images given as scalar data together with a color mapper.

    In addition to the defined model properties, ``Image`` also can accept
    a keyword argument ``palette`` in place of an explicit ``color_mapper``.
    The value should be a list of colors, or the name of one of the built-in
    palettes in ``bokeh.palettes``. This palette will be used to automatically
    construct a ``ColorMapper`` model for the ``color_mapper`` property.

    If both ``palette`` and ``color_mapper`` are passed, a ``ValueError``
    exception will be raised. If neither is passed, then the ``Greys9``
    palette will be used as a default.

    r\   r]   c                    d|v rd|v rt          d          d|vr*|                    dd          }t          |          }||d<    t                      j        |i | d S )Npalettecolor_mapperz9only one of 'palette' and 'color_mapper' may be specifiedGreys9)
ValueErrorpopr4   ra   rb   )rd   re   rf   r   mapperrg   s        rh   rb   zImage.__init__  s~    >V#;#;XYYY6))jjH55G&w//F%+F>"$)&)))))rj   imagerk   rl   r   r   r   r   )zstr or list[color value]zAa palette to construct a value for the color mapper property fromr   zE
    The arrays of scalar data for the images to be colormapped.
    ro   r   r   aL  
    A ``ColorMapper`` to use to map the scalar data from ``image``
    into RGBA values for display.

    The name of a palette from ``bokeh.palettes`` may also be set, in which
    case a ``LinearColorMapper`` configured with the named palette wil be used.

    .. note::
        The color mapping step happens on the client.
    c                "    t          |           S )Nr   )r4   )pals    rh   <lambda>zImage.<lambda>1  s    ,=c,J,J,J rj   rv   )rw   rx   ry   rz   rb   r{   
_extra_kwsr   r   r   r   r3   r   r4   acceptsr   r   r   r   r   s   @rh   rC   rC      s         	* 	* 	* 	* 	* 	* 6E 	 
J JuuW~~ 5 	 	 	E 8KAR\d1e1e1e 	m 		 		 		 
g J J	K	K LLLLrj   rC   c                  T     e Zd ZdZd	 fdZdZ e ed          d          Z xZ	S )
rD   z( Render images given as RGBA data.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zImageRGBA.__init__9  ri   rj   r   r   z1
    The arrays of RGBA data for the images.
    ro   rv   )
rw   rx   ry   rz   rb   r{   r   r   r   r   r   s   @rh   rD   rD   3  sg         
* * * * * * 6EJuuW~~ 5 	 	 	EEEEErj   rD   c                  n     e Zd ZdZd fdZdZ e ed          d          Z e	e
d	
          Z xZS )rE   a`   Render images given as 3D stacked arrays by flattening each stack into
    an RGBA image using a ``StackColorMapper``.

    The 3D arrays have shape (ny, nx, nstack) where ``nstack` is the number of
    stacks. The ``color_mapper`` produces an RGBA value for each of the
    (ny, nx) pixels by combining array values in the ``nstack`` direction.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zImageStack.__init__M  ri   rj   r   r   z/
    The 3D arrays of data for the images.
    ro   z
    ``ScalarColorMapper`` used to map the scalar data from ``image``
    into RGBA values for display.

    .. note::
        The color mapping step happens on the client.
    ru   rv   )rw   rx   ry   rz   rb   r{   r   r   r   r   r5   r   r   r   s   @rh   rE   rE   B  s         * * * * * * 6EJuuW~~ 5 	 	 	E 8, 4 	 	 	LLLLLrj   rE   c                  |    e Zd ZdZd fdZdZdZ e ed          d	          Z	 e
 ed
          d	          Z e
 ed          d	          Z ed          Z ed          Z edd	          Z e
dd          Z edd          Z edd	          Z edd          Z edd          Z xZS )rF   z, Render images loaded from given URLs.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zImageURL.__init__d  ri   rj   z%examples/reference/models/ImageURL.py)urlrk   rl   whrn   r   r   z
    The URLs to retrieve images from.

    .. note::
        The actual retrieving and loading of the images happens on
        the client.
    ro   rk   r   rl   r   z
    The width of the plot region that the image will occupy in data space.

    The default value is ``None``, in which case the image will be displayed
    at its actual image size (regardless of the units specified here).
    ru   z
    The height of the plot region that the image will occupy in data space.

    The default value is ``None``, in which case the image will be displayed
    at its actual image size (regardless of the units specified here).
    r   zK
    The angles to rotate the images, as measured from the horizontal.
    rr   z
    An overall opacity that each image is rendered with (in addition
    to any inherent alpha values in the image itself).
    Fr   top_leftr   ze
    Number of attempts to retry loading the images from the specified URL.
    Default is zero.
    zr
    Timeout (in ms) between retry attempts to load the image from the
    specified URL. Default is zero ms.
    rv   )rw   rx   ry   rz   rb   r   r{   r   r   r   r   rk   rl   r   r   r   r   rn   global_alphar   r   r   r   r   retry_attemptsretry_timeoutr   r   s   @rh   rF   rF   ^  s        
* * * * * * :K:E
*UU5\\ 1 	 	 	C 	
55:: - 		 		 		A 	
55:: - 		 		 		A 	  		 		 		A 	  		 		 		A Ia ' 	 	 	E :c ) 	 	 	L
 T%  	 	 	F VJ . 	 	 	F S " 	 	 	N
 C ! 	 	 	MMMMMrj   rF   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 eed          Z xZS )rG   a   Render a single line.

    The ``Line`` glyph is different from most other glyphs in that the vector
    of values only produces one glyph on the Plot.

    .. note::
        Due to limitations in the underlying HTML canvas, it is possible that a
        line is not drawn when one or more of its coordinates is very far outside
        the viewport. This behavior is different for different browsers. See
        :bokeh-issue:`11498` for more information.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zLine.__init__  ri   rj   r   z!examples/reference/models/Line.pyrk   z7
    The x-coordinates for the points of the line.
    ro   rl   z7
    The y-coordinates for the points of the line.
    z)
    The {prop} values for the line.
    ru   rv   )rw   rx   ry   rz   rb   r{   r   r   r   rk   rl   r   r)   r}   r   r   s   @rh   rG   rG     s         * * * * * * E5K
55:: - 		 		 		A 	
55:: - 		 		 		A  0 	 	 	JJJJJrj   rG   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 eed          Z xZS )rI   z Render several lines.

    The data for the ``MultiLine`` glyph is different in that the vector of
    values is not a vector of scalars. Rather, it is a "list of lists".

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zMultiLine.__init__  ri   rj   z&examples/reference/models/MultiLine.pyxsysr   zJ
    The x-coordinates for all the lines, given as a "list of lists".
    ro   r   zJ
    The y-coordinates for all the lines, given as a "list of lists".
    z*
    The {prop} values for the lines.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   r   r   r   r&   r}   r   r   s   @rh   rI   rI     s         * * * * * * ;KE	EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B  * 	 	 	JJJJJrj   rI   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 eed          Z eed          Z eed          Z xZS )rJ   aS   Render several MultiPolygon.

    Modeled on geoJSON - the data for the ``MultiPolygons`` glyph is
    different in that the vector of values is not a vector of scalars.
    Rather, it is a "list of lists of lists of lists".

    During box selection only multi-polygons entirely contained in the
    selection box will be included.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zMultiPolygons.__init__  ri   rj   z*examples/reference/models/MultiPolygons.pyr   r   a?  
    The x-coordinates for all the patches, given as a nested list.

    .. note::
        Each item in ``MultiPolygons`` represents one MultiPolygon and each
        MultiPolygon is comprised of ``n`` Polygons. Each Polygon is made of
        one exterior ring optionally followed by ``m`` interior rings (holes).
    ro   r   aC  
    The y-coordinates for all the patches, given as a "list of lists".

    .. note::
        Each item in ``MultiPolygons`` represents one MultiPolygon and each
        MultiPolygon is comprised of ``n`` Polygons. Each Polygon is made of
        one exterior ring optionally followed by ``m`` interior rings (holes).
    z2
    The {prop} values for the multipolygons.
    ru   rv   rw   rx   ry   rz   rb   r   r{   r   r   r   r   r   r&   r}   r#   r~   r$   r   r   r   s   @rh   rJ   rJ     s        	 	* * * * * * ?KE	EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   rJ   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 eed          Z eed          Z eed          Z xZS )rK   z Render a single patch.

    The ``Patch`` glyph is different from most other glyphs in that the vector
    of values only produces one glyph on the Plot.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zPatch.__init__!  ri   rj   z"examples/reference/models/Patch.pyr   rk   z
    The x-coordinates for the points of the patch.

    .. note::
        A patch may comprise multiple polygons. In this case the
        x-coordinates for each polygon should be separated by NaN
        values in the sequence.
    ro   rl   z
    The y-coordinates for the points of the patch.

    .. note::
        A patch may comprise multiple polygons. In this case the
        y-coordinates for each polygon should be separated by NaN
        values in the sequence.
    z*
    The {prop} values for the patch.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   rk   rl   r   r)   r}   r'   r~   r(   r   r   r   s   @rh   rK   rK     s         * * * * * * 7KE
55:: - 		 		 		A 	
55:: - 		 		 		A  0 	 	 	J  0 	 	 	J '* 2 	 	 	KKKKKrj   rK   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 eed          Z eed          Z eed          Z xZS )rL   a   Render several patches.

    The data for the ``Patches`` glyph is different in that the vector of
    values is not a vector of scalars. Rather, it is a "list of lists".

    During box selection only patches entirely contained in the
    selection box will be included.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zPatches.__init__R  ri   rj   z$examples/reference/models/Patches.pyr   r   a	  
    The x-coordinates for all the patches, given as a "list of lists".

    .. note::
        Individual patches may comprise multiple polygons. In this case
        the x-coordinates for each polygon should be separated by NaN
        values in the sublists.
    ro   r   a	  
    The y-coordinates for all the patches, given as a "list of lists".

    .. note::
        Individual patches may comprise multiple polygons. In this case
        the y-coordinates for each polygon should be separated by NaN
        values in the sublists.
    z,
    The {prop} values for the patches.
    ru   rv   r  r   s   @rh   rL   rL   F  s         * * * * * * 9KE	EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   rL   c                  *    e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z e ed          d	          Z eed          Z eed          Z eed          Z xZS )rM   z! Render axis-aligned quads.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zQuad.__init__}  ri   rj   z!examples/reference/models/Quad.py)r   r   topbottomr   r   ro   r   r   r	  0
    The y-coordinates of the bottom edges.
    r  -
    The y-coordinates of the top edges.
    z*
    The {prop} values for the quads.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   r   r   r	  r  r   r&   r}   r#   r~   r$   r   r   r   s   @rh   rM   rM   w  s>        
* * * * * * 6K.E:eeFmm 3 	 	 	D JuuW~~ 5 	 	 	E Zh 7 	 	 	F *UU5\\ 1 	 	 	C  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   rM   c                  N    e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z e ed          d	          Z e ed          d	          Z e ed          d	          Z eed          Z xZS )rN   z Render parabolas.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zQuadratic.__init__  ri   rj   z&examples/reference/models/Quadratic.py)r   r   r   r   cxcyr   r   ro   r   r   r   r   r   r   r  z2
    The x-coordinates of the control points.
    r  z2
    The y-coordinates of the control points.
    z.
    The {prop} values for the parabolas.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   r   r   r   r   r  r  r   r&   r}   r   r   s   @rh   rN   rN     sN        
* * * * * * ;K0E	EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B  * 	 	 	JJJJJrj   rN   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 edd	          Z edd	          Z eed          Z xZS )rO   z Render rays.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zRay.__init__  ri   rj   z examples/reference/models/Ray.py)rk   rl   lengthrn   rk   z.
    The x-coordinates to start the rays.
    ro   rl   z.
    The y-coordinates to start the rays.
    r   zT
    The angles in radians to extend the rays, as measured from the horizontal.
    z}
    The length to extend the ray. Note that this ``length`` defaults
    to |data units| (measured in the x-direction).
    z)
    The {prop} values for the rays.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   rk   rl   r   rn   r   r  r   r&   r}   r   r   s   @rh   rO   rO     s         
* * * * * * 5K)E
55:: - 		 		 		A 	
55:: - 		 		 		A Ia ' 	 	 	E \! + 	 	 	F
  * 	 	 	JJJJJrj   rO   c                  x    e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z e ed          d	          Z edd	          Z edd	          Z edd          Z eed          Z eed          Z eed          Z xZS )rP   a%   Render rectangles, characterised by center position (x and y), width,
    height, and angle of rotation.

    .. warning::
        ``Rect`` glyphs are not well defined on logarithmic scales. Use
        :class:`~bokeh.models.Block` or :class:`~bokeh.models.Quad` glyphs
        instead.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zRect.__init__  ri   rj   z!examples/reference/models/Rect.py)rk   rl   r   r   rn   r   rk   z=
    The x-coordinates of the centers of the rectangles.
    ro   rl   z=
    The y-coordinates of the centers of the rectangles.
    r   z/
    The overall widths of the rectangles.
    r   z0
    The overall heights of the rectangles.
    rt   zO
    The angles to rotate the rectangles, as measured from the horizontal.
    r   r   Fa  
    Whether to always round fractional pixel locations in such a way
    as to make the rectangles bigger.

    This setting may be useful if pixel rounding errors are causing
    rectangles to have a gap between them, when they should appear
    flush.
    ru   z/
    The {prop} values for the rectangles.
    rv   )rw   rx   ry   rz   rb   r   r{   r   r   rk   rl   r   r   r   r   rn   r    r   r   r   r   r&   r}   r#   r~   r$   r   r   r   s   @rh   rP   rP     s        * * * * * * 6K<E
55:: - 		 		 		A 	
55:: - 		 		 		A Lw 7 	 	 	E \%%// 9 	 	 	F Ic ) 	 	 	E !L 2 	 	 	M T%  	 	 	F  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   rP   c                  F     e Zd ZdZd
 fdZdZdZ edd	          Z xZ	S )rQ   a   Render scatter markers selected from a predefined list of designs.

    Use ``Scatter`` to draw any of Bokeh's built-in marker types:
    ``asterisk``, ``circle``, ``circle_cross``, ``circle_dot``, ``circle_x``,
    ``circle_y``, ``cross``, ``dash``, ``diamond``, ``diamond_cross``,
    ``diamond_dot``, ``dot``, ``hex``, ``hex_dot``, ``inverted_triangle``,
    ``plus``, ``square``, ``square_cross``, ``square_dot``, ``square_pin``,
    ``square_x``, ``star``, ``star_dot``, ``triangle``, ``triangle_dot``,
    ``triangle_pin``, ``x``, or ``y``. This collection is available in
    :class:`~bokeh.core.enums.MarkerType`.

    Bokeh's built-in markers consist of a set of base markers, most of which can
    be combined with different kinds of additional visual features:

    .. bokeh-plot:: __REPO__/examples/basic/scatters/markertypes.py
        :source-position: none

    You can select marker types in two ways:

    * To draw the **same marker for all values**, use the ``marker`` attribute
      to specify the name of a specific marker. For example:

      .. code-block:: python

          glyph = Scatter(x="x", y="y", size="sizes", marker="square")
          plot.add_glyph(source, glyph)

      This will render square markers for all points.

    * Alternatively, to use **marker types specified in a data source column**,
      assign the column name to the ``marker`` attribute. For example:

      .. code-block:: python

          # source.data['markers'] = ["circle", "square", "circle", ... ]

          glyph = Scatter(x="x", y="y", size="sizes", marker="markers")
          plot.add_glyph(source, glyph)

    .. note::
        When you draw ``circle`` markers with ``Scatter``, you can only assign a
        size in |screen units| (by passing a number of pixels to the ``size``
        property). In case you want to define the radius of circles in
        |data units|, use the :class:`~bokeh.models.glyphs.Circle` glyph instead
        of the ``Scatter`` glyph.

    .. note::
        ``Scatter`` markers with multiple marker types may be drawn in a
        different order when using the WebGL output backend. This is an explicit
        trade-off made in the interests of performance.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zScatter.__init__e  ri   rj   z$examples/reference/models/Scatter.py)rk   rl   rm   rn   markercirclez
    Which marker to render. This can be the name of any built in marker,
    e.g. "circle", or a reference to a data column containing such names.
    ro   rv   )
rw   rx   ry   rz   rb   r   r{   r   r  r   r   s   @rh   rQ   rQ   .  se        3 3l* * * * * * 9K1EZ 0 	 	 	FFFFFrj   rQ   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z e ed          d	          Z eed          Z xZS )rR   z Render segments.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zSegment.__init__w  ri   rj   z$examples/reference/models/Segment.py)r   r   r   r   r   r   ro   r   r   r   r   r   r   z-
    The {prop} values for the segments.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   r   r   r   r   r   r&   r}   r   r   s   @rh   rR   rR   q  s         
* * * * * * 9K$E	EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B  * 	 	 	JJJJJrj   rR   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 eed          Z eedd	          Z xZS )rS   a   Render step lines.

    Step levels can be draw before, after, or centered on each point, according
    to the value of the ``mode`` property.

    The x-coordinates are assumed to be (and must be) sorted in ascending order
    for steps to be properly rendered.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zStep.__init__  ri   rj   z!examples/reference/models/Step.pyr   rk   z*
    The x-coordinates for the steps.
    ro   rl   z*
    The y-coordinates for the steps.
    z*
    The {prop} values for the steps.
    ru   r     
    Where the step "level" should be drawn in relation to the x and y
    coordinates. The parameter can assume one of three values:

    * ``before``: (default) Draw step levels before each x-coordinate (no step before the first point)
    * ``after``:  Draw step levels after each x-coordinate (no step after the last point)
    * ``center``: Draw step levels centered on each x-coordinate
    rv   )rw   rx   ry   rz   rb   r   r{   r   r   rk   rl   r   r)   r}   r   r   moder   r   s   @rh   rS   rS     s         * * * * * * 6KE
55:: - 		 		 		A 	
55:: - 		 		 		A  0 	 	 	J 4( 2 	 	 	DDDDDrj   rS   c                      e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z edd	          Z edd	          Z edd	          Z ee ed          d	          Z edd	          Z edd	          Z eed          Z eedd          Z eedd          Z ee dd          Z! e"d          Z# e"d          Z$ e"d          Z% xZ&S )rT   z Render text.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zText.__init__  ri   rj   z!examples/reference/models/Text.py)rk   rl   textrn   x_offsety_offsetrk   z7
    The x-coordinates to locate the text anchors.
    ro   rl   z7
    The y-coordinates to locate the text anchors.
    r!  z$
    The text values to render.
    r   zI
    The angles to rotate the text, as measured from the horizontal.
    z
    Offset values in pixels to apply to the x-coordinates.

    This is useful, for instance, if it is desired to "float" text a fixed
    distance in |screen units| from a given data position.
    z
    Offset values in pixels to apply to the y-coordinates.

    This is useful, for instance, if it is desired to "float" text a fixed
    distance in |screen units| from a given data position.
    autoa  
    Position within the bounding box of this glyph to which ``x`` and ``y``
    coordinates are anchored to. This can be a named anchor point like
    ``top_left`` or ``center``, or a percentage from from left to right
    and top to bottom, or a combination of those, independently in width
    and height. If set to ``auto``, then anchor point will be determined
    from text ``align`` and ``baseline``.

    .. note::
        This property is experimental and may change at any point.
    z
    Extra space between the text of a glyphs and its bounding box (border).

    .. note::
        This property is experimental and may change at any point.
    z
    Allows the box to have rounded corners. For the best results, it
    should be used in combination with ``padding``.

    .. note::
        This property is experimental and may change at any point.
    z)
    The {prop} values for the text.
    ru   
backgroundz6
    The {prop} values for the text bounding box.
    )prefixrq   borderNr   rv   )'rw   rx   ry   rz   rb   r   r{   r   r   rk   rl   r   r!  r   rn   r"  r#  r   r"   r   r   r!   paddingr    r   r   r*   
text_propsr#   background_fill_propsr$   background_hatch_propsr&   border_line_propsr   background_fill_colorbackground_hatch_colorborder_line_colorr   r   s   @rh   rT   rT     sE        
* * * * * * 6K?E
55:: - 		 		 		A 	
55:: - 		 		 		A :eeFmm 3 	 	 	D Ia ' 	 	 	E z! + 	 	 	H z! + 	 	 	H Xj%%-- 
? 
	 
	 
	F ga ' 	 	 	G !L 2 	 	 	M  * 	 	 	J $GIl J 	 	 	 %WZ L 	 	 	  	( B 	 	 	 %HT222%Xd333 ...rj   rT   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z eed          Z eed          Z xZS )rU   z} Render a vertically directed area between two equal length sequences
    of y-coordinates with the same x-coordinates.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zVArea.__init__  ri   rj   z"examples/reference/models/VArea.pyrk   r   y2rk   7
    The x-coordinates for the points of the area.
    ro   r   C
    The y-coordinates for the points of one side of the area.
    r3  I
    The y-coordinates for the points of the other side of the area.
    ;
    The {prop} values for the vertical directed area.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   rk   r   r3  r   r'   r~   r$   r   r   r   s   @rh   rU   rU     s         * * * * * * 7KE
55:: - 		 		 		A 
EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B  0 	 	 	J '* , 	 	 	KKKKKrj   rU   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z eedd	          Z eed          Z eed          Z xZS )rV   z Render a vertically directed area between two equal length sequences
    of y-coordinates with the same x-coordinates using step lines.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zVAreaStep.__init__?  ri   rj   z&examples/reference/models/VAreaStep.pyr2  rk   r4  ro   r   r5  r3  r6  r   r  r7  ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   rk   r   r3  r   r   r   r   r'   r~   r$   r   r   r   s   @rh   rV   rV   8  s        * * * * * * ;KE
55:: - 		 		 		A 
EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B Xx 7 	 	 	I  0 	 	 	J '* , 	 	 	KKKKKrj   rV   c                      e Zd ZdZd fdZdZdZ e ed          d	          Z	 ed
d	          Z
 edd	          Z e ed          d	          Z eed          Z eed          Z eed          Z xZS )rW   z\ Render vertical bars, given a center coordinate, width and (top, bottom) coordinates.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zVBar.__init__i  ri   rj   z!examples/reference/models/VBar.py)rk   r   r  r	  rk   z@
    The x-coordinates of the centers of the vertical bars.
    ro   r+   z*
    The widths of the vertical bars.
    r   r
  r  r  z2
    The {prop} values for the vertical bars.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   rk   r   r	  r  r   r&   r}   r#   r~   r$   r   r   r   s   @rh   rW   rW   c  s.        
* * * * * * 6K+E
55:: - 		 		 		A Jq ( 	 	 	E Z ) 	 	 	F *UU5\\ 1 	 	 	C  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   rW   c                  r    e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 e ed          d	          Z e ed          d	          Z e ed          d	          Z eedd	          Z eed          Z eed          Z eed          Z xZS )rZ   z Render wedges.

    r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zWedge.__init__  ri   rj   z"examples/reference/models/Wedge.pyr   rk   z8
    The x-coordinates of the points of the wedges.
    ro   rl   z8
    The y-coordinates of the points of the wedges.
    r   z
    Radii of the wedges.
    r   zJ
    The angles to start the wedges, as measured from the horizontal.
    r   zH
    The angles to end the wedges, as measured from the horizontal.
    r   r   z+
    The {prop} values for the wedges.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   rk   rl   r   r   r   r   r   r   r   r   r   r&   r}   r#   r~   r$   r   r   r   s   @rh   rZ   rZ     s        
* * * * * * 7KIE
55:: - 		 		 		A 	
55:: - 		 		 		A \%%// 9 	 	 	F )EE-$8$8 @ 	 	 	K 	%%"4"4 < 	 	 	I Y ; 	 	 	I  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   rZ   c                  r     e Zd ZdZd fdZdZdZ e ed          d          Z	 e
ed	
          Z xZS )r@   z% Horizontal lines of infinite width. r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zHSpan.__init__  ri   rj   z"examples/reference/models/HSpan.pyrl   z)
    The y-coordinates of the spans.
    ro   *
    The {prop} values for the spans.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   rl   r   r&   r}   r   r   s   @rh   r@   r@     s        //* * * * * * 7KE
55:: - 		 		 		A  * 	 	 	JJJJJrj   r@   c                  r     e Zd ZdZd fdZdZdZ e ed          d          Z	 e
ed	
          Z xZS )rX   z$ Vertical lines of infinite height. r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zVSpan.__init__  ri   rj   z"examples/reference/models/VSpan.pyrk   z)
    The x-coordinates of the spans.
    ro   r@  ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   rk   r   r&   r}   r   r   s   @rh   rX   rX     s        ..* * * * * * 7KE
55:: - 		 		 		A  * 	 	 	JJJJJrj   rX   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 eed          Z eed          Z eed          Z xZS )rA   z& Horizontal strips of infinite width. r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zHStrip.__init__  ri   rj   z#examples/reference/models/HStrip.py)r   r   r   zI
    The y-coordinates of the coordinates of one side of the strips.
    ro   r   zO
    The y-coordinates of the coordinates of the other side of the strips.
    +
    The {prop} values for the strips.
    ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   r   r   r   r&   r}   r#   r~   r$   r   r   r   s   @rh   rA   rA     s        00* * * * * * 8KE	EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   rA   c                       e Zd ZdZd fdZdZdZ e ed          d	          Z	 e ed
          d	          Z
 eed          Z eed          Z eed          Z xZS )rY   z% Vertical strips of infinite height. r\   r]   c                :     t                      j        |i | d S r_   r`   rc   s      rh   rb   zVStrip.__init__  ri   rj   z#examples/reference/models/VStrip.py)r   r   r   zI
    The x-coordinates of the coordinates of one side of the strips.
    ro   r   zO
    The x-coordinates of the coordinates of the other side of the strips.
    rE  ru   rv   )rw   rx   ry   rz   rb   r   r{   r   r   r   r   r   r&   r}   r#   r~   r$   r   r   r   s   @rh   rY   rY     s        //* * * * * * 8KE	EE$KK / 
	 
	 
	B 
EE$KK / 
	 
	 
	B  * 	 	 	J  * 	 	 	J '* , 	 	 	KKKKKrj   rY   )frz   
__future__r   logging	getLoggerrw   log
core.enumsr   r   r   r   r	   core.has_propsr
   core.propertiesr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   core.property_aliasesr   r    r!   r"   core.property_mixinsr#   r$   r%   r&   r'   r(   r)   r*   glyphr,   r-   r.   r/   r0   r1   r2   mappersr3   r4   r5   __all__rH   r   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   rB   r   rC   rD   rE   rF   rG   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   rV   rW   rZ   r@   rX   rA   rY    rj   rh   <module>rU     s	   . # " " " " " g!!              & % % % % %                                           ,           	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	                  F E E E E E E E E E)^ 
4	 4	 4	 4	 4	WiJ 4	 4	 
4	l 
	 	 	 	 		9j 	 	 
	3	 3	 3	 3	 3	7Iy* 3	 3	 3	j'	 '	 '	 '	 '	gy)Z '	 '	 '	R'	 '	 '	 '	 '	'9 '	 '	 '	R3	 3	 3	 3	 3	Y 3	 3	 3	j'	 '	 '	 '	 '	I '	 '	 '	R'	 '	 '	 '	 '	V '	 '	 '	R+	 +	 +	 +	 +	gy)Z +	 +	 +	Z 	  	  	  	  	Iy*  	  	  	D)	 )	 )	 )	 )		: )	 )	 )	V(	 (	 (	 (	 (	9 (	 (	 (	T?	 ?	 ?	 ?	 ?	iJ ?	 ?	 ?	B 
0	 0	 0	 0	 0	 0	 0	 
0	d1L 1L 1L 1L 1LI 1L 1L 1Lf	 	 	 	 		 	 	 		 	 	 	 	 	 	 	8H	 H	 H	 H	 H	w H	 H	 H	T 	  	  	  	  	Y  	  	  	D	 	 	 	 		 	 	 	80	 0	 0	 0	 0	Iy* 0	 0	 0	d,	 ,	 ,	 ,	 ,	iJ ,	 ,	 ,	\/	 /	 /	 /	 /	iJ /	 /	 /	b'	 '	 '	 '	 '	9 '	 '	 '	R'	 '	 '	 '	 '		 '	 '	 '	R 	  	  	  	  	'9  	  	  	DA	 A	 A	 A	 A	7Iy* A	 A	 A	FA	 A	 A	 A	 A	f A	 A	 A	F	 	 	 	 	i 	 	 	B&	 &	 &	 &	 &	7I &	 &	 &	PZ/ Z/ Z/ Z/ Z/7I Z/ Z/ Z/x 	  	  	  	  	Iz  	  	  	D)	 )	 )	 )	 )		: )	 )	 )	V'	 '	 '	 '	 '	9 '	 '	 '	R/	 /	 /	 /	 /	GY	: /	 /	 /	b	 	 	 	 	I 	 	 	&	 	 	 	 	I 	 	 	&	 	 	 	 	Y	: 	 	 	>	 	 	 	 	Y	: 	 	 	 	 	rj   