( )⚙ D10206 typing: disable a few errors when accessing Windows specific attributes

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10206

typing: disable a few errors when accessing Windows specific attributes
ClosedPublic

Authored by mharbison72 on Mar 13 2021, 2:33 PM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG65f437c240f2: typing: disable a few errors when accessing Windows specific attributes
Summary

This is already guarded with conditionals. The entire win32 module is
conditionally loaded.

File "/mnt/c/Users/Matt/hg/mercurial/utils/procutil.py", line 162, in <module>: No attribute 'winstdout' on module 'mercurial.posix' [module-attr]
File "/mnt/c/Users/Matt/hg/mercurial/utils/procutil.py", line 163, in <module>: No attribute 'winstdout' on module 'mercurial.posix' [module-attr]
File "/mnt/c/Users/Matt/hg/mercurial/utils/procutil.py", line 174, in <module>: No attribute 'winstdout' on module 'mercurial.posix' [module-attr]
File "/mnt/c/Users/Matt/hg/mercurial/utils/procutil.py", line 175, in <module>: No attribute 'winstdout' on module 'mercurial.posix' [module-attr]

Diff Detail

Repository
rHG Mercurial
Branch
stable
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

PathPackages
Mmercurial/utils/procutil.py (8 lines)
Mmercurial/win32.py (26 lines)

Diff 26320

mercurial/utils/procutil.py

stdout = _make_write_all(sys.stdout.buffer) stdout = _make_write_all(sys.stdout.buffer)
if sys.stderr is None: if sys.stderr is None:
stderr = BadFile() stderr = BadFile()
else: else:
stderr = _make_write_all(sys.stderr.buffer) stderr = _make_write_all(sys.stderr.buffer)
if pycompat.iswindows: if pycompat.iswindows:
# Work around Windows bugs. # Work around Windows bugs.
stdout = platform.winstdout(stdout) stdout = platform.winstdout(stdout) # pytype: disable=module-attr
stderr = platform.winstdout(stderr) stderr = platform.winstdout(stderr) # pytype: disable=module-attr
if isatty(stdout): if isatty(stdout):
# The standard library doesn't offer line-buffered binary streams. # The standard library doesn't offer line-buffered binary streams.
stdout = make_line_buffered(stdout) stdout = make_line_buffered(stdout)
else: else:
# Python 2 uses the I/O streams provided by the C library. # Python 2 uses the I/O streams provided by the C library.
stdin = sys.stdin stdin = sys.stdin
stdout = sys.stdout stdout = sys.stdout
stderr = sys.stderr stderr = sys.stderr
if pycompat.iswindows: if pycompat.iswindows:
# Work around Windows bugs. # Work around Windows bugs.
stdout = platform.winstdout(stdout) stdout = platform.winstdout(stdout) # pytype: disable=module-attr
stderr = platform.winstdout(stderr) stderr = platform.winstdout(stderr) # pytype: disable=module-attr
if isatty(stdout): if isatty(stdout):
if pycompat.iswindows: if pycompat.iswindows:
# The Windows C runtime library doesn't support line buffering. # The Windows C runtime library doesn't support line buffering.
stdout = make_line_buffered(stdout) stdout = make_line_buffered(stdout)
else: else:
# glibc determines buffering on first write to stdout - if we # glibc determines buffering on first write to stdout - if we
# replace a TTY destined stdout with a pipe destined stdout (e.g. # replace a TTY destined stdout with a pipe destined stdout (e.g.
# pager), we want line buffering. # pager), we want line buffering.

mercurial/win32.py

import random import random
import subprocess import subprocess
from . import ( from . import (
encoding, encoding,
pycompat, pycompat,
) )
# pytype: disable=module-attr
_kernel32 = ctypes.windll.kernel32 _kernel32 = ctypes.windll.kernel32
_advapi32 = ctypes.windll.advapi32 _advapi32 = ctypes.windll.advapi32
_user32 = ctypes.windll.user32 _user32 = ctypes.windll.user32
_crypt32 = ctypes.windll.crypt32 _crypt32 = ctypes.windll.crypt32
# pytype: enable=module-attr
_BOOL = ctypes.c_long _BOOL = ctypes.c_long
_WORD = ctypes.c_ushort _WORD = ctypes.c_ushort
_DWORD = ctypes.c_ulong _DWORD = ctypes.c_ulong
_UINT = ctypes.c_uint _UINT = ctypes.c_uint
_LONG = ctypes.c_long _LONG = ctypes.c_long
_LPCSTR = _LPSTR = ctypes.c_char_p _LPCSTR = _LPSTR = ctypes.c_char_p
_HANDLE = ctypes.c_void_p _HANDLE = ctypes.c_void_p
_kernel32.CreateProcessA.restype = _BOOL _kernel32.CreateProcessA.restype = _BOOL
_kernel32.ExitProcess.argtypes = [_UINT] _kernel32.ExitProcess.argtypes = [_UINT]
_kernel32.ExitProcess.restype = None _kernel32.ExitProcess.restype = None
_kernel32.GetCurrentProcessId.argtypes = [] _kernel32.GetCurrentProcessId.argtypes = []
_kernel32.GetCurrentProcessId.restype = _DWORD _kernel32.GetCurrentProcessId.restype = _DWORD
# pytype: disable=module-attr
_SIGNAL_HANDLER = ctypes.WINFUNCTYPE(_BOOL, _DWORD) _SIGNAL_HANDLER = ctypes.WINFUNCTYPE(_BOOL, _DWORD)
# pytype: enable=module-attr
_kernel32.SetConsoleCtrlHandler.argtypes = [_SIGNAL_HANDLER, _BOOL] _kernel32.SetConsoleCtrlHandler.argtypes = [_SIGNAL_HANDLER, _BOOL]
_kernel32.SetConsoleCtrlHandler.restype = _BOOL _kernel32.SetConsoleCtrlHandler.restype = _BOOL
_kernel32.SetConsoleMode.argtypes = [_HANDLE, _DWORD] _kernel32.SetConsoleMode.argtypes = [_HANDLE, _DWORD]
_kernel32.SetConsoleMode.restype = _BOOL _kernel32.SetConsoleMode.restype = _BOOL
_kernel32.GetConsoleMode.argtypes = [_HANDLE, ctypes.c_void_p] _kernel32.GetConsoleMode.argtypes = [_HANDLE, ctypes.c_void_p]
_kernel32.GetConsoleMode.restype = _BOOL _kernel32.GetConsoleMode.restype = _BOOL
_kernel32.GetStdHandle.argtypes = [_DWORD] _kernel32.GetStdHandle.argtypes = [_DWORD]
_kernel32.GetStdHandle.restype = _HANDLE _kernel32.GetStdHandle.restype = _HANDLE
_kernel32.GetConsoleScreenBufferInfo.argtypes = [_HANDLE, ctypes.c_void_p] _kernel32.GetConsoleScreenBufferInfo.argtypes = [_HANDLE, ctypes.c_void_p]
_kernel32.GetConsoleScreenBufferInfo.restype = _BOOL _kernel32.GetConsoleScreenBufferInfo.restype = _BOOL
_advapi32.GetUserNameA.argtypes = [ctypes.c_void_p, ctypes.c_void_p] _advapi32.GetUserNameA.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
_advapi32.GetUserNameA.restype = _BOOL _advapi32.GetUserNameA.restype = _BOOL
_user32.GetWindowThreadProcessId.argtypes = [_HANDLE, ctypes.c_void_p] _user32.GetWindowThreadProcessId.argtypes = [_HANDLE, ctypes.c_void_p]
_user32.GetWindowThreadProcessId.restype = _DWORD _user32.GetWindowThreadProcessId.restype = _DWORD
_user32.ShowWindow.argtypes = [_HANDLE, ctypes.c_int] _user32.ShowWindow.argtypes = [_HANDLE, ctypes.c_int]
_user32.ShowWindow.restype = _BOOL _user32.ShowWindow.restype = _BOOL
# pytype: disable=module-attr
_WNDENUMPROC = ctypes.WINFUNCTYPE(_BOOL, _HWND, _LPARAM) _WNDENUMPROC = ctypes.WINFUNCTYPE(_BOOL, _HWND, _LPARAM)
# pytype: enable=module-attr
_user32.EnumWindows.argtypes = [_WNDENUMPROC, _LPARAM] _user32.EnumWindows.argtypes = [_WNDENUMPROC, _LPARAM]
_user32.EnumWindows.restype = _BOOL _user32.EnumWindows.restype = _BOOL
_kernel32.PeekNamedPipe.argtypes = [ _kernel32.PeekNamedPipe.argtypes = [
_HANDLE, _HANDLE,
ctypes.c_void_p, ctypes.c_void_p,
_DWORD, _DWORD,
ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_void_p, ctypes.c_void_p,
] ]
_kernel32.PeekNamedPipe.restype = _BOOL _kernel32.PeekNamedPipe.restype = _BOOL
def _raiseoserror(name): def _raiseoserror(name):
# Force the code to a signed int to avoid an 'int too large' error. # Force the code to a signed int to avoid an 'int too large' error.
# See https://bugs.python.org/issue28474 # See https://bugs.python.org/issue28474
code = _kernel32.GetLastError() code = _kernel32.GetLastError()
if code > 0x7FFFFFFF: if code > 0x7FFFFFFF:
code -= 2 ** 32 code -= 2 ** 32
err = ctypes.WinError(code=code) err = ctypes.WinError(code=code) # pytype: disable=module-attr
raise OSError( raise OSError(
err.errno, '%s: %s' % (encoding.strfromlocal(name), err.strerror) err.errno, '%s: %s' % (encoding.strfromlocal(name), err.strerror)
) )
def _getfileinfo(name): def _getfileinfo(name):
fh = _kernel32.CreateFileA( fh = _kernel32.CreateFileA(
name, name,
def samedevice(path1, path2): def samedevice(path1, path2):
'''Returns whether path1 and path2 are on the same device.''' '''Returns whether path1 and path2 are on the same device.'''
res1 = _getfileinfo(path1) res1 = _getfileinfo(path1)
res2 = _getfileinfo(path2) res2 = _getfileinfo(path2)
return res1.dwVolumeSerialNumber == res2.dwVolumeSerialNumber return res1.dwVolumeSerialNumber == res2.dwVolumeSerialNumber
def peekpipe(pipe): def peekpipe(pipe):
handle = msvcrt.get_osfhandle(pipe.fileno()) handle = msvcrt.get_osfhandle(pipe.fileno()) # pytype: disable=module-attr
avail = _DWORD() avail = _DWORD()
if not _kernel32.PeekNamedPipe( if not _kernel32.PeekNamedPipe(
handle, None, 0, None, ctypes.byref(avail), None handle, None, 0, None, ctypes.byref(avail), None
): ):
err = _kernel32.GetLastError() err = _kernel32.GetLastError()
if err == _ERROR_BROKEN_PIPE: if err == _ERROR_BROKEN_PIPE:
return 0 return 0
raise ctypes.WinError(err) raise ctypes.WinError(err) # pytype: disable=module-attr
return avail.value return avail.value
def lasterrorwaspipeerror(err): def lasterrorwaspipeerror(err):
if err.errno != errno.EINVAL: if err.errno != errno.EINVAL:
return False return False
err = _kernel32.GetLastError() err = _kernel32.GetLastError()
return _kernel32.GetLastError() != _ERROR_INVALID_PARAMETER return _kernel32.GetLastError() != _ERROR_INVALID_PARAMETER
def executablepath(): def executablepath():
'''return full path of hg.exe''' '''return full path of hg.exe'''
size = 600 size = 600
buf = ctypes.create_string_buffer(size + 1) buf = ctypes.create_string_buffer(size + 1)
len = _kernel32.GetModuleFileNameA(None, ctypes.byref(buf), size) len = _kernel32.GetModuleFileNameA(None, ctypes.byref(buf), size)
# pytype: disable=module-attr
if len == 0: if len == 0:
raise ctypes.WinError() # Note: WinError is a function raise ctypes.WinError() # Note: WinError is a function
elif len == size: elif len == size:
raise ctypes.WinError(_ERROR_INSUFFICIENT_BUFFER) raise ctypes.WinError(_ERROR_INSUFFICIENT_BUFFER)
# pytype: enable=module-attr
return buf.value return buf.value
def getvolumename(path): def getvolumename(path):
"""Get the mount point of the filesystem from a directory or file """Get the mount point of the filesystem from a directory or file
(best-effort) (best-effort)
Returns None if we are unsure. Raises OSError on ENOENT, EPERM, etc. Returns None if we are unsure. Raises OSError on ENOENT, EPERM, etc.
""" """
# realpath() calls GetFullPathName() # realpath() calls GetFullPathName()
realpath = os.path.realpath(path) realpath = os.path.realpath(path)
# allocate at least MAX_PATH long since GetVolumePathName('c:\\', buf, 4) # allocate at least MAX_PATH long since GetVolumePathName('c:\\', buf, 4)
# somehow fails on Windows XP # somehow fails on Windows XP
size = max(len(realpath), _MAX_PATH) + 1 size = max(len(realpath), _MAX_PATH) + 1
buf = ctypes.create_string_buffer(size) buf = ctypes.create_string_buffer(size)
if not _kernel32.GetVolumePathNameA(realpath, ctypes.byref(buf), size): if not _kernel32.GetVolumePathNameA(realpath, ctypes.byref(buf), size):
raise ctypes.WinError() # Note: WinError is a function # Note: WinError is a function
raise ctypes.WinError() # pytype: disable=module-attr
return buf.value return buf.value
def getfstype(path): def getfstype(path):
"""Get the filesystem type name from a directory or file (best-effort) """Get the filesystem type name from a directory or file (best-effort)
Returns None if we are unsure. Raises OSError on ENOENT, EPERM, etc. Returns None if we are unsure. Raises OSError on ENOENT, EPERM, etc.
return None return None
size = _MAX_PATH + 1 size = _MAX_PATH + 1
name = ctypes.create_string_buffer(size) name = ctypes.create_string_buffer(size)
if not _kernel32.GetVolumeInformationA( if not _kernel32.GetVolumeInformationA(
volume, None, 0, None, None, None, ctypes.byref(name), size volume, None, 0, None, None, None, ctypes.byref(name), size
): ):
raise ctypes.WinError() # Note: WinError is a function # Note: WinError is a function
raise ctypes.WinError() # pytype: disable=module-attr
return name.value return name.value
def getuser(): def getuser():
'''return name of current user''' '''return name of current user'''
size = _DWORD(300) size = _DWORD(300)
buf = ctypes.create_string_buffer(size.value + 1) buf = ctypes.create_string_buffer(size.value + 1)
if not _advapi32.GetUserNameA(ctypes.byref(buf), ctypes.byref(size)): if not _advapi32.GetUserNameA(ctypes.byref(buf), ctypes.byref(size)):
raise ctypes.WinError() raise ctypes.WinError() # pytype: disable=module-attr
return buf.value return buf.value
_signalhandler = [] _signalhandler = []
def setsignalhandler(): def setsignalhandler():
"""Register a termination handler for console events including """Register a termination handler for console events including
CTRL+C. python signal handlers do not work well with socket CTRL+C. python signal handlers do not work well with socket
operations. operations.
""" """
def handler(event): def handler(event):
_kernel32.ExitProcess(1) _kernel32.ExitProcess(1)
if _signalhandler: if _signalhandler:
return # already registered return # already registered
h = _SIGNAL_HANDLER(handler) h = _SIGNAL_HANDLER(handler)
_signalhandler.append(h) # needed to prevent garbage collection _signalhandler.append(h) # needed to prevent garbage collection
if not _kernel32.SetConsoleCtrlHandler(h, True): if not _kernel32.SetConsoleCtrlHandler(h, True):
raise ctypes.WinError() raise ctypes.WinError() # pytype: disable=module-attr
def hidewindow(): def hidewindow():
def callback(hwnd, pid): def callback(hwnd, pid):
wpid = _DWORD() wpid = _DWORD()
_user32.GetWindowThreadProcessId(hwnd, ctypes.byref(wpid)) _user32.GetWindowThreadProcessId(hwnd, ctypes.byref(wpid))
if pid == wpid.value: if pid == wpid.value:
_user32.ShowWindow(hwnd, _SW_HIDE) _user32.ShowWindow(hwnd, _SW_HIDE)
False, False,
_CREATE_NO_WINDOW, _CREATE_NO_WINDOW,
env, env,
encoding.getcwd(), encoding.getcwd(),
ctypes.byref(si), ctypes.byref(si),
ctypes.byref(pi), ctypes.byref(pi),
) )
if not res: if not res:
raise ctypes.WinError() raise ctypes.WinError() # pytype: disable=module-attr
_kernel32.CloseHandle(pi.hProcess) _kernel32.CloseHandle(pi.hProcess)
_kernel32.CloseHandle(pi.hThread) _kernel32.CloseHandle(pi.hThread)
return pi.dwProcessId return pi.dwProcessId
def unlink(f): def unlink(f):