neulab/docprompting-conala huggingface dataset:
_thread.get_ident()  
Return the ‘thread identifier’ of the current thread. This is a nonzero integer. Its value has no direct meaning; it is intended as a magic cookie to be used e.g. to index a dictionary of thread-specific data. Thread identifiers may be recycled when a thread exits and another thread is created.
_thread.get_native_id()  
Return the native integral Thread ID of the current thread assigned by the kernel. This is a non-negative integer. Its value may be used to uniquely identify this particular thread system-wide (until the thread terminates, after which the value may be recycled by the OS). Availability: Windows, FreeBSD, Linux, macOS, OpenBSD, NetBSD, AIX.  New in version 3.8.
_thread.interrupt_main()  
Simulate the effect of a signal.SIGINT signal arriving in the main thread. A thread can use this function to interrupt the main thread. If signal.SIGINT isn’t handled by Python (it was set to signal.SIG_DFL or signal.SIG_IGN), this function does nothing.
lock.acquire(waitflag=1, timeout=-1)  
Without any optional argument, this method acquires the lock unconditionally, if necessary waiting until it is released by another thread (only one thread at a time can acquire a lock — that’s their reason for existence). If the integer waitflag argument is present, the action depends on its value: if it is zero, the lock is only acquired if it can be acquired immediately without waiting, while if it is nonzero, the lock is acquired unconditionally as above. If the floating-point timeout argument is present and positive, it specifies the maximum wait time in seconds before returning. A negative timeout argument specifies an unbounded wait. You cannot specify a timeout if waitflag is zero. The return value is True if the lock is acquired successfully, False if not.  Changed in version 3.2: The timeout parameter is new.   Changed in version 3.2: Lock acquires can now be interrupted by signals on POSIX.
lock.locked()  
Return the status of the lock: True if it has been acquired by some thread, False if not.
lock.release()  
Releases the lock. The lock must have been acquired earlier, but not necessarily by the same thread.
_thread.stack_size([size])  
Return the thread stack size used when creating new threads. The optional size argument specifies the stack size to be used for subsequently created threads, and must be 0 (use platform or configured default) or a positive integer value of at least 32,768 (32 KiB). If size is not specified, 0 is used. If changing the thread stack size is unsupported, a RuntimeError is raised. If the specified stack size is invalid, a ValueError is raised and the stack size is unmodified. 32 KiB is currently the minimum supported stack size value to guarantee sufficient stack space for the interpreter itself. Note that some platforms may have particular restrictions on values for the stack size, such as requiring a minimum stack size > 32 KiB or requiring allocation in multiples of the system memory page size - platform documentation should be referred to for more information (4 KiB pages are common; using multiples of 4096 for the stack size is the suggested approach in the absence of more specific information). Availability: Windows, systems with POSIX threads.
_thread.start_new_thread(function, args[, kwargs])  
Start a new thread and return its identifier. The thread executes the function function with the argument list args (which must be a tuple). The optional kwargs argument specifies a dictionary of keyword arguments. When the function returns, the thread silently exits. When the function terminates with an unhandled exception, sys.unraisablehook() is called to handle the exception. The object attribute of the hook argument is function. By default, a stack trace is printed and then the thread exits (but other threads continue to run). When the function raises a SystemExit exception, it is silently ignored.  Changed in version 3.8: sys.unraisablehook() is now used to handle unhandled exceptions.
_thread.TIMEOUT_MAX  
The maximum value allowed for the timeout parameter of Lock.acquire(). Specifying a timeout greater than this value will raise an OverflowError.  New in version 3.2.
__debug__  
This constant is true if Python was not started with an -O option. See also the assert statement.
__future__ — Future statement definitions Source code: Lib/__future__.py __future__ is a real module, and serves three purposes:  To avoid confusing existing tools that analyze import statements and expect to find the modules they’re importing. To ensure that future statements run under releases prior to 2.1 at least yield runtime exceptions (the import of __future__ will fail, because there was no module of that name prior to 2.1). To document when incompatible changes were introduced, and when they will be — or were — made mandatory. This is a form of executable documentation, and can be inspected programmatically via importing __future__ and examining its contents.  Each statement in __future__.py is of the form: FeatureName = _Feature(OptionalRelease, MandatoryRelease,
                       CompilerFlag)
 where, normally, OptionalRelease is less than MandatoryRelease, and both are 5-tuples of the same form as sys.version_info: (PY_MAJOR_VERSION, # the 2 in 2.1.0a3; an int
 PY_MINOR_VERSION, # the 1; an int
 PY_MICRO_VERSION, # the 0; an int
 PY_RELEASE_LEVEL, # "alpha", "beta", "candidate" or "final"; string
 PY_RELEASE_SERIAL # the 3; an int
)
 OptionalRelease records the first release in which the feature was accepted. In the case of a MandatoryRelease that has not yet occurred, MandatoryRelease predicts the release in which the feature will become part of the language. Else MandatoryRelease records when the feature became part of the language; in releases at or after that, modules no longer need a future statement to use the feature in question, but may continue to use such imports. MandatoryRelease may also be None, meaning that a planned feature got dropped. Instances of class _Feature have two corresponding methods, getOptionalRelease() and getMandatoryRelease(). CompilerFlag is the (bitfield) flag that should be passed in the fourth argument to the built-in function compile() to enable the feature in dynamically compiled code. This flag is stored in the compiler_flag attribute on _Feature instances. No feature description will ever be deleted from __future__. Since its introduction in Python 2.1 the following features have found their way into the language using this mechanism:   
feature optional in mandatory in effect   
nested_scopes 2.1.0b1 2.2 PEP 227: Statically Nested Scopes  
generators 2.2.0a1 2.3 PEP 255: Simple Generators  
division 2.2.0a2 3.0 PEP 238: Changing the Division Operator  
absolute_import 2.5.0a1 3.0 PEP 328: Imports: Multi-Line and Absolute/Relative  
with_statement 2.5.0a1 2.6 PEP 343: The “with” Statement  
print_function 2.6.0a2 3.0 PEP 3105: Make print a function  
unicode_literals 2.6.0a2 3.0 PEP 3112: Bytes literals in Python 3000  
generator_stop 3.5.0b1 3.7 PEP 479: StopIteration handling inside generators  
annotations 3.7.0b1 3.10 PEP 563: Postponed evaluation of annotations    See also  Future statements

How the compiler treats future imports.
__import__(name, globals=None, locals=None, fromlist=(), level=0)  
 Note This is an advanced function that is not needed in everyday Python programming, unlike importlib.import_module().  This function is invoked by the import statement. It can be replaced (by importing the builtins module and assigning to builtins.__import__) in order to change semantics of the import statement, but doing so is strongly discouraged as it is usually simpler to use import hooks (see PEP 302) to attain the same goals and does not cause issues with code which assumes the default import implementation is in use. Direct use of __import__() is also discouraged in favor of importlib.import_module(). The function imports the module name, potentially using the given globals and locals to determine how to interpret the name in a package context. The fromlist gives the names of objects or submodules that should be imported from the module given by name. The standard implementation does not use its locals argument at all, and uses its globals only to determine the package context of the import statement. level specifies whether to use absolute or relative imports. 0 (the default) means only perform absolute imports. Positive values for level indicate the number of parent directories to search relative to the directory of the module calling __import__() (see PEP 328 for the details). When the name variable is of the form package.module, normally, the top-level package (the name up till the first dot) is returned, not the module named by name. However, when a non-empty fromlist argument is given, the module named by name is returned. For example, the statement import spam results in bytecode resembling the following code: spam = __import__('spam', globals(), locals(), [], 0)
 The statement import spam.ham results in this call: spam = __import__('spam.ham', globals(), locals(), [], 0)
 Note how __import__() returns the toplevel module here because this is the object that is bound to a name by the import statement. On the other hand, the statement from spam.ham import eggs, sausage as
saus results in _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage
 Here, the spam.ham module is returned from __import__(). From this object, the names to import are retrieved and assigned to their respective names. If you simply want to import a module (potentially within a package) by name, use importlib.import_module().  Changed in version 3.3: Negative values for level are no longer supported (which also changes the default value to 0).   Changed in version 3.9: When the command line options -E or -I are being used, the environment variable PYTHONCASEOK is now ignored.
__main__ — Top-level script environment '__main__' is the name of the scope in which top-level code executes. A module’s __name__ is set equal to '__main__' when read from standard input, a script, or from an interactive prompt. A module can discover whether or not it is running in the main scope by checking its own __name__, which allows a common idiom for conditionally executing code in a module when it is run as a script or with python
-m but not when it is imported: if __name__ == "__main__":
    # execute only if run as a script
    main()
 For a package, the same effect can be achieved by including a __main__.py module, the contents of which will be executed when the module is run with -m.
matplotlib._api.caching_module_getattr(cls)[source]
 
Helper decorator for implementing module-level __getattr__ as a class. This decorator must be used at the module toplevel as follows: @caching_module_getattr
class __getattr__:  # The class *must* be named ``__getattr__``.
    @property  # Only properties are taken into account.
    def name(self): ...
 The __getattr__ class will be replaced by a __getattr__ function such that trying to access name on the module will resolve the corresponding property (which may be decorated e.g. with _api.deprecated for deprecating module globals). The properties are all implicitly cached. Moreover, a suitable AttributeError is generated and raised if no property with the given name exists.
matplotlib._api.check_getitem(_mapping, **kwargs)[source]
 
kwargs must consist of a single key, value pair. If key is in _mapping, return _mapping[value]; else, raise an appropriate ValueError. Examples >>> _api.check_getitem({"foo": "bar"}, arg=arg)
matplotlib._api.check_in_list(_values, *, _print_supported_values=True, **kwargs)[source]
 
For each key, value pair in kwargs, check that value is in _values.  Parameters 
 
_valuesiterable


Sequence of values to check on.  
_print_supported_valuesbool, default: True


Whether to print _values when raising ValueError.  
**kwargsdict


key, value pairs as keyword arguments to find in _values.    Raises 
 ValueError

If any value in kwargs is not found in _values.     Examples >>> _api.check_in_list(["foo", "bar"], arg=arg, other_arg=other_arg)
matplotlib._api.check_isinstance(_types, **kwargs)[source]
 
For each key, value pair in kwargs, check that value is an instance of one of _types; if not, raise an appropriate TypeError. As a special case, a None entry in _types is treated as NoneType. Examples >>> _api.check_isinstance((SomeClass, None), arg=arg)
matplotlib._api.check_shape(_shape, **kwargs)[source]
 
For each key, value pair in kwargs, check that value has the shape _shape, if not, raise an appropriate ValueError. None in the shape is treated as a "free" size that can have any length. e.g. (None, 2) -> (N, 2) The values checked must be numpy arrays. Examples To check for (N, 2) shaped arrays >>> _api.check_shape((None, 2), arg=arg, other_arg=other_arg)
classmatplotlib._api.classproperty(fget, fset=None, fdel=None, doc=None)[source]
 
Bases: object Like property, but also triggers on access via the class, and it is the class that's passed as argument. Examples class C:
    @classproperty
    def foo(cls):
        return cls.__name__

assert C.foo == "C"
   propertyfget
matplotlib._api.deprecation.delete_parameter(since, name, func=None, **kwargs)[source]
 
Decorator indicating that parameter name of func is being deprecated. The actual implementation of func should keep the name parameter in its signature, or accept a **kwargs argument (through which name would be passed). Parameters that come after the deprecated parameter effectively become keyword-only (as they cannot be passed positionally without triggering the DeprecationWarning on the deprecated parameter), and should be marked as such after the deprecation period has passed and the deprecated parameter is removed. Parameters other than since, name, and func are keyword-only and forwarded to warn_deprecated. Examples @_api.delete_parameter("3.1", "unused")
def func(used_arg, other_arg, unused, more_args): ...
matplotlib._api.deprecation.deprecate_method_override(method, obj, *, allow_empty=False, **kwargs)[source]
 
Return obj.method with a deprecation if it was overridden, else None.  Parameters 
 method

An unbound method, i.e. an expression of the form Class.method_name. Remember that within the body of a method, one can always use __class__ to refer to the class that is currently being defined.  obj

Either an object of the class where method is defined, or a subclass of that class.  
allow_emptybool, default: False


Whether to allow overrides by "empty" methods without emitting a warning.  **kwargs

Additional parameters passed to warn_deprecated to generate the deprecation warning; must at least include the "since" key.
classmatplotlib._api.deprecation.deprecate_privatize_attribute(*args, **kwargs)[source]
 
Bases: object Helper to deprecate public access to an attribute (or method). This helper should only be used at class scope, as follows: class Foo:
    attr = _deprecate_privatize_attribute(*args, **kwargs)
 where all parameters are forwarded to deprecated. This form makes attr a property which forwards read and write access to self._attr (same name but with a leading underscore), with a deprecation warning. Note that the attribute name is derived from the name this helper is assigned to. This helper also works for deprecating methods.
matplotlib._api.deprecation.deprecated(since, *, message='', name='', alternative='', pending=False, obj_type=None, addendum='', removal='')[source]
 
Decorator to mark a function, a class, or a property as deprecated. When deprecating a classmethod, a staticmethod, or a property, the @deprecated decorator should go under @classmethod and @staticmethod (i.e., deprecated should directly decorate the underlying callable), but over @property. When deprecating a class C intended to be used as a base class in a multiple inheritance hierarchy, C must define an __init__ method (if C instead inherited its __init__ from its own base class, then @deprecated would mess up __init__ inheritance when installing its own (deprecation-emitting) C.__init__). Parameters are the same as for warn_deprecated, except that obj_type defaults to 'class' if decorating a class, 'attribute' if decorating a property, and 'function' otherwise. Examples @deprecated('1.4.0')
def the_function_to_deprecate():
    pass
matplotlib._api.deprecation.make_keyword_only(since, name, func=None)[source]
 
Decorator indicating that passing parameter name (or any of the following ones) positionally to func is being deprecated. When used on a method that has a pyplot wrapper, this should be the outermost decorator, so that boilerplate.py can access the original signature.
exceptionmatplotlib._api.deprecation.MatplotlibDeprecationWarning[source]
 
Bases: DeprecationWarning A class for issuing deprecation warnings for Matplotlib users.
matplotlib._api.deprecation.mplDeprecation[source]
 
alias of matplotlib._api.deprecation.MatplotlibDeprecationWarning
matplotlib._api.deprecation.rename_parameter(since, old, new, func=None)[source]
 
Decorator indicating that parameter old of func is renamed to new. The actual implementation of func should use new, not old. If old is passed to func, a DeprecationWarning is emitted, and its value is used, even if new is also passed by keyword (this is to simplify pyplot wrapper functions, which always pass new explicitly to the Axes method). If new is also passed but positionally, a TypeError will be raised by the underlying function during argument binding. Examples @_api.rename_parameter("3.1", "bad_name", "good_name")
def func(good_name): ...
matplotlib._api.deprecation.warn_deprecated(since, *, message='', name='', alternative='', pending=False, obj_type='', addendum='', removal='')[source]
 
Display a standardized deprecation.  Parameters 
 
sincestr


The release at which this API became deprecated.  
messagestr, optional


Override the default deprecation message. The %(since)s, %(name)s, %(alternative)s, %(obj_type)s, %(addendum)s, and %(removal)s format specifiers will be replaced by the values of the respective arguments passed to this function.  
namestr, optional


The name of the deprecated object.  
alternativestr, optional


An alternative API that the user may use in place of the deprecated API. The deprecation warning will tell the user about this alternative if provided.  
pendingbool, optional


If True, uses a PendingDeprecationWarning instead of a DeprecationWarning. Cannot be used together with removal.  
obj_typestr, optional


The object type being deprecated.  
addendumstr, optional


Additional text appended directly to the final message.  
removalstr, optional


The expected removal version. With the default (an empty string), a removal version is automatically computed from since. Set to other Falsy values to not schedule a removal date. Cannot be used together with pending.     Examples # To warn of the deprecation of "matplotlib.name_of_module"
warn_deprecated('1.4.0', name='matplotlib.name_of_module',
                obj_type='module')
matplotlib._api.select_matching_signature(funcs, *args, **kwargs)[source]
 
Select and call the function that accepts *args, **kwargs. funcs is a list of functions which should not raise any exception (other than TypeError if the arguments passed do not match their signature). select_matching_signature tries to call each of the functions in funcs with *args, **kwargs (in the order in which they are given). Calls that fail with a TypeError are silently skipped. As soon as a call succeeds, select_matching_signature returns its return value. If no function accepts *args, **kwargs, then the TypeError raised by the last failing call is re-raised. Callers should normally make sure that any *args, **kwargs can only bind a single func (to avoid any ambiguity), although this is not checked by select_matching_signature. Notes select_matching_signature is intended to help implementing signature-overloaded functions. In general, such functions should be avoided, except for back-compatibility concerns. A typical use pattern is def my_func(*args, **kwargs):
    params = select_matching_signature(
        [lambda old1, old2: locals(), lambda new: locals()],
        *args, **kwargs)
    if "old1" in params:
        warn_deprecated(...)
        old1, old2 = params.values()  # note that locals() is ordered.
    else:
        new, = params.values()
    # do things with params
 which allows my_func to be called either with two parameters (old1 and old2) or a single one (new). Note that the new signature is given last, so that callers get a TypeError corresponding to the new signature if the arguments they passed in do not match any signature.
matplotlib._api.warn_external(message, category=None)[source]
 
warnings.warn wrapper that sets stacklevel to "outside Matplotlib". The original emitter of the warning can be obtained by patching this function back to warnings.warn, i.e. _api.warn_external =
warnings.warn (or functools.partial(warnings.warn, stacklevel=2), etc.).
matplotlib._enums Enums representing sets of strings that Matplotlib uses as input parameters. Matplotlib often uses simple data types like strings or tuples to define a concept; e.g. the line capstyle can be specified as one of 'butt', 'round', or 'projecting'. The classes in this module are used internally and serve to document these concepts formally. As an end-user you will not use these classes directly, but only the values they define.   classmatplotlib._enums.JoinStyle(value)[source]
 
Define how the connection between two line segments is drawn. For a visual impression of each JoinStyle, view these docs online, or run JoinStyle.demo. Lines in Matplotlib are typically defined by a 1D Path and a finite linewidth, where the underlying 1D Path represents the center of the stroked line. By default, GraphicsContextBase defines the boundaries of a stroked line to simply be every point within some radius, linewidth/2, away from any point of the center line. However, this results in corners appearing "rounded", which may not be the desired behavior if you are drawing, for example, a polygon or pointed star. Supported values:  'miter'

the "arrow-tip" style. Each boundary of the filled-in area will extend in a straight line parallel to the tangent vector of the centerline at the point it meets the corner, until they meet in a sharp point.  'round'

stokes every point within a radius of linewidth/2 of the center lines.  'bevel'

the "squared-off" style. It can be thought of as a rounded corner where the "circular" part of the corner has been cut off.    Note Very long miter tips are cut off (to form a bevel) after a backend-dependent limit called the "miter limit", which specifies the maximum allowed ratio of miter length to line width. For example, the PDF backend uses the default value of 10 specified by the PDF standard, while the SVG backend does not even specify the miter limit, resulting in a default value of 4 per the SVG specification. Matplotlib does not currently allow the user to adjust this parameter. A more detailed description of the effect of a miter limit can be found in the Mozilla Developer Docs  (Source code, png, pdf)      staticdemo()[source]
 
Demonstrate how each JoinStyle looks for various join angles. 
 
   classmatplotlib._enums.CapStyle(value)[source]
 
Define how the two endpoints (caps) of an unclosed line are drawn. How to draw the start and end points of lines that represent a closed curve (i.e. that end in a CLOSEPOLY) is controlled by the line's JoinStyle. For all other lines, how the start and end points are drawn is controlled by the CapStyle. For a visual impression of each CapStyle, view these docs online or run CapStyle.demo. Supported values:  'butt'

the line is squared off at its endpoint.  'projecting'

the line is squared off as in butt, but the filled in area extends beyond the endpoint a distance of linewidth/2.  'round'

like butt, but a semicircular cap is added to the end of the line, of radius linewidth/2.   (Source code, png, pdf)      staticdemo()[source]
 
Demonstrate how each CapStyle looks for a thick line segment.