本文整理汇总了Python中pywincffi.core.dist.load函数的典型用法代码示例。如果您正苦于以下问题:Python load函数的具体用法?Python load怎么用?Python load使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了load函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: CreateEvent
def CreateEvent(
bManualReset, bInitialState, lpEventAttributes=None, lpName=None):
"""
Creates or opens an named or unnamed event object.
.. seealso::
https://msdn.microsoft.com/en-us/library/ms682396
:param bool bManualReset:
If True then this function will create a manual reset
event which must be manually reset with :func:`ResetEvent`. Refer
to the msdn documentation for full information.
:param bool bInitialState:
If True the initial state will be 'signaled'.
:keyword :class:`pywincffi.wintypes.SECURITY_ATTRIBUTES` lpEventAttributes:
If not provided then, by default, the handle cannot be inherited
by a subprocess.
:keyword str lpName:
Type is ``unicode`` on Python 2, ``str`` on Python 3.
The optional case-sensitive name of the event. If not provided then
the event will be created without an explicit name.
:returns:
Returns a :class:`pywincffi.wintypes.HANDLE` to the event. If an event
by the given name already exists then it will be returned instead of
creating a new event.
"""
input_check("bManualReset", bManualReset, bool)
input_check("bInitialState", bInitialState, bool)
ffi, library = dist.load()
if lpName is None:
lpName = ffi.NULL
else:
input_check("lpName", lpName, text_type)
input_check(
"lpEventAttributes", lpEventAttributes,
allowed_types=(SECURITY_ATTRIBUTES, NoneType)
)
handle = library.CreateEvent(
wintype_to_cdata(lpEventAttributes),
ffi.cast("BOOL", bManualReset),
ffi.cast("BOOL", bInitialState),
lpName
)
try:
error_check("CreateEvent")
except WindowsAPIError as error:
if error.errno != library.ERROR_ALREADY_EXISTS:
raise
return HANDLE(handle)
示例2: OpenEvent
def OpenEvent(dwDesiredAccess, bInheritHandle, lpName):
"""
Opens an existing named event.
.. seealso::
https://msdn.microsoft.com/en-us/library/ms684305
:param int dwDesiredAccess:
The access desired for the event object.
:param bool bInheritHandle:
:param str lpName:
Type is ``unicode`` on Python 2, ``str`` on Python 3.
:return:
Returns a :class:`pywincffi.wintypes.HANDLE` to the event.
"""
input_check("dwDesiredAccess", dwDesiredAccess, integer_types)
input_check("bInheritHandle", bInheritHandle, bool)
input_check("lpName", lpName, text_type)
ffi, library = dist.load()
handle = library.OpenEvent(
ffi.cast("DWORD", dwDesiredAccess),
ffi.cast("BOOL", bInheritHandle),
lpName
)
error_check("OpenEvent")
return HANDLE(handle)
示例3: test_signaled
def test_signaled(self):
handle = CreateEvent(bManualReset=True, bInitialState=False)
self.addCleanup(CloseHandle, handle)
_, library = dist.load()
SetEvent(handle)
self.assertEqual(
WaitForSingleObject(handle, 0), library.WAIT_OBJECT_0)
示例4: test_resets_event
def test_resets_event(self):
handle = CreateEvent(bManualReset=True, bInitialState=True)
self.addCleanup(CloseHandle, handle)
ResetEvent(handle)
_, library = dist.load()
self.assertEqual(WaitForSingleObject(handle, 0), library.WAIT_TIMEOUT)
示例5: test_create_console
def test_create_console(self):
_, library = dist.load()
handle = CreateConsoleScreenBuffer(
library.GENERIC_READ | library.GENERIC_WRITE,
None, lpSecurityAttributes=None, dwFlags=None,
)
self.addCleanup(CloseHandle, handle)
示例6: ClearCommError
def ClearCommError(hFile):
"""
Retrieves information about a communications error and reports the
current status of a communications device.
.. seealso::
https://msdn.microsoft.com/en-us/aa363180
:param pywincffi.wintypes.HANDLE hFile:
A handle to the communications device, typically created by
:func:`CreateFile`
:rtype: tuple
:return:
Returns a two element tuple containing the ``lpErrors`` and
``lpStat`` result objects.
* ``lpErrors`` - Contains the mast indicating the type of error
* ``lpStat`` - A ``COMSTAT`` structure which contains the device's
information.
"""
input_check("hFile", hFile, HANDLE)
ffi, library = dist.load()
lpErrors = ffi.new("LPDWORD")
lpStat = ffi.new("LPCOMSTAT")
code = library.ClearCommError(wintype_to_cdata(hFile), lpErrors, lpStat)
error_check("ClearCommError", code=code, expected=Enums.NON_ZERO)
# TODO: Build Python instance of COMSTAT here!
return lpErrors, lpStat
示例7: test_collect_data_timeout_fail
def test_collect_data_timeout_fail(self):
# should fail: only supported with named pipes
with self.assertRaises(WindowsAPIError):
self._set_collect_data_timeout(500)
_, library = dist.load()
self.assert_last_error(library.ERROR_INVALID_PARAMETER)
示例8: WriteFile
def WriteFile(hFile, lpBuffer, nNumberOfBytesToWrite=None, lpOverlapped=None):
"""
Writes data to ``hFile`` which may be an I/O device for file.
.. seealso::
https://msdn.microsoft.com/en-us/library/aa365747
:param pywincffi.wintypes.HANDLE hFile:
The handle to write to.
:type lpBuffer: str/bytes
:param lpBuffer:
Type is ``str`` on Python 2, ``bytes`` on Python 3.
The data to be written to the file or device.
:keyword int nNumberOfBytesToWrite:
The number of bytes to be written. Defaults to len(lpBuffer).
:keyword pywincffi.wintypes.OVERLAPPED lpOverlapped:
See Microsoft's documentation for intended usage and below for
an example.
>>> from pywincffi.core import dist
>>> from pywincffi.kernel32 import WriteFile, CreateEvent
>>> from pywincffi.wintypes import OVERLAPPED
>>> hEvent = CreateEvent(...)
>>> lpOverlapped = OVERLAPPED()
>>> lpOverlapped.hEvent = hEvent
>>> bytes_written = WriteFile(
... hFile, "Hello world", lpOverlapped=lpOverlapped)
:returns:
Returns the number of bytes written.
"""
ffi, library = dist.load()
input_check("hFile", hFile, HANDLE)
input_check("lpBuffer", lpBuffer, binary_type)
input_check(
"lpOverlapped", lpOverlapped,
allowed_types=(NoneType, OVERLAPPED)
)
if nNumberOfBytesToWrite is None:
nNumberOfBytesToWrite = len(lpBuffer)
else:
input_check(
"nNumberOfBytesToWrite", nNumberOfBytesToWrite,
integer_types
)
bytes_written = ffi.new("LPDWORD")
code = library.WriteFile(
wintype_to_cdata(hFile), lpBuffer, nNumberOfBytesToWrite,
bytes_written, wintype_to_cdata(lpOverlapped)
)
error_check("WriteFile", code=code, expected=Enums.NON_ZERO)
return bytes_written[0]
示例9: SetConsoleTextAttribute
def SetConsoleTextAttribute(hConsoleOutput, wAttributes):
"""
Sets the attributes of characters written to a console buffer.
.. seealso::
https://docs.microsoft.com/en-us/windows/console/setconsoletextattribute
:param pywincffi.wintypes.HANDLE hConsoleOutput:
A handle to the console screen buffer. The handle must have the
``GENERIC_READ`` access right.
:param int wAttributes:
The character attribute(s) to set.
"""
input_check("hConsoleOutput", hConsoleOutput, HANDLE)
input_check("wAttributes", wAttributes, integer_types)
ffi, library = dist.load()
# raise Exception(type(wAttributes))
# info = ffi.new("PCHAR_INFO")
code = library.SetConsoleTextAttribute(
wintype_to_cdata(hConsoleOutput),
ffi.cast("ATOM", wAttributes)
)
error_check("SetConsoleTextAttribute", code=code, expected=NON_ZERO)
示例10: SetHandleInformation
def SetHandleInformation(hObject, dwMask, dwFlags):
"""
Sets properties of an object handle.
.. seealso::
https://msdn.microsoft.com/en-us/ms724935
:param pywincffi.wintypes.HANDLE hObject:
A handle to an object whose information is to be set.
:param int dwMask:
A mask that specifies the bit flags to be changed.
:param int dwFlags:
Set of bit flags that specifies properties of ``hObject``.
"""
input_check("hObject", hObject, HANDLE)
input_check("dwMask", dwMask, integer_types)
input_check("dwFlags", dwFlags, integer_types)
ffi, library = dist.load()
code = library.SetHandleInformation(
wintype_to_cdata(hObject),
ffi.cast("DWORD", dwMask),
ffi.cast("DWORD", dwFlags)
)
error_check("SetHandleInformation", code=code, expected=Enums.NON_ZERO)
示例11: GetStdHandle
def GetStdHandle(nStdHandle):
"""
Retrieves a handle to the specified standard
device (standard input, standard output, or standard error).
.. seealso::
https://msdn.microsoft.com/en-us/library/ms683231
:param int nStdHandle:
The standard device to retrieve.
:rtype: pywincffi.wintypes.HANDLE
:return:
Returns a handle to the standard device retrieved.
"""
_, library = dist.load()
input_check("nStdHandle", nStdHandle,
allowed_values=(library.STD_INPUT_HANDLE,
library.STD_OUTPUT_HANDLE,
library.STD_ERROR_HANDLE))
handle = library.GetStdHandle(nStdHandle)
if handle == library.INVALID_HANDLE_VALUE: # pragma: no cover
raise WindowsAPIError(
"GetStdHandle", "Invalid Handle", library.INVALID_HANDLE_VALUE,
expected_return_code="not %r" % library.INVALID_HANDLE_VALUE)
return HANDLE(handle)
示例12: test_type_check_on_pHandles_input_not_list
def test_type_check_on_pHandles_input_not_list(self):
_, library = dist.load()
e1 = CreateEvent(True, False)
self.addCleanup(CloseHandle, e1)
with self.assertRaises(InputError):
MsgWaitForMultipleObjects(e1, False, 0, library.QS_ALLEVENTS)
示例13: test_dwCreationFlags_CREATE_NO_WINDOW
def test_dwCreationFlags_CREATE_NO_WINDOW(self):
"""
If we call CreateProcess() with dwCreationFlags set and
pass in an environmnet, internally it must internally add
CREATE_UNICODE_ENVIRONMENT to dwCreationFlags. Otherwise it
will fail due to an invalid parameter.
"""
_, library = dist.load()
env = {}
for key, val in iteritems(os.environ):
if isinstance(key, bytes):
key = key.decode(sys.getfilesystemencoding())
if isinstance(val, bytes):
val = val.decode(sys.getfilesystemencoding())
env[key] = val
process = CreateProcess(
lpCommandLine=u"{0} -c \"\"".format(sys.executable),
lpApplicationName=None,
lpProcessAttributes=None,
lpThreadAttributes=None,
bInheritHandles=True,
dwCreationFlags=library.CREATE_NO_WINDOW,
lpEnvironment=env,
lpCurrentDirectory=None,
lpStartupInfo=None
)
self.assertIsInstance(process, CreateProcessResult)
self.addCleanup(self.cleanup_process, process)
示例14: GetExitCodeProcess
def GetExitCodeProcess(hProcess):
"""
Retrieves the exit code of the given process handle. To retrieve
a process handle use :func:`OpenProcess`.
.. warning::
You may want to use :func:`process_exit_code` instead of this
function if you're just checking to see if a process has
exited at all.
.. seealso::
https://msdn.microsoft.com/en-us/library/ms683189
:param pywincffi.wintypes.HANDLE hProcess:
The handle of the process to retrieve the exit code for.
:returns:
Returns the exit code of the requested process if one
can be found.
"""
input_check("hProcess", hProcess, HANDLE)
ffi, library = dist.load()
lpExitCode = ffi.new("LPDWORD")
code = library.GetExitCodeProcess(wintype_to_cdata(hProcess), lpExitCode)
error_check("GetExitCodeProcess", code=code, expected=Enums.NON_ZERO)
return lpExitCode[0]
示例15: test_get_handle_info_stdin
def test_get_handle_info_stdin(self):
_, library = dist.load()
stdin_handle = GetStdHandle(library.STD_INPUT_HANDLE)
handle_flags = GetHandleInformation(stdin_handle)
inherit = handle_flags & library.HANDLE_FLAG_INHERIT
expected = (0, library.HANDLE_FLAG_INHERIT)
self.assertIn(inherit, expected)