neulab/docprompting-conala huggingface dataset:
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_detect method   distutils.ccompiler_opt.CCompilerOpt.feature_detect(names)[source]
 
Return a list of CPU features that required to be detected sorted from the lowest to highest interest.
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_get_til method   distutils.ccompiler_opt.CCompilerOpt.feature_get_til(names, keyisfalse)[source]
 
same as feature_implies_c() but stop collecting implied features when feature’s option that provided through parameter ‘keyisfalse’ is False, also sorting the returned features.
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_implies method   distutils.ccompiler_opt.CCompilerOpt.feature_implies(names, keep_origins=False)[source]
 
Return a set of CPU features that implied by ‘names’  Parameters 
 names: str or sequence of str

CPU feature name(s) in uppercase.  keep_origins: bool

if False(default) then the returned set will not contain any features from ‘names’. This case happens only when two features imply each other.     Examples >>> self.feature_implies("SSE3")
{'SSE', 'SSE2'}
>>> self.feature_implies("SSE2")
{'SSE'}
>>> self.feature_implies("SSE2", keep_origins=True)
# 'SSE2' found here since 'SSE' and 'SSE2' imply each other
{'SSE', 'SSE2'}
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_implies_c method   distutils.ccompiler_opt.CCompilerOpt.feature_implies_c(names)[source]
 
same as feature_implies() but combining ‘names’
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_is_exist method   distutils.ccompiler_opt.CCompilerOpt.feature_is_exist(name)[source]
 
Returns True if a certain feature is exist and covered within _Config.conf_features.  Parameters 
 ‘name’: str

feature name in uppercase.
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_names method   distutils.ccompiler_opt.CCompilerOpt.feature_names(names=None, force_flags=None, macros=[])[source]
 
Returns a set of CPU feature names that supported by platform and the C compiler.  Parameters 
 names: sequence or None, optional

Specify certain CPU features to test it against the C compiler. if None(default), it will test all current supported features. Note: feature names must be in upper-case.  force_flags: list or None, optional

If None(default), default compiler flags for every CPU feature will be used during the test.  
macroslist of tuples, optional


A list of C macro definitions.
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_sorted method   distutils.ccompiler_opt.CCompilerOpt.feature_sorted(names, reverse=False)[source]
 
Sort a list of CPU features ordered by the lowest interest.  Parameters 
 ‘names’: sequence

sequence of supported feature names in uppercase.  ‘reverse’: bool, optional

If true, the sorted features is reversed. (highest interest)    Returns 
 list, sorted CPU features
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_untied method   distutils.ccompiler_opt.CCompilerOpt.feature_untied(names)[source]
 
same as ‘feature_ahead()’ but if both features implied each other and keep the highest interest.  Parameters 
 ‘names’: sequence

sequence of CPU feature names in uppercase.    Returns 
 list of CPU features sorted as-is ‘names’
   Examples >>> self.feature_untied(["SSE2", "SSE3", "SSE41"])
["SSE2", "SSE3", "SSE41"]
# assume AVX2 and FMA3 implies each other
>>> self.feature_untied(["SSE2", "SSE3", "SSE41", "FMA3", "AVX2"])
["SSE2", "SSE3", "SSE41", "AVX2"]
numpy.distutils.ccompiler_opt.CCompilerOpt.generate_dispatch_header method   distutils.ccompiler_opt.CCompilerOpt.generate_dispatch_header(header_path)[source]
 
Generate the dispatch header which contains the #definitions and headers for platform-specific instruction-sets for the enabled CPU baseline and dispatch-able features. Its highly recommended to take a look at the generated header also the generated source files via try_dispatch() in order to get the full picture.
numpy.distutils.ccompiler_opt.CCompilerOpt.is_cached method   distutils.ccompiler_opt.CCompilerOpt.is_cached()[source]
 
Returns True if the class loaded from the cache file
numpy.distutils.ccompiler_opt.CCompilerOpt.parse_targets method   distutils.ccompiler_opt.CCompilerOpt.parse_targets(source)[source]
 
Fetch and parse configuration statements that required for defining the targeted CPU features, statements should be declared in the top of source in between C comment and start with a special mark @targets. Configuration statements are sort of keywords representing CPU features names, group of statements and policies, combined together to determine the required optimization.  Parameters 
 source: str

the path of C source file.    Returns 
 
 bool, True if group has the ‘baseline’ option
  
 list, list of CPU features
  
 list, list of extra compiler flags
numpy.distutils.ccompiler_opt.CCompilerOpt.try_dispatch method   distutils.ccompiler_opt.CCompilerOpt.try_dispatch(sources, src_dir=None, ccompiler=None, **kwargs)[source]
 
Compile one or more dispatch-able sources and generates object files, also generates abstract C config headers and macros that used later for the final runtime dispatching process. The mechanism behind it is to takes each source file that specified in ‘sources’ and branching it into several files depend on special configuration statements that must be declared in the top of each source which contains targeted CPU features, then it compiles every branched source with the proper compiler flags.  Parameters 
 
sourceslist


Must be a list of dispatch-able sources file paths, and configuration statements must be declared inside each file.  
src_dirstr


Path of parent directory for the generated headers and wrapped sources. If None(default) the files will generated in-place.  ccompiler: CCompiler

Distutils CCompiler instance to be used for compilation. If None (default), the provided instance during the initialization will be used instead.  
**kwargsany


Arguments to pass on to the CCompiler.compile()    Returns 
 
listgenerated object files

  Raises 
 CompileError

Raises by CCompiler.compile() on compiling failure.  DistutilsError

Some errors during checking the sanity of configuration statements.      See also  parse_targets

Parsing the configuration statements of dispatch-able sources.
numpy.distutils.ccompiler_opt.new_ccompiler_opt   distutils.ccompiler_opt.new_ccompiler_opt(compiler, dispatch_hpath, **kwargs)[source]
 
Create a new instance of ‘CCompilerOpt’ and generate the dispatch header which contains the #definitions and headers of platform-specific instruction-sets for the enabled CPU baseline and dispatch-able features.  Parameters 
 
compilerCCompiler instance


dispatch_hpathstr


path of the dispatch header  **kwargs: passed as-is to `CCompilerOpt(…)`
Returns
——-
new instance of CCompilerOpt
numpy.distutils.cpuinfo.cpu   distutils.cpuinfo.cpu = <numpy.distutils.cpuinfo.LinuxCPUInfo object>
numpy.distutils.exec_command.exec_command   distutils.exec_command.exec_command(command, execute_in='', use_shell=None, use_tee=None, _with_python=1, **env)[source]
 
Return (status,output) of executed command.  Deprecated since version 1.17: Use subprocess.Popen instead   Parameters 
 
commandstr


A concatenated string of executable and arguments.  
execute_instr


Before running command cd execute_in and after cd -.  
use_shell{bool, None}, optional


If True, execute sh -c command. Default None (True)  
use_tee{bool, None}, optional


If True use tee. Default None (True)    Returns 
 
resstr


Both stdout and stderr messages.     Notes On NT, DOS systems the returned status is correct for external commands. Wild cards will not work for non-posix systems or when use_shell=0.
numpy.distutils.exec_command.filepath_from_subprocess_output   distutils.exec_command.filepath_from_subprocess_output(output)[source]
 
Convert bytes in the encoding used by a subprocess into a filesystem-appropriate str. Inherited from exec_command, and possibly incorrect.
numpy.distutils.exec_command.find_executable   distutils.exec_command.find_executable(exe, path=None, _cache={})[source]
 
Return full path of a executable or None. Symbolic links are not followed.
numpy.distutils.exec_command.forward_bytes_to_stdout   distutils.exec_command.forward_bytes_to_stdout(val)[source]
 
Forward bytes from a subprocess call to the console, without attempting to decode them. The assumption is that the subprocess call already returned bytes in a suitable encoding.
numpy.distutils.exec_command.get_pythonexe   distutils.exec_command.get_pythonexe()[source]
numpy.distutils.exec_command.temp_file_name   distutils.exec_command.temp_file_name()[source]
numpy.distutils.log.set_verbosity   distutils.log.set_verbosity(v, force=False)[source]
numpy.distutils.system_info.get_info   distutils.system_info.get_info(name, notfound_action=0)[source]
 
 notfound_action:

0 - do nothing 1 - display warning message 2 - raise error
numpy.distutils.system_info.get_standard_file   distutils.system_info.get_standard_file(fname)[source]
 
Returns a list of files named ‘fname’ from 1) System-wide directory (directory-location of this module) 2) Users HOME directory (os.environ[‘HOME’]) 3) Local directory
DoxyLimbo(constDoxyLimbo<Tp,N>&l)
 
Set Default behavior for copy the limbo.
numpy.dtype.__class_getitem__ method   dtype.__class_getitem__(item, /)
 
Return a parametrized wrapper around the dtype type.  New in version 1.22.   Returns 
 
aliastypes.GenericAlias


A parametrized dtype type.      See also  PEP 585

Type hinting generics in standard collections.    Notes This method is only available for python 3.9 and later. Examples >>> import numpy as np
 >>> np.dtype[np.int64]
numpy.dtype[numpy.int64]
numpy.dtype.__ge__ method   dtype.__ge__(value, /)
 
Return self>=value.
numpy.dtype.__gt__ method   dtype.__gt__(value, /)
 
Return self>value.
numpy.dtype.__le__ method   dtype.__le__(value, /)
 
Return self<=value.
numpy.dtype.__lt__ method   dtype.__lt__(value, /)
 
Return self<value.
numpy.dtype.alignment attribute   dtype.alignment
 
The required alignment (bytes) of this data-type according to the compiler. More information is available in the C-API section of the manual. Examples >>> x = np.dtype('i4')
>>> x.alignment
4
 >>> x = np.dtype(float)
>>> x.alignment
8
numpy.dtype.base attribute   dtype.base
 
Returns dtype for the base element of the subarrays, regardless of their dimension or shape.  See also  dtype.subdtype
  Examples >>> x = numpy.dtype('8f')
>>> x.base
dtype('float32')
 >>> x =  numpy.dtype('i2')
>>> x.base
dtype('int16')
numpy.dtype.byteorder attribute   dtype.byteorder
 
A character indicating the byte-order of this data-type object. One of:  
‘=’ native  
‘<’ little-endian  
‘>’ big-endian  
‘|’ not applicable   All built-in data-type objects have byteorder either ‘=’ or ‘|’. Examples >>> dt = np.dtype('i2')
>>> dt.byteorder
'='
>>> # endian is not relevant for 8 bit numbers
>>> np.dtype('i1').byteorder
'|'
>>> # or ASCII strings
>>> np.dtype('S2').byteorder
'|'
>>> # Even if specific code is given, and it is native
>>> # '=' is the byteorder
>>> import sys
>>> sys_is_le = sys.byteorder == 'little'
>>> native_code = sys_is_le and '<' or '>'
>>> swapped_code = sys_is_le and '>' or '<'
>>> dt = np.dtype(native_code + 'i2')
>>> dt.byteorder
'='
>>> # Swapped code shows up as itself
>>> dt = np.dtype(swapped_code + 'i2')
>>> dt.byteorder == swapped_code
True
numpy.dtype.char attribute   dtype.char
 
A unique character code for each of the 21 different built-in types. Examples >>> x = np.dtype(float)
>>> x.char
'd'
numpy.dtype.descr attribute   dtype.descr
 
__array_interface__ description of the data-type. The format is that required by the ‘descr’ key in the __array_interface__ attribute. Warning: This attribute exists specifically for __array_interface__, and passing it directly to np.dtype will not accurately reconstruct some dtypes (e.g., scalar and subarray dtypes). Examples >>> x = np.dtype(float)
>>> x.descr
[('', '<f8')]
 >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> dt.descr
[('name', '<U16'), ('grades', '<f8', (2,))]
numpy.dtype.fields attribute   dtype.fields
 
Dictionary of named fields defined for this data type, or None. The dictionary is indexed by keys that are the names of the fields. Each entry in the dictionary is a tuple fully describing the field: (dtype, offset[, title])
 Offset is limited to C int, which is signed and usually 32 bits. If present, the optional title can be any object (if it is a string or unicode then it will also be a key in the fields dictionary, otherwise it’s meta-data). Notice also that the first two elements of the tuple can be passed directly as arguments to the ndarray.getfield and ndarray.setfield methods.  See also  
ndarray.getfield, ndarray.setfield

  Examples >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> print(dt.fields)
{'grades': (dtype(('float64',(2,))), 16), 'name': (dtype('|S16'), 0)}
numpy.dtype.flags attribute   dtype.flags
 
Bit-flags describing how this data type is to be interpreted. Bit-masks are in numpy.core.multiarray as the constants ITEM_HASOBJECT, LIST_PICKLE, ITEM_IS_POINTER, NEEDS_INIT, NEEDS_PYAPI, USE_GETITEM, USE_SETITEM. A full explanation of these flags is in C-API documentation; they are largely useful for user-defined data-types. The following example demonstrates that operations on this particular dtype requires Python C-API. Examples >>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)])
>>> x.flags
16
>>> np.core.multiarray.NEEDS_PYAPI
16
numpy.dtype.hasobject attribute   dtype.hasobject
 
Boolean indicating whether this dtype contains any reference-counted objects in any fields or sub-dtypes. Recall that what is actually in the ndarray memory representing the Python object is the memory address of that object (a pointer). Special handling may be required, and this attribute is useful for distinguishing data types that may contain arbitrary Python objects and data-types that won’t.
numpy.dtype.isalignedstruct attribute   dtype.isalignedstruct
 
Boolean indicating whether the dtype is a struct which maintains field alignment. This flag is sticky, so when combining multiple structs together, it is preserved and produces new dtypes which are also aligned.
numpy.dtype.isbuiltin attribute   dtype.isbuiltin
 
Integer indicating how this dtype relates to the built-in dtypes. Read-only.  
0 if this is a structured array type, with fields  
1 if this is a dtype compiled into numpy (such as ints, floats etc)  
2 if the dtype is for a user-defined numpy type A user-defined type uses the numpy C-API machinery to extend numpy to handle a new array type. See User-defined data-types in the NumPy manual.   Examples >>> dt = np.dtype('i2')
>>> dt.isbuiltin
1
>>> dt = np.dtype('f8')
>>> dt.isbuiltin
1
>>> dt = np.dtype([('field1', 'f8')])
>>> dt.isbuiltin
0
numpy.dtype.isnative attribute   dtype.isnative
 
Boolean indicating whether the byte order of this dtype is native to the platform.
numpy.dtype.itemsize attribute   dtype.itemsize
 
The element size of this data-type object. For 18 of the 21 types this number is fixed by the data-type. For the flexible data-types, this number can be anything. Examples >>> arr = np.array([[1, 2], [3, 4]])
>>> arr.dtype
dtype('int64')
>>> arr.itemsize
8
 >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> dt.itemsize
80
numpy.dtype.kind attribute   dtype.kind
 
A character code (one of ‘biufcmMOSUV’) identifying the general kind of data.  
b boolean  
i signed integer  
u unsigned integer  
f floating-point  
c complex floating-point  
m timedelta  
M datetime  
O object  
S (byte-)string  
U Unicode  
V void   Examples >>> dt = np.dtype('i4')
>>> dt.kind
'i'
>>> dt = np.dtype('f8')
>>> dt.kind
'f'
>>> dt = np.dtype([('field1', 'f8')])
>>> dt.kind
'V'
numpy.dtype.metadata attribute   dtype.metadata
 
Either None or a readonly dictionary of metadata (mappingproxy). The metadata field can be set using any dictionary at data-type creation. NumPy currently has no uniform approach to propagating metadata; although some array operations preserve it, there is no guarantee that others will.  Warning Although used in certain projects, this feature was long undocumented and is not well supported. Some aspects of metadata propagation are expected to change in the future.  Examples >>> dt = np.dtype(float, metadata={"key": "value"})
>>> dt.metadata["key"]
'value'
>>> arr = np.array([1, 2, 3], dtype=dt)
>>> arr.dtype.metadata
mappingproxy({'key': 'value'})
 Adding arrays with identical datatypes currently preserves the metadata: >>> (arr + arr).dtype.metadata
mappingproxy({'key': 'value'})
 But if the arrays have different dtype metadata, the metadata may be dropped: >>> dt2 = np.dtype(float, metadata={"key2": "value2"})
>>> arr2 = np.array([3, 2, 1], dtype=dt2)
>>> (arr + arr2).dtype.metadata is None
True  # The metadata field is cleared so None is returned
numpy.dtype.name attribute   dtype.name
 
A bit-width name for this data-type. Un-sized flexible data-type objects do not have this attribute. Examples >>> x = np.dtype(float)
>>> x.name
'float64'
>>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)])
>>> x.name
'void640'
numpy.dtype.names attribute   dtype.names
 
Ordered list of field names, or None if there are no fields. The names are ordered according to increasing byte offset. This can be used, for example, to walk through all of the named fields in offset order. Examples >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> dt.names
('name', 'grades')
numpy.dtype.ndim attribute   dtype.ndim
 
Number of dimensions of the sub-array if this data type describes a sub-array, and 0 otherwise.  New in version 1.13.0.  Examples >>> x = np.dtype(float)
>>> x.ndim
0
 >>> x = np.dtype((float, 8))
>>> x.ndim
1
 >>> x = np.dtype(('i4', (3, 4)))
>>> x.ndim
2
numpy.dtype.newbyteorder method   dtype.newbyteorder(new_order='S', /)
 
Return a new dtype with a different byte order. Changes are also made in all fields and sub-arrays of the data type.  Parameters 
 
new_orderstring, optional


Byte order to force; a value from the byte order specifications below. The default value (‘S’) results in swapping the current byte order. new_order codes can be any of:  ‘S’ - swap dtype from current to opposite endian {‘<’, ‘little’} - little endian {‘>’, ‘big’} - big endian {‘=’, ‘native’} - native order {‘|’, ‘I’} - ignore (no change to byte order)     Returns 
 
new_dtypedtype


New dtype object with the given change to the byte order.     Notes Changes are also made in all fields and sub-arrays of the data type. Examples >>> import sys
>>> sys_is_le = sys.byteorder == 'little'
>>> native_code = sys_is_le and '<' or '>'
>>> swapped_code = sys_is_le and '>' or '<'
>>> native_dt = np.dtype(native_code+'i2')
>>> swapped_dt = np.dtype(swapped_code+'i2')
>>> native_dt.newbyteorder('S') == swapped_dt
True
>>> native_dt.newbyteorder() == swapped_dt
True
>>> native_dt == swapped_dt.newbyteorder('S')
True
>>> native_dt == swapped_dt.newbyteorder('=')
True
>>> native_dt == swapped_dt.newbyteorder('N')
True
>>> native_dt == native_dt.newbyteorder('|')
True
>>> np.dtype('<i2') == native_dt.newbyteorder('<')
True
>>> np.dtype('<i2') == native_dt.newbyteorder('L')
True
>>> np.dtype('>i2') == native_dt.newbyteorder('>')
True
>>> np.dtype('>i2') == native_dt.newbyteorder('B')
True
numpy.dtype.num attribute   dtype.num
 
A unique number for each of the 21 different built-in types. These are roughly ordered from least-to-most precision. Examples >>> dt = np.dtype(str)
>>> dt.num
19
 >>> dt = np.dtype(float)
>>> dt.num
12
numpy.dtype.shape attribute   dtype.shape
 
Shape tuple of the sub-array if this data type describes a sub-array, and () otherwise. Examples >>> dt = np.dtype(('i4', 4))
>>> dt.shape
(4,)
 >>> dt = np.dtype(('i4', (2, 3)))
>>> dt.shape
(2, 3)
numpy.dtype.str attribute   dtype.str
 
The array-protocol typestring of this data-type object.
numpy.dtype.subdtype attribute   dtype.subdtype
 
Tuple (item_dtype, shape) if this dtype describes a sub-array, and None otherwise. The shape is the fixed shape of the sub-array described by this data type, and item_dtype the data type of the array. If a field whose dtype object has this attribute is retrieved, then the extra dimensions implied by shape are tacked on to the end of the retrieved array.  See also  dtype.base
  Examples >>> x = numpy.dtype('8f')
>>> x.subdtype
(dtype('float32'), (8,))
 >>> x =  numpy.dtype('i2')
>>> x.subdtype
>>>
numpy.errstate.__call__ method   errstate.__call__(func)
 
Call self as a function.
numpy.distutils.exec_command exec_command Implements exec_command function that is (almost) equivalent to commands.getstatusoutput function but on NT, DOS systems the returned status is actually correct (though, the returned status values may be different by a factor). In addition, exec_command takes keyword arguments for (re-)defining environment variables. Provides functions:  exec_command — execute command in a specified directory and

in the modified environment.  find_executable — locate a command using info from environment

variable PATH. Equivalent to posix which command.   Author: Pearu Peterson <pearu@cens.ioc.ee> Created: 11 January 2003 Requires: Python 2.x Successfully tested on:   
os.name sys.platform comments   
posix linux2 Debian (sid) Linux, Python 2.1.3+, 2.2.3+, 2.3.3 PyCrust 0.9.3, Idle 1.0.2  
posix linux2 Red Hat 9 Linux, Python 2.1.3, 2.2.2, 2.3.2  
posix sunos5 SunOS 5.9, Python 2.2, 2.3.2  
posix darwin Darwin 7.2.0, Python 2.3  
nt win32 Windows Me Python 2.3(EE), Idle 1.0, PyCrust 0.7.2 Python 2.1.1 Idle 0.8  
nt win32 Windows 98, Python 2.1.1. Idle 0.8  
nt win32 Cygwin 98-4.10, Python 2.1.1(MSC) - echo tests fail i.e. redefining environment variables may not work. FIXED: don’t use cygwin echo! Comment: also cmd /c echo will not work but redefining environment variables do work.  
posix cygwin Cygwin 98-4.10, Python 2.3.3(cygming special)  
nt win32 Windows XP, Python 2.3.3   Known bugs:  Tests, that send messages to stderr, fail when executed from MSYS prompt because the messages are lost at some point.  Functions  
exec_command(command[, execute_in, ...]) Return (status,output) of executed command.  
filepath_from_subprocess_output(output) Convert bytes in the encoding used by a subprocess into a filesystem-appropriate str.  
find_executable(exe[, path, _cache]) Return full path of a executable or None.  
forward_bytes_to_stdout(val) Forward bytes from a subprocess call to the console, without attempting to decode them.  
get_pythonexe()   
temp_file_name()