neulab/docprompting-conala huggingface dataset:
glob(pattern, exclude=None)  
Add a list of files to the current component as specified in the glob pattern. Individual files can be excluded in the exclude list.
start_component(component=None, feature=None, flags=None, keyfile=None, uuid=None)  
Add an entry to the Component table, and make this component the current component for this directory. If no component name is given, the directory name is used. If no feature is given, the current feature is used. If no flags are given, the directory’s default flags are used. If no keyfile is given, the KeyPath is left null in the Component table.
msilib.FCICreate(cabname, files)  
Create a new CAB file named cabname. files must be a list of tuples, each containing the name of the file on disk, and the name of the file inside the CAB file. The files are added to the CAB file in the order they appear in the list. All files are added into a single CAB file, using the MSZIP compression algorithm. Callbacks to Python for the various steps of MSI creation are currently not exposed.
class msilib.Feature(db, id, title, desc, display, level=1, parent=None, directory=None, attributes=0)  
Add a new record to the Feature table, using the values id, parent.id, title, desc, display, level, directory, and attributes. The resulting feature object can be passed to the start_component() method of Directory.  
set_current()  
Make this feature the current feature of msilib. New components are automatically added to the default feature, unless a feature is explicitly specified.
set_current()  
Make this feature the current feature of msilib. New components are automatically added to the default feature, unless a feature is explicitly specified.
msilib.gen_uuid()  
Return a new UUID, in the format that MSI typically requires (i.e. in curly braces, and with all hexdigits in upper-case).
msilib.init_database(name, schema, ProductName, ProductCode, ProductVersion, Manufacturer)  
Create and return a new database name, initialize it with schema, and set the properties ProductName, ProductCode, ProductVersion, and Manufacturer. schema must be a module object containing tables and _Validation_records attributes; typically, msilib.schema should be used. The database will contain just the schema and the validation records when this function returns.
msilib.OpenDatabase(path, persist)  
Return a new database object by calling MsiOpenDatabase. path is the file name of the MSI file; persist can be one of the constants MSIDBOPEN_CREATEDIRECT, MSIDBOPEN_CREATE, MSIDBOPEN_DIRECT, MSIDBOPEN_READONLY, or MSIDBOPEN_TRANSACT, and may include the flag MSIDBOPEN_PATCHFILE. See the Microsoft documentation for the meaning of these flags; depending on the flags, an existing database is opened, or a new one created.
class msilib.RadioButtonGroup(dlg, name, property)  
Create a radio button control named name. property is the installer property that gets set when a radio button is selected.  
add(name, x, y, width, height, text, value=None)  
Add a radio button named name to the group, at the coordinates x, y, width, height, and with the label text. If value is None, it defaults to name.
add(name, x, y, width, height, text, value=None)  
Add a radio button named name to the group, at the coordinates x, y, width, height, and with the label text. If value is None, it defaults to name.
Record.ClearData()  
Set all fields of the record to 0, through MsiRecordClearData().
Record.GetFieldCount()  
Return the number of fields of the record, through MsiRecordGetFieldCount().
Record.GetInteger(field)  
Return the value of field as an integer where possible. field must be an integer.
Record.GetString(field)  
Return the value of field as a string where possible. field must be an integer.
Record.SetInteger(field, value)  
Set field to value through MsiRecordSetInteger(). Both field and value must be an integer.
Record.SetStream(field, value)  
Set field to the contents of the file named value, through MsiRecordSetStream(). field must be an integer; value a string.
Record.SetString(field, value)  
Set field to value through MsiRecordSetString(). field must be an integer; value a string.
msilib.schema  
This is the standard MSI schema for MSI 2.0, with the tables variable providing a list of table definitions, and _Validation_records providing the data for MSI validation.
msilib.sequence  
This module contains table contents for the standard sequence tables: AdminExecuteSequence, AdminUISequence, AdvtExecuteSequence, InstallExecuteSequence, and InstallUISequence.
SummaryInformation.GetProperty(field)  
Return a property of the summary, through MsiSummaryInfoGetProperty(). field is the name of the property, and can be one of the constants PID_CODEPAGE, PID_TITLE, PID_SUBJECT, PID_AUTHOR, PID_KEYWORDS, PID_COMMENTS, PID_TEMPLATE, PID_LASTAUTHOR, PID_REVNUMBER, PID_LASTPRINTED, PID_CREATE_DTM, PID_LASTSAVE_DTM, PID_PAGECOUNT, PID_WORDCOUNT, PID_CHARCOUNT, PID_APPNAME, or PID_SECURITY.
SummaryInformation.GetPropertyCount()  
Return the number of summary properties, through MsiSummaryInfoGetPropertyCount().
SummaryInformation.Persist()  
Write the modified properties to the summary information stream, using MsiSummaryInfoPersist().
SummaryInformation.SetProperty(field, value)  
Set a property through MsiSummaryInfoSetProperty(). field can have the same values as in GetProperty(), value is the new value of the property. Possible value types are integer and string.
msilib.text  
This module contains definitions for the UIText and ActionText tables, for the standard installer actions.
msilib.UuidCreate()  
Return the string representation of a new unique identifier. This wraps the Windows API functions UuidCreate() and UuidToString().
View.Execute(params)  
Execute the SQL query of the view, through MSIViewExecute(). If params is not None, it is a record describing actual values of the parameter tokens in the query.
View.Fetch()  
Return a result record of the query, through calling MsiViewFetch().
View.GetColumnInfo(kind)  
Return a record describing the columns of the view, through calling MsiViewGetColumnInfo(). kind can be either MSICOLINFO_NAMES or MSICOLINFO_TYPES.
View.Modify(kind, data)  
Modify the view, by calling MsiViewModify(). kind can be one of MSIMODIFY_SEEK, MSIMODIFY_REFRESH, MSIMODIFY_INSERT, MSIMODIFY_UPDATE, MSIMODIFY_ASSIGN, MSIMODIFY_REPLACE, MSIMODIFY_MERGE, MSIMODIFY_DELETE, MSIMODIFY_INSERT_TEMPORARY, MSIMODIFY_VALIDATE, MSIMODIFY_VALIDATE_NEW, MSIMODIFY_VALIDATE_FIELD, or MSIMODIFY_VALIDATE_DELETE. data must be a record describing the new data.
msvcrt.getch()  
Read a keypress and return the resulting character as a byte string. Nothing is echoed to the console. This call will block if a keypress is not already available, but will not wait for Enter to be pressed. If the pressed key was a special function key, this will return '\000' or '\xe0'; the next call will return the keycode. The Control-C keypress cannot be read with this function.
msvcrt.getche()  
Similar to getch(), but the keypress will be echoed if it represents a printable character.
msvcrt.getwch()  
Wide char variant of getch(), returning a Unicode value.
msvcrt.getwche()  
Wide char variant of getche(), returning a Unicode value.
msvcrt.get_osfhandle(fd)  
Return the file handle for the file descriptor fd. Raises OSError if fd is not recognized. Raises an auditing event msvcrt.get_osfhandle with argument fd.
msvcrt.heapmin()  
Force the malloc() heap to clean itself up and return unused blocks to the operating system. On failure, this raises OSError.
msvcrt.kbhit()  
Return True if a keypress is waiting to be read.
msvcrt.LK_LOCK  
msvcrt.LK_RLCK  
Locks the specified bytes. If the bytes cannot be locked, the program immediately tries again after 1 second. If, after 10 attempts, the bytes cannot be locked, OSError is raised.
msvcrt.LK_NBLCK  
msvcrt.LK_NBRLCK  
Locks the specified bytes. If the bytes cannot be locked, OSError is raised.
msvcrt.LK_UNLCK  
Unlocks the specified bytes, which must have been previously locked.
msvcrt.locking(fd, mode, nbytes)  
Lock part of a file based on file descriptor fd from the C runtime. Raises OSError on failure. The locked region of the file extends from the current file position for nbytes bytes, and may continue beyond the end of the file. mode must be one of the LK_* constants listed below. Multiple regions in a file may be locked at the same time, but may not overlap. Adjacent regions are not merged; they must be unlocked individually. Raises an auditing event msvcrt.locking with arguments fd, mode, nbytes.
msvcrt.open_osfhandle(handle, flags)  
Create a C runtime file descriptor from the file handle handle. The flags parameter should be a bitwise OR of os.O_APPEND, os.O_RDONLY, and os.O_TEXT. The returned file descriptor may be used as a parameter to os.fdopen() to create a file object. Raises an auditing event msvcrt.open_osfhandle with arguments handle, flags.
msvcrt.putch(char)  
Print the byte string char to the console without buffering.
msvcrt.putwch(unicode_char)  
Wide char variant of putch(), accepting a Unicode value.
msvcrt.setmode(fd, flags)  
Set the line-end translation mode for the file descriptor fd. To set it to text mode, flags should be os.O_TEXT; for binary, it should be os.O_BINARY.
msvcrt.ungetch(char)  
Cause the byte string char to be “pushed back” into the console buffer; it will be the next character read by getch() or getche().
msvcrt.ungetwch(unicode_char)  
Wide char variant of ungetch(), accepting a Unicode value.
multiprocessing.active_children()  
Return list of all live children of the current process. Calling this has the side effect of “joining” any processes which have already finished.
multiprocessing.Array(typecode_or_type, size_or_initializer, *, lock=True)  
Return a ctypes array allocated from shared memory. By default the return value is actually a synchronized wrapper for the array. typecode_or_type determines the type of the elements of the returned array: it is either a ctypes type or a one character typecode of the kind used by the array module. If size_or_initializer is an integer, then it determines the length of the array, and the array will be initially zeroed. Otherwise, size_or_initializer is a sequence which is used to initialize the array and whose length determines the length of the array. If lock is True (the default) then a new lock object is created to synchronize access to the value. If lock is a Lock or RLock object then that will be used to synchronize access to the value. If lock is False then access to the returned object will not be automatically protected by a lock, so it will not necessarily be “process-safe”. Note that lock is a keyword only argument. Note that an array of ctypes.c_char has value and raw attributes which allow one to use it to store and retrieve strings.
class multiprocessing.Barrier(parties[, action[, timeout]])  
A barrier object: a clone of threading.Barrier.  New in version 3.3.
class multiprocessing.BoundedSemaphore([value])  
A bounded semaphore object: a close analog of threading.BoundedSemaphore. A solitary difference from its close analog exists: its acquire method’s first argument is named block, as is consistent with Lock.acquire().  Note On Mac OS X, this is indistinguishable from Semaphore because sem_getvalue() is not implemented on that platform.
exception multiprocessing.BufferTooShort  
Exception raised by Connection.recv_bytes_into() when the supplied buffer object is too small for the message read. If e is an instance of BufferTooShort then e.args[0] will give the message as a byte string.
class multiprocessing.Condition([lock])  
A condition variable: an alias for threading.Condition. If lock is specified then it should be a Lock or RLock object from multiprocessing.  Changed in version 3.3: The wait_for() method was added.
multiprocessing.connection.answer_challenge(connection, authkey)  
Receive a message, calculate the digest of the message using authkey as the key, and then send the digest back. If a welcome message is not received, then AuthenticationError is raised.
multiprocessing.connection.Client(address[, family[, authkey]])  
Attempt to set up a connection to the listener which is using address address, returning a Connection. The type of the connection is determined by family argument, but this can generally be omitted since it can usually be inferred from the format of address. (See Address Formats) If authkey is given and not None, it should be a byte string and will be used as the secret key for an HMAC-based authentication challenge. No authentication is done if authkey is None. AuthenticationError is raised if authentication fails. See Authentication keys.
class multiprocessing.connection.Connection  
 
send(obj)  
Send an object to the other end of the connection which should be read using recv(). The object must be picklable. Very large pickles (approximately 32 MiB+, though it depends on the OS) may raise a ValueError exception. 
  
recv()  
Return an object sent from the other end of the connection using send(). Blocks until there is something to receive. Raises EOFError if there is nothing left to receive and the other end was closed. 
  
fileno()  
Return the file descriptor or handle used by the connection. 
  
close()  
Close the connection. This is called automatically when the connection is garbage collected. 
  
poll([timeout])  
Return whether there is any data available to be read. If timeout is not specified then it will return immediately. If timeout is a number then this specifies the maximum time in seconds to block. If timeout is None then an infinite timeout is used. Note that multiple connection objects may be polled at once by using multiprocessing.connection.wait(). 
  
send_bytes(buffer[, offset[, size]])  
Send byte data from a bytes-like object as a complete message. If offset is given then data is read from that position in buffer. If size is given then that many bytes will be read from buffer. Very large buffers (approximately 32 MiB+, though it depends on the OS) may raise a ValueError exception 
  
recv_bytes([maxlength])  
Return a complete message of byte data sent from the other end of the connection as a string. Blocks until there is something to receive. Raises EOFError if there is nothing left to receive and the other end has closed. If maxlength is specified and the message is longer than maxlength then OSError is raised and the connection will no longer be readable.  Changed in version 3.3: This function used to raise IOError, which is now an alias of OSError.  
  
recv_bytes_into(buffer[, offset])  
Read into buffer a complete message of byte data sent from the other end of the connection and return the number of bytes in the message. Blocks until there is something to receive. Raises EOFError if there is nothing left to receive and the other end was closed. buffer must be a writable bytes-like object. If offset is given then the message will be written into the buffer from that position. Offset must be a non-negative integer less than the length of buffer (in bytes). If the buffer is too short then a BufferTooShort exception is raised and the complete message is available as e.args[0] where e is the exception instance. 
  Changed in version 3.3: Connection objects themselves can now be transferred between processes using Connection.send() and Connection.recv().   New in version 3.3: Connection objects now support the context management protocol – see Context Manager Types. __enter__() returns the connection object, and __exit__() calls close().
poll([timeout])  
Return whether there is any data available to be read. If timeout is not specified then it will return immediately. If timeout is a number then this specifies the maximum time in seconds to block. If timeout is None then an infinite timeout is used. Note that multiple connection objects may be polled at once by using multiprocessing.connection.wait().
recv()  
Return an object sent from the other end of the connection using send(). Blocks until there is something to receive. Raises EOFError if there is nothing left to receive and the other end was closed.
recv_bytes([maxlength])  
Return a complete message of byte data sent from the other end of the connection as a string. Blocks until there is something to receive. Raises EOFError if there is nothing left to receive and the other end has closed. If maxlength is specified and the message is longer than maxlength then OSError is raised and the connection will no longer be readable.  Changed in version 3.3: This function used to raise IOError, which is now an alias of OSError.
recv_bytes_into(buffer[, offset])  
Read into buffer a complete message of byte data sent from the other end of the connection and return the number of bytes in the message. Blocks until there is something to receive. Raises EOFError if there is nothing left to receive and the other end was closed. buffer must be a writable bytes-like object. If offset is given then the message will be written into the buffer from that position. Offset must be a non-negative integer less than the length of buffer (in bytes). If the buffer is too short then a BufferTooShort exception is raised and the complete message is available as e.args[0] where e is the exception instance.
send(obj)  
Send an object to the other end of the connection which should be read using recv(). The object must be picklable. Very large pickles (approximately 32 MiB+, though it depends on the OS) may raise a ValueError exception.
send_bytes(buffer[, offset[, size]])  
Send byte data from a bytes-like object as a complete message. If offset is given then data is read from that position in buffer. If size is given then that many bytes will be read from buffer. Very large buffers (approximately 32 MiB+, though it depends on the OS) may raise a ValueError exception
multiprocessing.connection.deliver_challenge(connection, authkey)  
Send a randomly generated message to the other end of the connection and wait for a reply. If the reply matches the digest of the message using authkey as the key then a welcome message is sent to the other end of the connection. Otherwise AuthenticationError is raised.
class multiprocessing.connection.Listener([address[, family[, backlog[, authkey]]]])  
A wrapper for a bound socket or Windows named pipe which is ‘listening’ for connections. address is the address to be used by the bound socket or named pipe of the listener object.  Note If an address of ‘0.0.0.0’ is used, the address will not be a connectable end point on Windows. If you require a connectable end-point, you should use ‘127.0.0.1’.  family is the type of socket (or named pipe) to use. This can be one of the strings 'AF_INET' (for a TCP socket), 'AF_UNIX' (for a Unix domain socket) or 'AF_PIPE' (for a Windows named pipe). Of these only the first is guaranteed to be available. If family is None then the family is inferred from the format of address. If address is also None then a default is chosen. This default is the family which is assumed to be the fastest available. See Address Formats. Note that if family is 'AF_UNIX' and address is None then the socket will be created in a private temporary directory created using tempfile.mkstemp(). If the listener object uses a socket then backlog (1 by default) is passed to the listen() method of the socket once it has been bound. If authkey is given and not None, it should be a byte string and will be used as the secret key for an HMAC-based authentication challenge. No authentication is done if authkey is None. AuthenticationError is raised if authentication fails. See Authentication keys.  
accept()  
Accept a connection on the bound socket or named pipe of the listener object and return a Connection object. If authentication is attempted and fails, then AuthenticationError is raised. 
  
close()  
Close the bound socket or named pipe of the listener object. This is called automatically when the listener is garbage collected. However it is advisable to call it explicitly. 
 Listener objects have the following read-only properties:  
address  
The address which is being used by the Listener object. 
  
last_accepted  
The address from which the last accepted connection came. If this is unavailable then it is None. 
  New in version 3.3: Listener objects now support the context management protocol – see Context Manager Types. __enter__() returns the listener object, and __exit__() calls close().
accept()  
Accept a connection on the bound socket or named pipe of the listener object and return a Connection object. If authentication is attempted and fails, then AuthenticationError is raised.
close()  
Close the bound socket or named pipe of the listener object. This is called automatically when the listener is garbage collected. However it is advisable to call it explicitly.
last_accepted  
The address from which the last accepted connection came. If this is unavailable then it is None.
multiprocessing.connection.wait(object_list, timeout=None)  
Wait till an object in object_list is ready. Returns the list of those objects in object_list which are ready. If timeout is a float then the call blocks for at most that many seconds. If timeout is None then it will block for an unlimited period. A negative timeout is equivalent to a zero timeout. For both Unix and Windows, an object can appear in object_list if it is  a readable Connection object; a connected and readable socket.socket object; or the sentinel attribute of a Process object.  A connection or socket object is ready when there is data available to be read from it, or the other end has been closed. Unix: wait(object_list, timeout) almost equivalent select.select(object_list, [], [], timeout). The difference is that, if select.select() is interrupted by a signal, it can raise OSError with an error number of EINTR, whereas wait() will not. Windows: An item in object_list must either be an integer handle which is waitable (according to the definition used by the documentation of the Win32 function WaitForMultipleObjects()) or it can be an object with a fileno() method which returns a socket handle or pipe handle. (Note that pipe handles and socket handles are not waitable handles.)  New in version 3.3.
multiprocessing.cpu_count()  
Return the number of CPUs in the system. This number is not equivalent to the number of CPUs the current process can use. The number of usable CPUs can be obtained with len(os.sched_getaffinity(0)) May raise NotImplementedError.  See also os.cpu_count()
multiprocessing.current_process()  
Return the Process object corresponding to the current process. An analogue of threading.current_thread().
multiprocessing.freeze_support()  
Add support for when a program which uses multiprocessing has been frozen to produce a Windows executable. (Has been tested with py2exe, PyInstaller and cx_Freeze.) One needs to call this function straight after the if __name__ ==
'__main__' line of the main module. For example: from multiprocessing import Process, freeze_support

def f():
    print('hello world!')

if __name__ == '__main__':
    freeze_support()
    Process(target=f).start()
 If the freeze_support() line is omitted then trying to run the frozen executable will raise RuntimeError. Calling freeze_support() has no effect when invoked on any operating system other than Windows. In addition, if the module is being run normally by the Python interpreter on Windows (the program has not been frozen), then freeze_support() has no effect.
multiprocessing.get_all_start_methods()  
Returns a list of the supported start methods, the first of which is the default. The possible start methods are 'fork', 'spawn' and 'forkserver'. On Windows only 'spawn' is available. On Unix 'fork' and 'spawn' are always supported, with 'fork' being the default.  New in version 3.4.
multiprocessing.get_context(method=None)  
Return a context object which has the same attributes as the multiprocessing module. If method is None then the default context is returned. Otherwise method should be 'fork', 'spawn', 'forkserver'. ValueError is raised if the specified start method is not available.  New in version 3.4.