neulab/docprompting-conala huggingface dataset:
classmatplotlib.transforms.Affine2DBase(*args, **kwargs)[source]
 
Bases: matplotlib.transforms.AffineBase The base class of all 2D affine transformations. 2D affine transformations are performed using a 3x3 numpy array: a c e
b d f
0 0 1
 This class provides the read-only interface. For a mutable 2D affine transformation, use Affine2D. Subclasses of this class will generally only need to override a constructor and get_matrix() that generates a custom 3x3 matrix.  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'

   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. 
   has_inverse=True
 
True if this transform has a corresponding inverse transform. 
   input_dims=2
 
The number of input dimensions of this transform. Must be overridden (with integers) in the subclass. 
   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. 
   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. 
   output_dims=2
 
The number of output dimensions of this transform. Must be overridden (with integers) in the subclass. 
   to_values()[source]
 
Return the values of the matrix as an (a, b, c, d, e, f) tuple. 
   transform_affine(points)[source]
 
Apply only the affine part of this transformation on the given array of values. transform(values) is always equivalent to transform_affine(transform_non_affine(values)). In non-affine transformations, this is generally a no-op. In affine transformations, this is equivalent to transform(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.
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.
to_values()[source]
 
Return the values of the matrix as an (a, b, c, d, e, f) tuple.
transform_affine(points)[source]
 
Apply only the affine part of this transformation on the given array of values. transform(values) is always equivalent to transform_affine(transform_non_affine(values)). In non-affine transformations, this is generally a no-op. In affine transformations, this is equivalent to transform(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.
classmatplotlib.transforms.AffineBase(*args, **kwargs)[source]
 
Bases: matplotlib.transforms.Transform The base class of all affine transformations of any number of dimensions.  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.       __array__(*args, **kwargs)[source]
 
Array interface to get at this Transform's affine matrix. 
   __eq__(other)[source]
 
Return self==value. 
   __hash__=None

   __init__(*args, **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'

   get_affine()[source]
 
Get the affine part of this transform. 
   is_affine=True

   transform(values)[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.     
   transform_affine(values)[source]
 
Apply only the affine part of this transformation on the given array of values. transform(values) is always equivalent to transform_affine(transform_non_affine(values)). In non-affine transformations, this is generally a no-op. In affine transformations, this is equivalent to transform(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.     
   transform_non_affine(points)[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_path(path)[source]
 
Apply the transform to Path path, returning a new Path. In some cases, this transform may insert curves into the path that began as line segments. 
   transform_path_affine(path)[source]
 
Apply the affine part of this transform to Path path, returning a new Path. transform_path(path) is equivalent to transform_path_affine(transform_path_non_affine(values)). 
   transform_path_non_affine(path)[source]
 
Apply the non-affine part of this transform to Path path, returning a new Path. transform_path(path) is equivalent to transform_path_affine(transform_path_non_affine(values)).
__array__(*args, **kwargs)[source]
 
Array interface to get at this Transform's affine matrix.
__init__(*args, **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.
transform(values)[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.
transform_affine(values)[source]
 
Apply only the affine part of this transformation on the given array of values. transform(values) is always equivalent to transform_affine(transform_non_affine(values)). In non-affine transformations, this is generally a no-op. In affine transformations, this is equivalent to transform(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.
transform_non_affine(points)[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_path(path)[source]
 
Apply the transform to Path path, returning a new Path. In some cases, this transform may insert curves into the path that began as line segments.
transform_path_affine(path)[source]
 
Apply the affine part of this transform to Path path, returning a new Path. transform_path(path) is equivalent to transform_path_affine(transform_path_non_affine(values)).
classmatplotlib.transforms.AffineDeltaTransform(transform, **kwargs)[source]
 
Bases: matplotlib.transforms.Affine2DBase A transform wrapper for transforming displacements between pairs of points. This class is intended to be used to transform displacements ("position deltas") between pairs of points (e.g., as the offset_transform of Collections): given a transform t such that t =
AffineDeltaTransform(t) + offset, AffineDeltaTransform satisfies AffineDeltaTransform(a - b) == AffineDeltaTransform(a) -
AffineDeltaTransform(b). This is implemented by forcing the offset components of the transform matrix to zero. This class is experimental as of 3.3, and the API may change.  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__(transform, **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__(transform, **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.
__init__(points, **kwargs)[source]
 
 Parameters 
 
pointsndarray


A 2x2 numpy array of the form [[x0, y0], [x1, y1]].
staticfrom_bounds(x0, y0, width, height)[source]
 
Create a new Bbox from x0, y0, width and height. width and height may be negative.
staticfrom_extents(*args, minpos=None)[source]
 
Create a new Bbox from left, bottom, right and top. The y-axis increases upwards.  Parameters 
 
left, bottom, right, topfloat


The four extents of the bounding box.  
minposfloat or None


If this is supplied, the Bbox will have a minimum positive value set. This is useful when dealing with logarithmic scales and other scales where negative bounds result in floating point errors.
frozen()[source]
 
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.
get_points()[source]
 
Get the points of the bounding box directly as a numpy array of the form: [[x0, y0], [x1, y1]].
ignore(value)[source]
 
Set whether the existing bounds of the box should be ignored by subsequent calls to update_from_data_xy().  valuebool


 When True, subsequent calls to update_from_data_xy() will ignore the existing bounds of the Bbox. When False, subsequent calls to update_from_data_xy() will include the existing bounds of the Bbox.
staticnull()[source]
 
Create a new null Bbox from (inf, inf) to (-inf, -inf).
set(other)[source]
 
Set this bounding box from the "frozen" bounds of another Bbox.
set_points(points)[source]
 
Set the points of the bounding box directly from a numpy array of the form: [[x0, y0], [x1, y1]]. No error checking is performed, as this method is mainly for internal use.
staticunit()[source]
 
Create a new unit Bbox from (0, 0) to (1, 1).
update_from_data_x(x, ignore=None)[source]
 
Update the x-bounds of the Bbox based on the passed in data. After updating, the bounds will have positive width, and x0 will be the minimal value.  Parameters 
 
xndarray


Array of x-values.  
ignorebool, optional


 When True, ignore the existing bounds of the Bbox. When False, include the existing bounds of the Bbox. When None, use the last value passed to ignore().
update_from_data_xy(xy, ignore=None, updatex=True, updatey=True)[source]
 
Update the bounds of the Bbox based on the passed in data. After updating, the bounds will have positive width and height; x0 and y0 will be the minimal values.  Parameters 
 
xyndarray


A numpy array of 2D points.  
ignorebool, optional


 When True, ignore the existing bounds of the Bbox. When False, include the existing bounds of the Bbox. When None, use the last value passed to ignore().   
updatex, updateybool, default: True


When True, update the x/y values.
update_from_data_y(y, ignore=None)[source]
 
Update the y-bounds of the Bbox based on the passed in data. After updating, the bounds will have positive height, and y0 will be the minimal value.  Parameters 
 
yndarray


Array of y-values.  
ignorebool, optional


 When True, ignore the existing bounds of the Bbox. When False, include the existing bounds of the Bbox. When None, use the last value passed to ignore().
update_from_path(path, ignore=None, updatex=True, updatey=True)[source]
 
Update the bounds of the Bbox to contain the vertices of the provided path. After updating, the bounds will have positive width and height; x0 and y0 will be the minimal values.  Parameters 
 
pathPath


ignorebool, optional


 when True, ignore the existing bounds of the Bbox. when False, include the existing bounds of the Bbox. when None, use the last value passed to ignore().   
updatex, updateybool, default: True


When True, update the x/y values.
anchored(c, container=None)[source]
 
Return a copy of the Bbox anchored to c within container.  Parameters 
 
c(float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', ...}


Either an (x, y) pair of relative coordinates (0 is left or bottom, 1 is right or top), 'C' (center), or a cardinal direction ('SW', southwest, is bottom left, etc.).  
containerBbox, optional


The box within which the Bbox is positioned; it defaults to the initial Bbox.      See also  Axes.set_anchor
coefs={'C': (0.5, 0.5), 'E': (1.0, 0.5), 'N': (0.5, 1.0), 'NE': (1.0, 1.0), 'NW': (0, 1.0), 'S': (0.5, 0), 'SE': (1.0, 0), 'SW': (0, 0), 'W': (0, 0.5)}
contains(x, y)[source]
 
Return whether (x, y) is in the bounding box or on its edge.
containsx(x)[source]
 
Return whether x is in the closed (x0, x1) interval.
containsy(y)[source]
 
Return whether y is in the closed (y0, y1) interval.
corners()[source]
 
Return the corners of this rectangle as an array of points. Specifically, this returns the array [[x0, y0], [x0, y1], [x1, y0], [x1, y1]].
count_contains(vertices)[source]
 
Count the number of vertices contained in the Bbox. Any vertices with a non-finite x or y value are ignored.  Parameters 
 
verticesNx2 Numpy array.
count_overlaps(bboxes)[source]
 
Count the number of bounding boxes that overlap this one.  Parameters 
 
bboxessequence of BboxBase
expanded(sw, sh)[source]
 
Construct a Bbox by expanding this one around its center by the factors sw and sh.
fully_contains(x, y)[source]
 
Return whether x, y is in the bounding box, but not on its edge.
fully_containsx(x)[source]
 
Return whether x is in the open (x0, x1) interval.
fully_containsy(y)[source]
 
Return whether y is in the open (y0, y1) interval.
fully_overlaps(other)[source]
 
Return whether this bounding box overlaps with the other bounding box, not including the edges.  Parameters 
 
otherBboxBase
staticintersection(bbox1, bbox2)[source]
 
Return the intersection of bbox1 and bbox2 if they intersect, or None if they don't.
overlaps(other)[source]
 
Return whether this bounding box overlaps with the other bounding box.  Parameters 
 
otherBboxBase
padded(p)[source]
 
Construct a Bbox by padding this one on all four sides by p.
rotated(radians)[source]
 
Return the axes-aligned bounding box that bounds the result of rotating this Bbox by an angle of radians.
shrunk(mx, my)[source]
 
Return a copy of the Bbox, shrunk by the factor mx in the x direction and the factor my in the y direction. The lower left corner of the box remains unchanged. Normally mx and my will be less than 1, but this is not enforced.
shrunk_to_aspect(box_aspect, container=None, fig_aspect=1.0)[source]
 
Return a copy of the Bbox, shrunk so that it is as large as it can be while having the desired aspect ratio, box_aspect. If the box coordinates are relative (i.e. fractions of a larger box such as a figure) then the physical aspect ratio of that figure is specified with fig_aspect, so that box_aspect can also be given as a ratio of the absolute dimensions, not the relative dimensions.
splitx(*args)[source]
 
Return a list of new Bbox objects formed by splitting the original one with vertical lines at fractional positions given by args.
splity(*args)[source]
 
Return a list of new Bbox objects formed by splitting the original one with horizontal lines at fractional positions given by args.
transformed(transform)[source]
 
Construct a Bbox by statically transforming this one by transform.
translated(tx, ty)[source]
 
Construct a Bbox by translating this one by tx and ty.
staticunion(bboxes)[source]
 
Return a Bbox that contains all of the given bboxes.
classmatplotlib.transforms.BboxTransform(boxin, boxout, **kwargs)[source]
 
Bases: matplotlib.transforms.Affine2DBase BboxTransform linearly transforms points from one Bbox to another. Create a new BboxTransform that linearly transforms points from boxin to boxout.   __init__(boxin, boxout, **kwargs)[source]
 
Create a new BboxTransform that linearly transforms points from boxin to boxout. 
   __module__='matplotlib.transforms'

   __str__()[source]
 
Return str(self). 
   get_matrix()[source]
 
Get the matrix for the affine part of this transform. 
   is_separable=True
 
True if this transform is separable in the x- and y- dimensions.
__init__(boxin, boxout, **kwargs)[source]
 
Create a new BboxTransform that linearly transforms points from boxin to boxout.
classmatplotlib.transforms.BboxTransformFrom(boxin, **kwargs)[source]
 
Bases: matplotlib.transforms.Affine2DBase BboxTransformFrom linearly transforms points from a given Bbox to the unit bounding box.  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__(boxin, **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. 
   is_separable=True
 
True if this transform is separable in the x- and y- dimensions.
__init__(boxin, **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.
classmatplotlib.transforms.BboxTransformTo(boxout, **kwargs)[source]
 
Bases: matplotlib.transforms.Affine2DBase BboxTransformTo is a transformation that linearly transforms points from the unit bounding box to a given Bbox. Create a new BboxTransformTo that linearly transforms points from the unit bounding box to boxout.   __init__(boxout, **kwargs)[source]
 
Create a new BboxTransformTo that linearly transforms points from the unit bounding box to boxout. 
   __module__='matplotlib.transforms'

   __str__()[source]
 
Return str(self). 
   get_matrix()[source]
 
Get the matrix for the affine part of this transform. 
   is_separable=True
 
True if this transform is separable in the x- and y- dimensions.
__init__(boxout, **kwargs)[source]
 
Create a new BboxTransformTo that linearly transforms points from the unit bounding box to boxout.
classmatplotlib.transforms.BboxTransformToMaxOnly(boxout, **kwargs)[source]
 
Bases: matplotlib.transforms.BboxTransformTo BboxTransformTo is a transformation that linearly transforms points from the unit bounding box to a given Bbox with a fixed upper left of (0, 0). Create a new BboxTransformTo that linearly transforms points from the unit bounding box to boxout.   __module__='matplotlib.transforms'

   get_matrix()[source]
 
Get the matrix for the affine part of this transform.
matplotlib.transforms.blended_transform_factory(x_transform, y_transform)[source]
 
Create a new "blended" transform using x_transform to transform the x-axis and y_transform to transform the y-axis. A faster version of the blended transform is returned for the case where both child transforms are affine.
classmatplotlib.transforms.BlendedAffine2D(x_transform, y_transform, **kwargs)[source]
 
Bases: matplotlib.transforms._BlendedMixin, matplotlib.transforms.Affine2DBase A "blended" transform uses one transform for the x-direction, and another transform for the y-direction. This version is an optimization for the case where both child transforms are of type Affine2DBase. Create a new "blended" transform using x_transform to transform the x-axis and y_transform to transform the y-axis. Both x_transform and y_transform must be 2D affine transforms. You will generally not call this constructor directly but use the blended_transform_factory function instead, which can determine automatically which kind of blended transform to create.   __init__(x_transform, y_transform, **kwargs)[source]
 
Create a new "blended" transform using x_transform to transform the x-axis and y_transform to transform the y-axis. Both x_transform and y_transform must be 2D affine transforms. You will generally not call this constructor directly but use the blended_transform_factory function instead, which can determine automatically which kind of blended transform to create. 
   __module__='matplotlib.transforms'

   get_matrix()[source]
 
Get the matrix for the affine part of this transform. 
   is_separable=True
 
True if this transform is separable in the x- and y- dimensions.
__init__(x_transform, y_transform, **kwargs)[source]
 
Create a new "blended" transform using x_transform to transform the x-axis and y_transform to transform the y-axis. Both x_transform and y_transform must be 2D affine transforms. You will generally not call this constructor directly but use the blended_transform_factory function instead, which can determine automatically which kind of blended transform to create.
__init__(x_transform, y_transform, **kwargs)[source]
 
Create a new "blended" transform using x_transform to transform the x-axis and y_transform to transform the y-axis. You will generally not call this constructor directly but use the blended_transform_factory function instead, which can determine automatically which kind of blended transform to create.
contains_branch(other)[source]
 
Return whether the given transform is a sub-tree of this transform. This routine uses transform equality to identify sub-trees, therefore in many situations it is object id which will be used. For the case where the given transform represents the whole of this transform, returns True.
pass_through=True
 
If pass_through is True, all ancestors will always be invalidated, even if 'self' is already invalid.
matplotlib.transforms.composite_transform_factory(a, b)[source]
 
Create a new composite transform that is the result of applying transform a then transform b. Shortcut versions of the blended transform are provided for the case where both child transforms are affine, or one or the other is the identity transform. Composite transforms may also be created using the '+' operator, e.g.: c = a + b