doc_content stringlengths 1 386k | doc_id stringlengths 5 188 |
|---|---|
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. | python.library.msilib#msilib.schema |
msilib.sequence
This module contains table contents for the standard sequence tables: AdminExecuteSequence, AdminUISequence, AdvtExecuteSequence, InstallExecuteSequence, and InstallUISequence. | python.library.msilib#msilib.sequence |
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, PI... | python.library.msilib#msilib.SummaryInformation.GetProperty |
SummaryInformation.GetPropertyCount()
Return the number of summary properties, through MsiSummaryInfoGetPropertyCount(). | python.library.msilib#msilib.SummaryInformation.GetPropertyCount |
SummaryInformation.Persist()
Write the modified properties to the summary information stream, using MsiSummaryInfoPersist(). | python.library.msilib#msilib.SummaryInformation.Persist |
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. | python.library.msilib#msilib.SummaryInformation.SetProperty |
msilib.text
This module contains definitions for the UIText and ActionText tables, for the standard installer actions. | python.library.msilib#msilib.text |
msilib.UuidCreate()
Return the string representation of a new unique identifier. This wraps the Windows API functions UuidCreate() and UuidToString(). | python.library.msilib#msilib.UuidCreate |
View.Close()
Close the view, through MsiViewClose(). | python.library.msilib#msilib.View.Close |
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. | python.library.msilib#msilib.View.Execute |
View.Fetch()
Return a result record of the query, through calling MsiViewFetch(). | python.library.msilib#msilib.View.Fetch |
View.GetColumnInfo(kind)
Return a record describing the columns of the view, through calling MsiViewGetColumnInfo(). kind can be either MSICOLINFO_NAMES or MSICOLINFO_TYPES. | python.library.msilib#msilib.View.GetColumnInfo |
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_VALID... | python.library.msilib#msilib.View.Modify |
msvcrt — Useful routines from the MS VC++ runtime These functions provide access to some useful capabilities on Windows platforms. Some higher-level modules use these functions to build the Windows implementations of their services. For example, the getpass module uses this in the implementation of the getpass() functi... | python.library.msvcrt |
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 ... | python.library.msvcrt#msvcrt.getch |
msvcrt.getche()
Similar to getch(), but the keypress will be echoed if it represents a printable character. | python.library.msvcrt#msvcrt.getche |
msvcrt.getwch()
Wide char variant of getch(), returning a Unicode value. | python.library.msvcrt#msvcrt.getwch |
msvcrt.getwche()
Wide char variant of getche(), returning a Unicode value. | python.library.msvcrt#msvcrt.getwche |
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. | python.library.msvcrt#msvcrt.get_osfhandle |
msvcrt.heapmin()
Force the malloc() heap to clean itself up and return unused blocks to the operating system. On failure, this raises OSError. | python.library.msvcrt#msvcrt.heapmin |
msvcrt.kbhit()
Return True if a keypress is waiting to be read. | python.library.msvcrt#msvcrt.kbhit |
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. | python.library.msvcrt#msvcrt.LK_LOCK |
msvcrt.LK_NBLCK
msvcrt.LK_NBRLCK
Locks the specified bytes. If the bytes cannot be locked, OSError is raised. | python.library.msvcrt#msvcrt.LK_NBLCK |
msvcrt.LK_NBLCK
msvcrt.LK_NBRLCK
Locks the specified bytes. If the bytes cannot be locked, OSError is raised. | python.library.msvcrt#msvcrt.LK_NBRLCK |
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. | python.library.msvcrt#msvcrt.LK_RLCK |
msvcrt.LK_UNLCK
Unlocks the specified bytes, which must have been previously locked. | python.library.msvcrt#msvcrt.LK_UNLCK |
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. Multi... | python.library.msvcrt#msvcrt.locking |
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.op... | python.library.msvcrt#msvcrt.open_osfhandle |
msvcrt.putch(char)
Print the byte string char to the console without buffering. | python.library.msvcrt#msvcrt.putch |
msvcrt.putwch(unicode_char)
Wide char variant of putch(), accepting a Unicode value. | python.library.msvcrt#msvcrt.putwch |
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. | python.library.msvcrt#msvcrt.setmode |
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(). | python.library.msvcrt#msvcrt.ungetch |
msvcrt.ungetwch(unicode_char)
Wide char variant of ungetch(), accepting a Unicode value. | python.library.msvcrt#msvcrt.ungetwch |
multiprocessing — Process-based parallelism Source code: Lib/multiprocessing/ Introduction multiprocessing is a package that supports spawning processes using an API similar to the threading module. The multiprocessing package offers both local and remote concurrency, effectively side-stepping the Global Interpreter Lo... | python.library.multiprocessing |
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. | python.library.multiprocessing#multiprocessing.active_children |
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 c... | python.library.multiprocessing#multiprocessing.Array |
exception multiprocessing.AuthenticationError
Raised when there is an authentication error. | python.library.multiprocessing#multiprocessing.AuthenticationError |
class multiprocessing.Barrier(parties[, action[, timeout]])
A barrier object: a clone of threading.Barrier. New in version 3.3. | python.library.multiprocessing#multiprocessing.Barrier |
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 Sema... | python.library.multiprocessing#multiprocessing.BoundedSemaphore |
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. | python.library.multiprocessing#multiprocessing.BufferTooShort |
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. | python.library.multiprocessing#multiprocessing.Condition |
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. | python.library.multiprocessing#multiprocessing.connection.answer_challenge |
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 addr... | python.library.multiprocessing#multiprocessing.connection.Client |
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... | python.library.multiprocessing#multiprocessing.connection.Connection |
close()
Close the connection. This is called automatically when the connection is garbage collected. | python.library.multiprocessing#multiprocessing.connection.Connection.close |
fileno()
Return the file descriptor or handle used by the connection. | python.library.multiprocessing#multiprocessing.connection.Connection.fileno |
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 ... | python.library.multiprocessing#multiprocessing.connection.Connection.poll |
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. | python.library.multiprocessing#multiprocessing.connection.Connection.recv |
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 OS... | python.library.multiprocessing#multiprocessing.connection.Connection.recv_bytes |
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 wri... | python.library.multiprocessing#multiprocessing.connection.Connection.recv_bytes_into |
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. | python.library.multiprocessing#multiprocessing.connection.Connection.send |
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 Val... | python.library.multiprocessing#multiprocessing.connection.Connection.send_bytes |
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 Authenticati... | python.library.multiprocessing#multiprocessing.connection.deliver_challenge |
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 addres... | python.library.multiprocessing#multiprocessing.connection.Listener |
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. | python.library.multiprocessing#multiprocessing.connection.Listener.accept |
address
The address which is being used by the Listener object. | python.library.multiprocessing#multiprocessing.connection.Listener.address |
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. | python.library.multiprocessing#multiprocessing.connection.Listener.close |
last_accepted
The address from which the last accepted connection came. If this is unavailable then it is None. | python.library.multiprocessing#multiprocessing.connection.Listener.last_accepted |
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 ... | python.library.multiprocessing#multiprocessing.connection.wait |
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() | python.library.multiprocessing#multiprocessing.cpu_count |
multiprocessing.current_process()
Return the Process object corresponding to the current process. An analogue of threading.current_thread(). | python.library.multiprocessing#multiprocessing.current_process |
class multiprocessing.Event
A clone of threading.Event. | python.library.multiprocessing#multiprocessing.Event |
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 ... | python.library.multiprocessing#multiprocessing.freeze_support |
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 versi... | python.library.multiprocessing#multiprocessing.get_all_start_methods |
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 v... | python.library.multiprocessing#multiprocessing.get_context |
multiprocessing.get_logger()
Returns the logger used by multiprocessing. If necessary, a new one will be created. When first created the logger has level logging.NOTSET and no default handler. Messages sent to this logger will not by default propagate to the root logger. Note that on Windows child processes will only... | python.library.multiprocessing#multiprocessing.get_logger |
multiprocessing.get_start_method(allow_none=False)
Return the name of start method used for starting processes. If the start method has not been fixed and allow_none is false, then the start method is fixed to the default and the name is returned. If the start method has not been fixed and allow_none is true then Non... | python.library.multiprocessing#multiprocessing.get_start_method |
class multiprocessing.JoinableQueue([maxsize])
JoinableQueue, a Queue subclass, is a queue which additionally has task_done() and join() methods.
task_done()
Indicate that a formerly enqueued task is complete. Used by queue consumers. For each get() used to fetch a task, a subsequent call to task_done() tells the... | python.library.multiprocessing#multiprocessing.JoinableQueue |
join()
Block until all items in the queue have been gotten and processed. The count of unfinished tasks goes up whenever an item is added to the queue. The count goes down whenever a consumer calls task_done() to indicate that the item was retrieved and all work on it is complete. When the count of unfinished tasks d... | python.library.multiprocessing#multiprocessing.JoinableQueue.join |
task_done()
Indicate that a formerly enqueued task is complete. Used by queue consumers. For each get() used to fetch a task, a subsequent call to task_done() tells the queue that the processing on the task is complete. If a join() is currently blocking, it will resume when all items have been processed (meaning that... | python.library.multiprocessing#multiprocessing.JoinableQueue.task_done |
class multiprocessing.Lock
A non-recursive lock object: a close analog of threading.Lock. Once a process or thread has acquired a lock, subsequent attempts to acquire it from any process or thread will block until it is released; any process or thread may release it. The concepts and behaviors of threading.Lock as it... | python.library.multiprocessing#multiprocessing.Lock |
acquire(block=True, timeout=None)
Acquire a lock, blocking or non-blocking. With the block argument set to True (the default), the method call will block until the lock is in an unlocked state, then set it to locked and return True. Note that the name of this first argument differs from that in threading.Lock.acquire... | python.library.multiprocessing#multiprocessing.Lock.acquire |
release()
Release a lock. This can be called from any process or thread, not only the process or thread which originally acquired the lock. Behavior is the same as in threading.Lock.release() except that when invoked on an unlocked lock, a ValueError is raised. | python.library.multiprocessing#multiprocessing.Lock.release |
multiprocessing.log_to_stderr()
This function performs a call to get_logger() but in addition to returning the logger created by get_logger, it adds a handler which sends output to sys.stderr using format '[%(levelname)s/%(processName)s] %(message)s'. | python.library.multiprocessing#multiprocessing.log_to_stderr |
class multiprocessing.managers.BaseManager([address[, authkey]])
Create a BaseManager object. Once created one should call start() or get_server().serve_forever() to ensure that the manager object refers to a started manager process. address is the address on which the manager process listens for new connections. If ... | python.library.multiprocessing#multiprocessing.managers.BaseManager |
address
The address used by the manager. | python.library.multiprocessing#multiprocessing.managers.BaseManager.address |
connect()
Connect a local manager object to a remote manager process: >>> from multiprocessing.managers import BaseManager
>>> m = BaseManager(address=('127.0.0.1', 50000), authkey=b'abc')
>>> m.connect() | python.library.multiprocessing#multiprocessing.managers.BaseManager.connect |
get_server()
Returns a Server object which represents the actual server under the control of the Manager. The Server object supports the serve_forever() method: >>> from multiprocessing.managers import BaseManager
>>> manager = BaseManager(address=('', 50000), authkey=b'abc')
>>> server = manager.get_server()
>>> ser... | python.library.multiprocessing#multiprocessing.managers.BaseManager.get_server |
register(typeid[, callable[, proxytype[, exposed[, method_to_typeid[, create_method]]]]])
A classmethod which can be used for registering a type or callable with the manager class. typeid is a “type identifier” which is used to identify a particular type of shared object. This must be a string. callable is a callable... | python.library.multiprocessing#multiprocessing.managers.BaseManager.register |
shutdown()
Stop the process used by the manager. This is only available if start() has been used to start the server process. This can be called multiple times. | python.library.multiprocessing#multiprocessing.managers.BaseManager.shutdown |
start([initializer[, initargs]])
Start a subprocess to start the manager. If initializer is not None then the subprocess will call initializer(*initargs) when it starts. | python.library.multiprocessing#multiprocessing.managers.BaseManager.start |
class multiprocessing.managers.BaseProxy
Proxy objects are instances of subclasses of BaseProxy.
_callmethod(methodname[, args[, kwds]])
Call and return the result of a method of the proxy’s referent. If proxy is a proxy whose referent is obj then the expression proxy._callmethod(methodname, args, kwds)
will eva... | python.library.multiprocessing#multiprocessing.managers.BaseProxy |
_callmethod(methodname[, args[, kwds]])
Call and return the result of a method of the proxy’s referent. If proxy is a proxy whose referent is obj then the expression proxy._callmethod(methodname, args, kwds)
will evaluate the expression getattr(obj, methodname)(*args, **kwds)
in the manager’s process. The returned ... | python.library.multiprocessing#multiprocessing.managers.BaseProxy._callmethod |
_getvalue()
Return a copy of the referent. If the referent is unpicklable then this will raise an exception. | python.library.multiprocessing#multiprocessing.managers.BaseProxy._getvalue |
__repr__()
Return a representation of the proxy object. | python.library.multiprocessing#multiprocessing.managers.BaseProxy.__repr__ |
__str__()
Return the representation of the referent. | python.library.multiprocessing#multiprocessing.managers.BaseProxy.__str__ |
class multiprocessing.managers.Namespace
A type that can register with SyncManager. A namespace object has no public methods, but does have writable attributes. Its representation shows the values of its attributes. However, when using a proxy for a namespace object, an attribute beginning with '_' will be an attribu... | python.library.multiprocessing#multiprocessing.managers.Namespace |
class multiprocessing.managers.SharedMemoryManager([address[, authkey]])
A subclass of BaseManager which can be used for the management of shared memory blocks across processes. A call to start() on a SharedMemoryManager instance causes a new process to be started. This new process’s sole purpose is to manage the lif... | python.library.multiprocessing.shared_memory#multiprocessing.managers.SharedMemoryManager |
ShareableList(sequence)
Create and return a new ShareableList object, initialized by the values from the input sequence. | python.library.multiprocessing.shared_memory#multiprocessing.managers.SharedMemoryManager.ShareableList |
SharedMemory(size)
Create and return a new SharedMemory object with the specified size in bytes. | python.library.multiprocessing.shared_memory#multiprocessing.managers.SharedMemoryManager.SharedMemory |
class multiprocessing.managers.SyncManager
A subclass of BaseManager which can be used for the synchronization of processes. Objects of this type are returned by multiprocessing.Manager(). Its methods create and return Proxy Objects for a number of commonly used data types to be synchronized across processes. This no... | python.library.multiprocessing#multiprocessing.managers.SyncManager |
Array(typecode, sequence)
Create an array and return a proxy for it. | python.library.multiprocessing#multiprocessing.managers.SyncManager.Array |
Barrier(parties[, action[, timeout]])
Create a shared threading.Barrier object and return a proxy for it. New in version 3.3. | python.library.multiprocessing#multiprocessing.managers.SyncManager.Barrier |
BoundedSemaphore([value])
Create a shared threading.BoundedSemaphore object and return a proxy for it. | python.library.multiprocessing#multiprocessing.managers.SyncManager.BoundedSemaphore |
Condition([lock])
Create a shared threading.Condition object and return a proxy for it. If lock is supplied then it should be a proxy for a threading.Lock or threading.RLock object. Changed in version 3.3: The wait_for() method was added. | python.library.multiprocessing#multiprocessing.managers.SyncManager.Condition |
dict()
dict(mapping)
dict(sequence)
Create a shared dict object and return a proxy for it. | python.library.multiprocessing#multiprocessing.managers.SyncManager.dict |
Event()
Create a shared threading.Event object and return a proxy for it. | python.library.multiprocessing#multiprocessing.managers.SyncManager.Event |
list()
list(sequence)
Create a shared list object and return a proxy for it. | python.library.multiprocessing#multiprocessing.managers.SyncManager.list |
Lock()
Create a shared threading.Lock object and return a proxy for it. | python.library.multiprocessing#multiprocessing.managers.SyncManager.Lock |
Namespace()
Create a shared Namespace object and return a proxy for it. | python.library.multiprocessing#multiprocessing.managers.SyncManager.Namespace |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.