neulab/docprompting-conala huggingface dataset:
classmatplotlib.transforms.CompositeAffine2D(a, b, **kwargs)[source]
 
Bases: matplotlib.transforms.Affine2DBase A composite transform formed by applying transform a then transform b. This version is an optimization that handles the case where both a and b are 2D affines. Create a new composite transform that is the result of applying Affine2DBase a then Affine2DBase b. You will generally not call this constructor directly but write a +
b instead, which will automatically choose the best kind of composite transform instance to create.   __init__(a, b, **kwargs)[source]
 
Create a new composite transform that is the result of applying Affine2DBase a then Affine2DBase b. You will generally not call this constructor directly but write a +
b instead, which will automatically choose the best kind of composite transform instance to create. 
   __module__='matplotlib.transforms'

   __str__()[source]
 
Return str(self). 
   propertydepth
 
Return the number of transforms which have been chained together to form this Transform instance.  Note For the special case of a Composite transform, the maximum depth of the two is returned.  
   get_matrix()[source]
 
Get the matrix for the affine part of this transform.
__init__(a, b, **kwargs)[source]
 
Create a new composite transform that is the result of applying Affine2DBase a then Affine2DBase b. You will generally not call this constructor directly but write a +
b instead, which will automatically choose the best kind of composite transform instance to create.
__init__(a, b, **kwargs)[source]
 
Create a new composite transform that is the result of applying transform a then transform b. You will generally not call this constructor directly but write a +
b instead, which will automatically choose the best kind of composite transform instance to create.
transform(points)[source]
 
Apply this transformation on the given array of values.  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.
matplotlib.transforms.interval_contains(interval, val)[source]
 
Check, inclusively, whether an interval includes a given value.  Parameters 
 
interval(float, float)


The endpoints of the interval.  
valfloat


Value to check is within interval.    Returns 
 bool

Whether val is within the interval.
matplotlib.transforms.interval_contains_open(interval, val)[source]
 
Check, excluding endpoints, whether an interval includes a given value.  Parameters 
 
interval(float, float)


The endpoints of the interval.  
valfloat


Value to check is within interval.    Returns 
 bool

Whether val is within the interval.
classmatplotlib.transforms.LockableBbox(bbox, x0=None, y0=None, x1=None, y1=None, **kwargs)[source]
 
Bases: matplotlib.transforms.BboxBase A Bbox where some elements may be locked at certain values. When the child bounding box changes, the bounds of this bbox will update accordingly with the exception of the locked elements.  Parameters 
 
bboxBbox


The child bounding box to wrap.  
x0float or None


The locked value for x0, or None to leave unlocked.  
y0float or None


The locked value for y0, or None to leave unlocked.  
x1float or None


The locked value for x1, or None to leave unlocked.  
y1float or None


The locked value for y1, or None to leave unlocked.       __init__(bbox, x0=None, y0=None, x1=None, y1=None, **kwargs)[source]
 
 Parameters 
 
bboxBbox


The child bounding box to wrap.  
x0float or None


The locked value for x0, or None to leave unlocked.  
y0float or None


The locked value for y0, or None to leave unlocked.  
x1float or None


The locked value for x1, or None to leave unlocked.  
y1float or None


The locked value for y1, or None to leave unlocked.     
   __module__='matplotlib.transforms'

   __str__()[source]
 
Return str(self). 
   get_points()[source]

   propertylocked_x0
 
float or None: The value used for the locked x0. 
   propertylocked_x1
 
float or None: The value used for the locked x1. 
   propertylocked_y0
 
float or None: The value used for the locked y0. 
   propertylocked_y1
 
float or None: The value used for the locked y1.
__init__(bbox, x0=None, y0=None, x1=None, y1=None, **kwargs)[source]
 
 Parameters 
 
bboxBbox


The child bounding box to wrap.  
x0float or None


The locked value for x0, or None to leave unlocked.  
y0float or None


The locked value for y0, or None to leave unlocked.  
x1float or None


The locked value for x1, or None to leave unlocked.  
y1float or None


The locked value for y1, or None to leave unlocked.
matplotlib.transforms.nonsingular(vmin, vmax, expander=0.001, tiny=1e-15, increasing=True)[source]
 
Modify the endpoints of a range as needed to avoid singularities.  Parameters 
 
vmin, vmaxfloat


The initial endpoints.  
expanderfloat, default: 0.001


Fractional amount by which vmin and vmax are expanded if the original interval is too small, based on tiny.  
tinyfloat, default: 1e-15


Threshold for the ratio of the interval to the maximum absolute value of its endpoints. If the interval is smaller than this, it will be expanded. This value should be around 1e-15 or larger; otherwise the interval will be approaching the double precision resolution limit.  
increasingbool, default: True


If True, swap vmin, vmax if vmin > vmax.    Returns 
 
vmin, vmaxfloat


Endpoints, expanded and/or swapped if necessary. If either input is inf or NaN, or if both inputs are 0 or very close to zero, it returns -expander, expander.
matplotlib.transforms.offset_copy(trans, fig=None, x=0.0, y=0.0, units='inches')[source]
 
Return a new transform with an added offset.  Parameters 
 
transTransform subclass


Any transform, to which offset will be applied.  
figFigure, default: None


Current figure. It can be None if units are 'dots'.  
x, yfloat, default: 0.0


The offset to apply.  
units{'inches', 'points', 'dots'}, default: 'inches'


Units of the offset.    Returns 
 
Transform subclass

Transform with applied offset.
classmatplotlib.transforms.ScaledTranslation(xt, yt, scale_trans, **kwargs)[source]
 
Bases: matplotlib.transforms.Affine2DBase A transformation that translates by xt and yt, after xt and yt have been transformed by scale_trans.  Parameters 
 
shorthand_namestr


A string representing the "name" of the transform. The name carries no significance other than to improve the readability of str(transform) when DEBUG=True.       __init__(xt, yt, scale_trans, **kwargs)[source]
 
 Parameters 
 
shorthand_namestr


A string representing the "name" of the transform. The name carries no significance other than to improve the readability of str(transform) when DEBUG=True.     
   __module__='matplotlib.transforms'

   __str__()[source]
 
Return str(self). 
   get_matrix()[source]
 
Get the matrix for the affine part of this transform.
__init__(xt, yt, scale_trans, **kwargs)[source]
 
 Parameters 
 
shorthand_namestr


A string representing the "name" of the transform. The name carries no significance other than to improve the readability of str(transform) when DEBUG=True.
__add__(other)[source]
 
Compose two transforms together so that self is followed by other. A + B returns a transform C so that C.transform(x) == B.transform(A.transform(x)).
classmethod__init_subclass__()[source]
 
This method is called when a class is subclassed. The default implementation does nothing. It may be overridden to extend subclasses.
__sub__(other)[source]
 
Compose self with the inverse of other, cancelling identical terms if any: # In general:
A - B == A + B.inverted()
# (but see note regarding frozen transforms below).

# If A "ends with" B (i.e. A == A' + B for some A') we can cancel
# out B:
(A' + B) - B == A'

# Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
A - (A + B') == B'.inverted() == B'^-1
 Cancellation (rather than naively returning A + B.inverted()) is important for multiple reasons:  It avoids floating-point inaccuracies when computing the inverse of B: B - B is guaranteed to cancel out exactly (resulting in the identity transform), whereas B + B.inverted() may differ by a small epsilon. 
B.inverted() always returns a frozen transform: if one computes A + B + B.inverted() and later mutates B, then B.inverted() won't be updated and the last two terms won't cancel out anymore; on the other hand, A + B - B will always be equal to A even if B is mutated.
contains_branch_seperately(other_transform)[source]
 
Return whether the given branch is a sub-tree of this transform on each separate dimension. A common use for this method is to identify if a transform is a blended transform containing an axes' data transform. e.g.: x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
input_dims=None
 
The number of input dimensions of this transform. Must be overridden (with integers) in the subclass.
is_separable=False
 
True if this transform is separable in the x- and y- dimensions.
output_dims=None
 
The number of output dimensions of this transform. Must be overridden (with integers) in the subclass.
transform_angles(angles, pts, radians=False, pushoff=1e-05)[source]
 
Transform a set of angles anchored at specific locations.  Parameters 
 
angles(N,) array-like


The angles to transform.  
pts(N, 2) array-like


The points where the angles are anchored.  
radiansbool, default: False


Whether angles are radians or degrees.  
pushofffloat


For each point in pts and angle in angles, the transformed angle is computed by transforming a segment of length pushoff starting at that point and making that angle relative to the horizontal axis, and measuring the angle between the horizontal axis and the transformed segment.    Returns 
 (N,) array
transform_bbox(bbox)[source]
 
Transform the given bounding box. For smarter transforms including caching (a common requirement in Matplotlib), see TransformedBbox.
transform_point(point)[source]
 
Return a transformed point. This function is only kept for backcompatibility; the more general transform method is capable of transforming both a list of points and a single point. The point is given as a sequence of length input_dims. The transformed point is returned as a sequence of length output_dims.
classmatplotlib.transforms.TransformedBbox(bbox, transform, **kwargs)[source]
 
Bases: matplotlib.transforms.BboxBase A Bbox that is automatically transformed by a given transform. When either the child bounding box or transform changes, the bounds of this bbox will update accordingly.  Parameters 
 
bboxBbox


transformTransform

     __init__(bbox, transform, **kwargs)[source]
 
 Parameters 
 
bboxBbox


transformTransform

   
   __module__='matplotlib.transforms'

   __str__()[source]
 
Return str(self). 
   get_points()[source]
__init__(bbox, transform, **kwargs)[source]
 
 Parameters 
 
bboxBbox


transformTransform
classmatplotlib.transforms.TransformedPatchPath(patch)[source]
 
Bases: matplotlib.transforms.TransformedPath A TransformedPatchPath caches a non-affine transformed copy of the Patch. This cached copy is automatically updated when the non-affine part of the transform or the patch changes.  Parameters 
 
patchPatch

     __init__(patch)[source]
 
 Parameters 
 
patchPatch

   
   __module__='matplotlib.transforms'
classmatplotlib.transforms.TransformedPath(path, transform)[source]
 
Bases: matplotlib.transforms.TransformNode A TransformedPath caches a non-affine transformed copy of the Path. This cached copy is automatically updated when the non-affine part of the transform changes.  Note Paths are considered immutable by this class. Any update to the path's vertices/codes will not trigger a transform recomputation.   Parameters 
 
pathPath


transformTransform

     __init__(path, transform)[source]
 
 Parameters 
 
pathPath


transformTransform

   
   __module__='matplotlib.transforms'

   get_affine()[source]

   get_fully_transformed_path()[source]
 
Return a fully-transformed copy of the child path. 
   get_transformed_path_and_affine()[source]
 
Return a copy of the child path, with the non-affine part of the transform already applied, along with the affine part of the path necessary to complete the transformation. 
   get_transformed_points_and_affine()[source]
 
Return a copy of the child path, with the non-affine part of the transform already applied, along with the affine part of the path necessary to complete the transformation. Unlike get_transformed_path_and_affine(), no interpolation will be performed.
__init__(path, transform)[source]
 
 Parameters 
 
pathPath


transformTransform
get_fully_transformed_path()[source]
 
Return a fully-transformed copy of the child path.
get_transformed_path_and_affine()[source]
 
Return a copy of the child path, with the non-affine part of the transform already applied, along with the affine part of the path necessary to complete the transformation.
get_transformed_points_and_affine()[source]
 
Return a copy of the child path, with the non-affine part of the transform already applied, along with the affine part of the path necessary to complete the transformation. Unlike get_transformed_path_and_affine(), no interpolation will be performed.
classmatplotlib.transforms.TransformNode(shorthand_name=None)[source]
 
Bases: object The base class for anything that participates in the transform tree and needs to invalidate its parents or be invalidated. This includes classes that are not really transforms, such as bounding boxes, since some transforms depend on bounding boxes to compute their values.  Parameters 
 
shorthand_namestr


A string representing the "name" of the transform. The name carries no significance other than to improve the readability of str(transform) when DEBUG=True.       INVALID=3

   INVALID_AFFINE=2

   INVALID_NON_AFFINE=1

   __copy__()[source]

   __deepcopy__(memo)[source]

   __dict__=mappingproxy({'__module__': 'matplotlib.transforms', '__doc__': '\n The base class for anything that participates in the transform tree\n and needs to invalidate its parents or be invalidated. This includes\n classes that are not really transforms, such as bounding boxes, since some\n transforms depend on bounding boxes to compute their values.\n ', 'INVALID_NON_AFFINE': 1, 'INVALID_AFFINE': 2, 'INVALID': 3, 'is_affine': False, 'is_bbox': False, 'pass_through': False, '__init__': <function TransformNode.__init__>, '__getstate__': <function TransformNode.__getstate__>, '__setstate__': <function TransformNode.__setstate__>, '__copy__': <function TransformNode.__copy__>, '__deepcopy__': <function TransformNode.__deepcopy__>, 'invalidate': <function TransformNode.invalidate>, '_invalidate_internal': <function TransformNode._invalidate_internal>, 'set_children': <function TransformNode.set_children>, 'frozen': <function TransformNode.frozen>, '__dict__': <attribute '__dict__' of 'TransformNode' objects>, '__weakref__': <attribute '__weakref__' of 'TransformNode' objects>, '__annotations__': {}})

   __getstate__()[source]

   __init__(shorthand_name=None)[source]
 
 Parameters 
 
shorthand_namestr


A string representing the "name" of the transform. The name carries no significance other than to improve the readability of str(transform) when DEBUG=True.     
   __module__='matplotlib.transforms'

   __setstate__(data_dict)[source]

   __weakref__
 
list of weak references to the object (if defined) 
   frozen()[source]
 
Return a frozen copy of this transform node. The frozen copy will not be updated when its children change. Useful for storing a previously known state of a transform where copy.deepcopy() might normally be used. 
   invalidate()[source]
 
Invalidate this TransformNode and triggers an invalidation of its ancestors. Should be called any time the transform changes. 
   is_affine=False

   is_bbox=False

   pass_through=False
 
If pass_through is True, all ancestors will always be invalidated, even if 'self' is already invalid. 
   set_children(*children)[source]
 
Set the children of the transform, to let the invalidation system know which transforms can invalidate this transform. Should be called from the constructor of any transforms that depend on other transforms.
__dict__=mappingproxy({'__module__': 'matplotlib.transforms', '__doc__': '\n The base class for anything that participates in the transform tree\n and needs to invalidate its parents or be invalidated. This includes\n classes that are not really transforms, such as bounding boxes, since some\n transforms depend on bounding boxes to compute their values.\n ', 'INVALID_NON_AFFINE': 1, 'INVALID_AFFINE': 2, 'INVALID': 3, 'is_affine': False, 'is_bbox': False, 'pass_through': False, '__init__': <function TransformNode.__init__>, '__getstate__': <function TransformNode.__getstate__>, '__setstate__': <function TransformNode.__setstate__>, '__copy__': <function TransformNode.__copy__>, '__deepcopy__': <function TransformNode.__deepcopy__>, 'invalidate': <function TransformNode.invalidate>, '_invalidate_internal': <function TransformNode._invalidate_internal>, 'set_children': <function TransformNode.set_children>, 'frozen': <function TransformNode.frozen>, '__dict__': <attribute '__dict__' of 'TransformNode' objects>, '__weakref__': <attribute '__weakref__' of 'TransformNode' objects>, '__annotations__': {}})
__init__(shorthand_name=None)[source]
 
 Parameters 
 
shorthand_namestr


A string representing the "name" of the transform. The name carries no significance other than to improve the readability of str(transform) when DEBUG=True.
invalidate()[source]
 
Invalidate this TransformNode and triggers an invalidation of its ancestors. Should be called any time the transform changes.
pass_through=False
 
If pass_through is True, all ancestors will always be invalidated, even if 'self' is already invalid.
set_children(*children)[source]
 
Set the children of the transform, to let the invalidation system know which transforms can invalidate this transform. Should be called from the constructor of any transforms that depend on other transforms.
classmatplotlib.transforms.TransformWrapper(child)[source]
 
Bases: matplotlib.transforms.Transform A helper class that holds a single child transform and acts equivalently to it. This is useful if a node of the transform tree must be replaced at run time with a transform of a different type. This class allows that replacement to correctly trigger invalidation. TransformWrapper instances must have the same input and output dimensions during their entire lifetime, so the child transform may only be replaced with another child transform of the same dimensions. child: A Transform instance. This child may later be replaced with set().   __eq__(other)[source]
 
Return self==value. 
   __hash__=None

   __init__(child)[source]
 
child: A Transform instance. This child may later be replaced with set(). 
   __module__='matplotlib.transforms'

   __str__()[source]
 
Return str(self). 
   frozen()[source]
 
Return a frozen copy of this transform node. The frozen copy will not be updated when its children change. Useful for storing a previously known state of a transform where copy.deepcopy() might normally be used. 
   propertyhas_inverse
 
bool(x) -> bool Returns True when the argument x is true, False otherwise. The builtins True and False are the only two instances of the class bool. The class bool is a subclass of the class int, and cannot be subclassed. 
   propertyis_affine
 
bool(x) -> bool Returns True when the argument x is true, False otherwise. The builtins True and False are the only two instances of the class bool. The class bool is a subclass of the class int, and cannot be subclassed. 
   propertyis_separable
 
bool(x) -> bool Returns True when the argument x is true, False otherwise. The builtins True and False are the only two instances of the class bool. The class bool is a subclass of the class int, and cannot be subclassed. 
   pass_through=True
 
If pass_through is True, all ancestors will always be invalidated, even if 'self' is already invalid. 
   set(child)[source]
 
Replace the current child of this transform with another one. The new child must have the same number of input and output dimensions as the current child.
__init__(child)[source]
 
child: A Transform instance. This child may later be replaced with set().
set(child)[source]
 
Replace the current child of this transform with another one. The new child must have the same number of input and output dimensions as the current child.
gradient(x, y)[source]
 
Returns a list of 2 masked arrays containing interpolated derivatives at the specified (x, y) points.  Parameters 
 
x, yarray-like


x and y coordinates of the same shape and any number of dimensions.    Returns 
 
dzdx, dzdynp.ma.array


2 masked arrays of the same shape as x and y; values corresponding to (x, y) points outside of the triangulation are masked out. The first returned array contains the values of \(\frac{\partial z}{\partial x}\) and the second those of \(\frac{\partial z}{\partial y}\).
classmatplotlib.tri.LinearTriInterpolator(triangulation, z, trifinder=None)[source]
 
Bases: matplotlib.tri.triinterpolate.TriInterpolator Linear interpolator on a triangular grid. Each triangle is represented by a plane so that an interpolated value at point (x, y) lies on the plane of the triangle containing (x, y). Interpolated values are therefore continuous across the triangulation, but their first derivatives are discontinuous at edges between triangles.  Parameters 
 
triangulationTriangulation


The triangulation to interpolate over.  
z(npoints,) array-like


Array of values, defined at grid points, to interpolate between.  
trifinderTriFinder, optional


If this is not specified, the Triangulation's default TriFinder will be used by calling Triangulation.get_trifinder.     Methods  
`__call__` (x, y) (Returns interpolated values at (x, y) points.)  
`gradient` (x, y) (Returns interpolated derivatives at (x, y) points.)     gradient(x, y)[source]
 
Returns a list of 2 masked arrays containing interpolated derivatives at the specified (x, y) points.  Parameters 
 
x, yarray-like


x and y coordinates of the same shape and any number of dimensions.    Returns 
 
dzdx, dzdynp.ma.array


2 masked arrays of the same shape as x and y; values corresponding to (x, y) points outside of the triangulation are masked out. The first returned array contains the values of \(\frac{\partial z}{\partial x}\) and the second those of \(\frac{\partial z}{\partial y}\).
classmatplotlib.tri.TrapezoidMapTriFinder(triangulation)[source]
 
Bases: matplotlib.tri.trifinder.TriFinder TriFinder class implemented using the trapezoid map algorithm from the book "Computational Geometry, Algorithms and Applications", second edition, by M. de Berg, M. van Kreveld, M. Overmars and O. Schwarzkopf. The triangulation must be valid, i.e. it must not have duplicate points, triangles formed from colinear points, or overlapping triangles. The algorithm has some tolerance to triangles formed from colinear points, but this should not be relied upon.
circle_ratios(rescale=True)[source]
 
Return a measure of the triangulation triangles flatness. The ratio of the incircle radius over the circumcircle radius is a widely used indicator of a triangle flatness. It is always <= 0.5 and == 0.5 only for equilateral triangles. Circle ratios below 0.01 denote very flat triangles. To avoid unduly low values due to a difference of scale between the 2 axis, the triangular mesh can first be rescaled to fit inside a unit square with scale_factors (Only if rescale is True, which is its default value).  Parameters 
 
rescalebool, default: True


If True, internally rescale (based on scale_factors), so that the (unmasked) triangles fit exactly inside a unit square mesh.    Returns 
 masked array

Ratio of the incircle radius over the circumcircle radius, for each 'rescaled' triangle of the encapsulated triangulation. Values corresponding to masked triangles are masked out.