neulab/docprompting-conala huggingface dataset:
draw_path(gc, tpath, affine, rgbFace=None)[source]
 
Draw a Path instance using the given affine transform.
draw_path_collection(gc, master_transform, paths, *args, **kwargs)[source]
 
Draw a collection of paths selecting drawing properties from the lists facecolors, edgecolors, linewidths, linestyles and antialiaseds. offsets is a list of offsets to apply to each of the paths. The offsets in offsets are first transformed by offsetTrans before being applied. offset_position is unused now, but the argument is kept for backwards compatibility. This provides a fallback implementation of draw_path_collection() that makes multiple calls to draw_path(). Some backends may want to override this in order to render each set of path data only once, and then reference that path multiple times with the different offsets, colors, styles etc. The generator methods _iter_collection_raw_paths() and _iter_collection() are provided to help with (and standardize) the implementation across backends. It is highly recommended to use those generators, so that changes to the behavior of draw_path_collection() can be made globally.
classmatplotlib.patheffects.PathPatchEffect(offset=(0, 0), **kwargs)[source]
 
Bases: matplotlib.patheffects.AbstractPathEffect Draws a PathPatch instance whose Path comes from the original PathEffect artist.  Parameters 
 
offset(float, float), default: (0, 0)


The (x, y) offset to apply to the path, in points.  **kwargs

All keyword arguments are passed through to the PathPatch constructor. The properties which cannot be overridden are "path", "clip_box" "transform" and "clip_path".       draw_path(renderer, gc, tpath, affine, rgbFace)[source]
 
Derived should override this method. The arguments are the same as matplotlib.backend_bases.RendererBase.draw_path() except the first argument is a renderer.
draw_path(renderer, gc, tpath, affine, rgbFace)[source]
 
Derived should override this method. The arguments are the same as matplotlib.backend_bases.RendererBase.draw_path() except the first argument is a renderer.
classmatplotlib.patheffects.SimpleLineShadow(offset=(2, - 2), shadow_color='k', alpha=0.3, rho=0.3, **kwargs)[source]
 
Bases: matplotlib.patheffects.AbstractPathEffect A simple shadow via a line.  Parameters 
 
offset(float, float), default: (2, -2)


The (x, y) offset to apply to the path, in points.  
shadow_colorcolor, default: 'black'


The shadow color. A value of None takes the original artist's color with a scale factor of rho.  
alphafloat, default: 0.3


The alpha transparency of the created shadow patch.  
rhofloat, default: 0.3


A scale factor to apply to the rgbFace color if shadow_color is None.  **kwargs

Extra keywords are stored and passed through to AbstractPathEffect._update_gc().       draw_path(renderer, gc, tpath, affine, rgbFace)[source]
 
Overrides the standard draw_path to add the shadow offset and necessary color changes for the shadow.
draw_path(renderer, gc, tpath, affine, rgbFace)[source]
 
Overrides the standard draw_path to add the shadow offset and necessary color changes for the shadow.
classmatplotlib.patheffects.SimplePatchShadow(offset=(2, - 2), shadow_rgbFace=None, alpha=None, rho=0.3, **kwargs)[source]
 
Bases: matplotlib.patheffects.AbstractPathEffect A simple shadow via a filled patch.  Parameters 
 
offset(float, float), default: (2, -2)


The (x, y) offset of the shadow in points.  
shadow_rgbFacecolor


The shadow color.  
alphafloat, default: 0.3


The alpha transparency of the created shadow patch. http://matplotlib.1069221.n5.nabble.com/path-effects-question-td27630.html  
rhofloat, default: 0.3


A scale factor to apply to the rgbFace color if shadow_rgbFace is not specified.  **kwargs

Extra keywords are stored and passed through to AbstractPathEffect._update_gc().       draw_path(renderer, gc, tpath, affine, rgbFace)[source]
 
Overrides the standard draw_path to add the shadow offset and necessary color changes for the shadow.
classmatplotlib.patheffects.Stroke(offset=(0, 0), **kwargs)[source]
 
Bases: matplotlib.patheffects.AbstractPathEffect A line based PathEffect which re-draws a stroke. The path will be stroked with its gc updated with the given keyword arguments, i.e., the keyword arguments should be valid gc parameter values.   draw_path(renderer, gc, tpath, affine, rgbFace)[source]
 
Draw the path with updated gc.
draw_path(renderer, gc, tpath, affine, rgbFace)[source]
 
Draw the path with updated gc.
classmatplotlib.patheffects.TickedStroke(offset=(0, 0), spacing=10.0, angle=45.0, length=1.4142135623730951, **kwargs)[source]
 
Bases: matplotlib.patheffects.AbstractPathEffect A line-based PathEffect which draws a path with a ticked style. This line style is frequently used to represent constraints in optimization. The ticks may be used to indicate that one side of the line is invalid or to represent a closed boundary of a domain (i.e. a wall or the edge of a pipe). The spacing, length, and angle of ticks can be controlled. This line style is sometimes referred to as a hatched line. See also the contour demo example. See also the contours in optimization example.  Parameters 
 
offset(float, float), default: (0, 0)


The (x, y) offset to apply to the path, in points.  
spacingfloat, default: 10.0


The spacing between ticks in points.  
anglefloat, default: 45.0


The angle between the path and the tick in degrees. The angle is measured as if you were an ant walking along the curve, with zero degrees pointing directly ahead, 90 to your left, -90 to your right, and 180 behind you.  
lengthfloat, default: 1.414


The length of the tick relative to spacing. Recommended length = 1.414 (sqrt(2)) when angle=45, length=1.0 when angle=90 and length=2.0 when angle=60.  **kwargs

Extra keywords are stored and passed through to AbstractPathEffect._update_gc().     Examples See TickedStroke patheffect.   draw_path(renderer, gc, tpath, affine, rgbFace)[source]
 
Draw the path with updated gc.
classmatplotlib.patheffects.withSimplePatchShadow(offset=(2, - 2), shadow_rgbFace=None, alpha=None, rho=0.3, **kwargs)[source]
 
Bases: matplotlib.patheffects.SimplePatchShadow A shortcut PathEffect for applying SimplePatchShadow and then drawing the original Artist. With this class you can use artist.set_path_effects([path_effects.withSimplePatchShadow()])
 as a shortcut for artist.set_path_effects([path_effects.SimplePatchShadow(),
                         path_effects.Normal()])
  Parameters 
 
offset(float, float), default: (2, -2)


The (x, y) offset of the shadow in points.  
shadow_rgbFacecolor


The shadow color.  
alphafloat, default: 0.3


The alpha transparency of the created shadow patch. http://matplotlib.1069221.n5.nabble.com/path-effects-question-td27630.html  
rhofloat, default: 0.3


A scale factor to apply to the rgbFace color if shadow_rgbFace is not specified.  **kwargs

Extra keywords are stored and passed through to AbstractPathEffect._update_gc().       draw_path(renderer, gc, tpath, affine, rgbFace)[source]
 
Overrides the standard draw_path to add the shadow offset and necessary color changes for the shadow.
classmatplotlib.patheffects.withStroke(offset=(0, 0), **kwargs)[source]
 
Bases: matplotlib.patheffects.Stroke A shortcut PathEffect for applying Stroke and then drawing the original Artist. With this class you can use artist.set_path_effects([path_effects.withStroke()])
 as a shortcut for artist.set_path_effects([path_effects.Stroke(),
                         path_effects.Normal()])
 The path will be stroked with its gc updated with the given keyword arguments, i.e., the keyword arguments should be valid gc parameter values.   draw_path(renderer, gc, tpath, affine, rgbFace)[source]
 
Draw the path with updated gc.
classmatplotlib.patheffects.withTickedStroke(offset=(0, 0), spacing=10.0, angle=45.0, length=1.4142135623730951, **kwargs)[source]
 
Bases: matplotlib.patheffects.TickedStroke A shortcut PathEffect for applying TickedStroke and then drawing the original Artist. With this class you can use artist.set_path_effects([path_effects.withTickedStroke()])
 as a shortcut for artist.set_path_effects([path_effects.TickedStroke(),
                         path_effects.Normal()])
  Parameters 
 
offset(float, float), default: (0, 0)


The (x, y) offset to apply to the path, in points.  
spacingfloat, default: 10.0


The spacing between ticks in points.  
anglefloat, default: 45.0


The angle between the path and the tick in degrees. The angle is measured as if you were an ant walking along the curve, with zero degrees pointing directly ahead, 90 to your left, -90 to your right, and 180 behind you.  
lengthfloat, default: 1.414


The length of the tick relative to spacing. Recommended length = 1.414 (sqrt(2)) when angle=45, length=1.0 when angle=90 and length=2.0 when angle=60.  **kwargs

Extra keywords are stored and passed through to AbstractPathEffect._update_gc().     Examples See TickedStroke patheffect.   draw_path(renderer, gc, tpath, affine, rgbFace)[source]
 
Draw the path with updated gc.
classAitoffTransform(resolution)[source]
 
Bases: matplotlib.projections.geo._GeoTransform The base Aitoff transform. Create a new geographical transform. Resolution is the number of steps to interpolate between each input line segment to approximate its path in curved space.   has_inverse=True
 
True if this transform has a corresponding inverse transform. 
   inverted()[source]
 
Return the corresponding inverse transformation. It holds x == self.inverted().transform(self.transform(x)). The return value of this method should be treated as temporary. An update to self does not cause a corresponding update to its inverted copy. 
   transform_non_affine(ll)[source]
 
Apply only the non-affine part of this transformation. transform(values) is always equivalent to transform_affine(transform_non_affine(values)). In non-affine transformations, this is generally equivalent to transform(values). In affine transformations, this is always a no-op.  Parameters 
 
valuesarray


The input values as NumPy array of length input_dims or shape (N x input_dims).    Returns 
 array

The output values as NumPy array of length input_dims or shape (N x output_dims), depending on the input.
inverted()[source]
 
Return the corresponding inverse transformation. It holds x == self.inverted().transform(self.transform(x)). The return value of this method should be treated as temporary. An update to self does not cause a corresponding update to its inverted copy.
transform_non_affine(ll)[source]
 
Apply only the non-affine part of this transformation. transform(values) is always equivalent to transform_affine(transform_non_affine(values)). In non-affine transformations, this is generally equivalent to transform(values). In affine transformations, this is always a no-op.  Parameters 
 
valuesarray


The input values as NumPy array of length input_dims or shape (N x input_dims).    Returns 
 array

The output values as NumPy array of length input_dims or shape (N x output_dims), depending on the input.
classInvertedAitoffTransform(resolution)[source]
 
Bases: matplotlib.projections.geo._GeoTransform Create a new geographical transform. Resolution is the number of steps to interpolate between each input line segment to approximate its path in curved space.   has_inverse=True
 
True if this transform has a corresponding inverse transform. 
   inverted()[source]
 
Return the corresponding inverse transformation. It holds x == self.inverted().transform(self.transform(x)). The return value of this method should be treated as temporary. An update to self does not cause a corresponding update to its inverted copy. 
   transform_non_affine(xy)[source]
 
Apply only the non-affine part of this transformation. transform(values) is always equivalent to transform_affine(transform_non_affine(values)). In non-affine transformations, this is generally equivalent to transform(values). In affine transformations, this is always a no-op.  Parameters 
 
valuesarray


The input values as NumPy array of length input_dims or shape (N x input_dims).    Returns 
 array

The output values as NumPy array of length input_dims or shape (N x output_dims), depending on the input.
transform_non_affine(xy)[source]
 
Apply only the non-affine part of this transformation. transform(values) is always equivalent to transform_affine(transform_non_affine(values)). In non-affine transformations, this is generally equivalent to transform(values). In affine transformations, this is always a no-op.  Parameters 
 
valuesarray


The input values as NumPy array of length input_dims or shape (N x input_dims).    Returns 
 array

The output values as NumPy array of length input_dims or shape (N x output_dims), depending on the input.
set(*, adjustable=<UNSET>, agg_filter=<UNSET>, alpha=<UNSET>, anchor=<UNSET>, animated=<UNSET>, aspect=<UNSET>, autoscale_on=<UNSET>, autoscalex_on=<UNSET>, autoscaley_on=<UNSET>, axes_locator=<UNSET>, axisbelow=<UNSET>, box_aspect=<UNSET>, clip_box=<UNSET>, clip_on=<UNSET>, clip_path=<UNSET>, facecolor=<UNSET>, frame_on=<UNSET>, gid=<UNSET>, in_layout=<UNSET>, label=<UNSET>, latitude_grid=<UNSET>, longitude_grid=<UNSET>, longitude_grid_ends=<UNSET>, navigate=<UNSET>, path_effects=<UNSET>, picker=<UNSET>, position=<UNSET>, prop_cycle=<UNSET>, rasterization_zorder=<UNSET>, rasterized=<UNSET>, sketch_params=<UNSET>, snap=<UNSET>, title=<UNSET>, transform=<UNSET>, url=<UNSET>, visible=<UNSET>, xbound=<UNSET>, xlabel=<UNSET>, xlim=<UNSET>, xmargin=<UNSET>, xscale=<UNSET>, xticklabels=<UNSET>, xticks=<UNSET>, ybound=<UNSET>, ylabel=<UNSET>, ylim=<UNSET>, ymargin=<UNSET>, yscale=<UNSET>, yticklabels=<UNSET>, yticks=<UNSET>, zorder=<UNSET>)[source]
 
Set multiple properties at once. Supported properties are   
Property Description   
adjustable {'box', 'datalim'}  
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array  
alpha scalar or None  
anchor (float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', ...}  
animated bool  
aspect {'auto', 'equal'} or float  
autoscale_on bool  
autoscalex_on bool  
autoscaley_on bool  
axes_locator Callable[[Axes, Renderer], Bbox]  
axisbelow bool or 'line'  
box_aspect float or None  
clip_box Bbox  
clip_on bool  
clip_path Patch or (Path, Transform) or None  
facecolor or fc color  
figure Figure  
frame_on bool  
gid str  
in_layout bool  
label object  
latitude_grid unknown  
longitude_grid unknown  
longitude_grid_ends unknown  
navigate bool  
navigate_mode unknown  
path_effects AbstractPathEffect  
picker None or bool or float or callable  
position [left, bottom, width, height] or Bbox  
prop_cycle unknown  
rasterization_zorder float or None  
rasterized bool  
sketch_params (scale: float, length: float, randomness: float)  
snap bool or None  
title str  
transform Transform  
url str  
visible bool  
xbound unknown  
xlabel str  
xlim unknown  
xmargin float greater than -0.5  
xscale unknown  
xticklabels unknown  
xticks unknown  
ybound unknown  
ylabel str  
ylim unknown  
ymargin float greater than -0.5  
yscale unknown  
yticklabels unknown  
yticks unknown  
zorder float
can_pan()[source]
 
Return whether this axes supports the pan/zoom button functionality. This axes object does not support interactive pan/zoom.
can_zoom()[source]
 
Return whether this axes supports the zoom box button functionality. This axes object does not support interactive zoom box.
drag_pan(button, key, x, y)[source]
 
Called when the mouse moves during a pan operation.  Parameters 
 
buttonMouseButton


The pressed mouse button.  
keystr or None


The pressed key, if any.  
x, yfloat


The mouse coordinates in display coords.     Notes This is intended to be overridden by new projection types.
end_pan()[source]
 
Called when a pan operation completes (when the mouse button is up.) Notes This is intended to be overridden by new projection types.
format_coord(lon, lat)[source]
 
Return a format string formatting the coordinate.
get_xaxis_text1_transform(pad)[source]
 
 Returns 
 
transformTransform


The transform used for drawing x-axis labels, which will add pad_points of padding (in points) between the axis and the label. The x-direction is in data coordinates and the y-direction is in axis coordinates  
valign{'center', 'top', 'bottom', 'baseline', 'center_baseline'}


The text vertical alignment.  
halign{'center', 'left', 'right'}


The text horizontal alignment.     Notes This transformation is primarily used by the Axis class, and is meant to be overridden by new kinds of projections that may need to place axis elements in different locations.
get_xaxis_text2_transform(pad)[source]
 
 Returns 
 
transformTransform


The transform used for drawing secondary x-axis labels, which will add pad_points of padding (in points) between the axis and the label. The x-direction is in data coordinates and the y-direction is in axis coordinates  
valign{'center', 'top', 'bottom', 'baseline', 'center_baseline'}


The text vertical alignment.  
halign{'center', 'left', 'right'}


The text horizontal alignment.     Notes This transformation is primarily used by the Axis class, and is meant to be overridden by new kinds of projections that may need to place axis elements in different locations.
get_xaxis_transform(which='grid')[source]
 
Get the transformation used for drawing x-axis labels, ticks and gridlines. The x-direction is in data coordinates and the y-direction is in axis coordinates.  Note This transformation is primarily used by the Axis class, and is meant to be overridden by new kinds of projections that may need to place axis elements in different locations.
get_yaxis_text1_transform(pad)[source]
 
 Returns 
 
transformTransform


The transform used for drawing y-axis labels, which will add pad_points of padding (in points) between the axis and the label. The x-direction is in axis coordinates and the y-direction is in data coordinates  
valign{'center', 'top', 'bottom', 'baseline', 'center_baseline'}


The text vertical alignment.  
halign{'center', 'left', 'right'}


The text horizontal alignment.     Notes This transformation is primarily used by the Axis class, and is meant to be overridden by new kinds of projections that may need to place axis elements in different locations.
get_yaxis_text2_transform(pad)[source]
 
 Returns 
 
transformTransform


The transform used for drawing secondart y-axis labels, which will add pad_points of padding (in points) between the axis and the label. The x-direction is in axis coordinates and the y-direction is in data coordinates  
valign{'center', 'top', 'bottom', 'baseline', 'center_baseline'}


The text vertical alignment.  
halign{'center', 'left', 'right'}


The text horizontal alignment.     Notes This transformation is primarily used by the Axis class, and is meant to be overridden by new kinds of projections that may need to place axis elements in different locations.
get_yaxis_transform(which='grid')[source]
 
Get the transformation used for drawing y-axis labels, ticks and gridlines. The x-direction is in axis coordinates and the y-direction is in data coordinates.  Note This transformation is primarily used by the Axis class, and is meant to be overridden by new kinds of projections that may need to place axis elements in different locations.
set_latitude_grid(degrees)[source]
 
Set the number of degrees between each latitude grid.
set_longitude_grid(degrees)[source]
 
Set the number of degrees between each longitude grid.
set_longitude_grid_ends(degrees)[source]
 
Set the latitude(s) at which to stop drawing the longitude grids.
set_xlim(*args, **kwargs)[source]
 
Not supported. Please consider using Cartopy.
set_xscale(*args, **kwargs)[source]
 
Set the x-axis scale.  Parameters 
 
value{"linear", "log", "symlog", "logit", ...} or ScaleBase


The axis scale type to apply.  **kwargs

Different keyword arguments are accepted, depending on the scale. See the respective class keyword arguments:  matplotlib.scale.LinearScale matplotlib.scale.LogScale matplotlib.scale.SymmetricalLogScale matplotlib.scale.LogitScale matplotlib.scale.FuncScale      Notes By default, Matplotlib supports the above mentioned scales. Additionally, custom scales may be registered using matplotlib.scale.register_scale. These scales can then also be used here.
set_ylim(*args, **kwargs)[source]
 
Not supported. Please consider using Cartopy.
set_yscale(*args, **kwargs)[source]
 
Set the y-axis scale.  Parameters 
 
value{"linear", "log", "symlog", "logit", ...} or ScaleBase


The axis scale type to apply.  **kwargs

Different keyword arguments are accepted, depending on the scale. See the respective class keyword arguments:  matplotlib.scale.LinearScale matplotlib.scale.LogScale matplotlib.scale.SymmetricalLogScale matplotlib.scale.LogitScale matplotlib.scale.FuncScale      Notes By default, Matplotlib supports the above mentioned scales. Additionally, custom scales may be registered using matplotlib.scale.register_scale. These scales can then also be used here.
start_pan(x, y, button)[source]
 
Called when a pan operation has started.  Parameters 
 
x, yfloat


The mouse coordinates in display coords.  
buttonMouseButton


The pressed mouse button.     Notes This is intended to be overridden by new projection types.
classThetaFormatter(round_to=1.0)[source]
 
Bases: matplotlib.ticker.Formatter Used to format the theta tick labels. Converts the native unit of radians into degrees and adds a degree symbol.
classHammerTransform(resolution)[source]
 
Bases: matplotlib.projections.geo._GeoTransform The base Hammer transform. Create a new geographical transform. Resolution is the number of steps to interpolate between each input line segment to approximate its path in curved space.   has_inverse=True
 
True if this transform has a corresponding inverse transform. 
   inverted()[source]
 
Return the corresponding inverse transformation. It holds x == self.inverted().transform(self.transform(x)). The return value of this method should be treated as temporary. An update to self does not cause a corresponding update to its inverted copy. 
   transform_non_affine(ll)[source]
 
Apply only the non-affine part of this transformation. transform(values) is always equivalent to transform_affine(transform_non_affine(values)). In non-affine transformations, this is generally equivalent to transform(values). In affine transformations, this is always a no-op.  Parameters 
 
valuesarray


The input values as NumPy array of length input_dims or shape (N x input_dims).    Returns 
 array

The output values as NumPy array of length input_dims or shape (N x output_dims), depending on the input.
classInvertedHammerTransform(resolution)[source]
 
Bases: matplotlib.projections.geo._GeoTransform Create a new geographical transform. Resolution is the number of steps to interpolate between each input line segment to approximate its path in curved space.   has_inverse=True
 
True if this transform has a corresponding inverse transform. 
   inverted()[source]
 
Return the corresponding inverse transformation. It holds x == self.inverted().transform(self.transform(x)). The return value of this method should be treated as temporary. An update to self does not cause a corresponding update to its inverted copy. 
   transform_non_affine(xy)[source]
 
Apply only the non-affine part of this transformation. transform(values) is always equivalent to transform_affine(transform_non_affine(values)). In non-affine transformations, this is generally equivalent to transform(values). In affine transformations, this is always a no-op.  Parameters 
 
valuesarray


The input values as NumPy array of length input_dims or shape (N x input_dims).    Returns 
 array

The output values as NumPy array of length input_dims or shape (N x output_dims), depending on the input.