← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Jelmer Vernooij
  • Date: 2016-04-03 16:32:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6617.
  • Revision ID: jelmer@jelmer.uk-20160403163231-h72bo0uyek2gikw0
https://launchpad.net/bugs/1565503
Don't put French text in doc/en/user-reference when LANGUAGE=fr_CH.UTF_8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
 
18
 
17
19
import errno
18
20
import os
19
21
import re
26
28
lazy_import(globals(), """
27
29
from datetime import datetime
28
30
import getpass
 
31
import locale
29
32
import ntpath
30
33
import posixpath
 
34
import select
31
35
# We need to import both shutil and rmtree as we export the later on posix
32
36
# and need the former on windows
33
37
import shutil
42
46
 
43
47
from bzrlib import (
44
48
    cache_utf8,
 
49
    config,
45
50
    errors,
46
51
    trace,
47
52
    win32utils,
48
53
    )
 
54
from bzrlib.i18n import gettext
49
55
""")
50
56
 
51
57
from bzrlib.symbol_versioning import (
 
58
    DEPRECATED_PARAMETER,
52
59
    deprecated_function,
53
60
    deprecated_in,
 
61
    deprecated_passed,
 
62
    warn as warn_deprecated,
54
63
    )
55
64
 
56
65
from hashlib import (
60
69
 
61
70
 
62
71
import bzrlib
63
 
from bzrlib import symbol_versioning
 
72
from bzrlib import symbol_versioning, _fs_enc
64
73
 
65
74
 
66
75
# Cross platform wall-clock time functionality with decent resolution.
88
97
        user_encoding = get_user_encoding()
89
98
        return [a.decode(user_encoding) for a in sys.argv[1:]]
90
99
    except UnicodeDecodeError:
91
 
        raise errors.BzrError("Parameter %r encoding is unsupported by %s "
92
 
            "application locale." % (a, user_encoding))
 
100
        raise errors.BzrError(gettext("Parameter {0!r} encoding is unsupported by {1} "
 
101
            "application locale.").format(a, user_encoding))
93
102
 
94
103
 
95
104
def make_readonly(filename):
208
217
            if e.errno == errno.ENOENT:
209
218
                return False;
210
219
            else:
211
 
                raise errors.BzrError("lstat/stat of (%r): %r" % (f, e))
 
220
                raise errors.BzrError(gettext("lstat/stat of ({0!r}): {1!r}").format(f, e))
212
221
 
213
222
 
214
223
def fancy_rename(old, new, rename_func, unlink_func):
290
299
# choke on a Unicode string containing a relative path if
291
300
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
292
301
# string.
293
 
_fs_enc = sys.getfilesystemencoding() or 'utf-8'
294
302
def _posix_abspath(path):
295
303
    # jam 20060426 rather than encoding to fsencoding
296
304
    # copy posixpath.abspath, but use os.getcwdu instead
318
326
    return path
319
327
 
320
328
 
 
329
def _posix_path_from_environ(key):
 
330
    """Get unicode path from `key` in environment or None if not present
 
331
 
 
332
    Note that posix systems use arbitrary byte strings for filesystem objects,
 
333
    so a path that raises BadFilenameEncoding here may still be accessible.
 
334
    """
 
335
    val = os.environ.get(key, None)
 
336
    if val is None:
 
337
        return val
 
338
    try:
 
339
        return val.decode(_fs_enc)
 
340
    except UnicodeDecodeError:
 
341
        # GZ 2011-12-12:Ideally want to include `key` in the exception message
 
342
        raise errors.BadFilenameEncoding(val, _fs_enc)
 
343
 
 
344
 
 
345
def _posix_get_home_dir():
 
346
    """Get the home directory of the current user as a unicode path"""
 
347
    path = posixpath.expanduser("~")
 
348
    try:
 
349
        return path.decode(_fs_enc)
 
350
    except UnicodeDecodeError:
 
351
        raise errors.BadFilenameEncoding(path, _fs_enc)
 
352
 
 
353
 
 
354
def _posix_getuser_unicode():
 
355
    """Get username from environment or password database as unicode"""
 
356
    name = getpass.getuser()
 
357
    user_encoding = get_user_encoding()
 
358
    try:
 
359
        return name.decode(user_encoding)
 
360
    except UnicodeDecodeError:
 
361
        raise errors.BzrError("Encoding of username %r is unsupported by %s "
 
362
            "application locale." % (name, user_encoding))
 
363
 
 
364
 
321
365
def _win32_fixdrive(path):
322
366
    """Force drive letters to be consistent.
323
367
 
406
450
    return unicodedata.normalize('NFC', os.getcwdu())
407
451
 
408
452
 
 
453
def _rename_wrap_exception(rename_func):
 
454
    """Adds extra information to any exceptions that come from rename().
 
455
 
 
456
    The exception has an updated message and 'old_filename' and 'new_filename'
 
457
    attributes.
 
458
    """
 
459
 
 
460
    def _rename_wrapper(old, new):
 
461
        try:
 
462
            rename_func(old, new)
 
463
        except OSError, e:
 
464
            detailed_error = OSError(e.errno, e.strerror +
 
465
                                " [occurred when renaming '%s' to '%s']" %
 
466
                                (old, new))
 
467
            detailed_error.old_filename = old
 
468
            detailed_error.new_filename = new
 
469
            raise detailed_error
 
470
 
 
471
    return _rename_wrapper
 
472
 
 
473
# Default rename wraps os.rename()
 
474
rename = _rename_wrap_exception(os.rename)
 
475
 
409
476
# Default is to just use the python builtins, but these can be rebound on
410
477
# particular platforms.
411
478
abspath = _posix_abspath
412
479
realpath = _posix_realpath
413
480
pathjoin = os.path.join
414
481
normpath = _posix_normpath
 
482
path_from_environ = _posix_path_from_environ
 
483
_get_home_dir = _posix_get_home_dir
 
484
getuser_unicode = _posix_getuser_unicode
415
485
getcwd = os.getcwdu
416
 
rename = os.rename
417
486
dirname = os.path.dirname
418
487
basename = os.path.basename
419
488
split = os.path.split
441
510
    normpath = _win32_normpath
442
511
    getcwd = _win32_getcwd
443
512
    mkdtemp = _win32_mkdtemp
444
 
    rename = _win32_rename
 
513
    rename = _rename_wrap_exception(_win32_rename)
445
514
    try:
446
515
        from bzrlib import _walkdirs_win32
447
516
    except ImportError:
473
542
    f = win32utils.get_unicode_argv     # special function or None
474
543
    if f is not None:
475
544
        get_unicode_argv = f
 
545
    path_from_environ = win32utils.get_environ_unicode
 
546
    _get_home_dir = win32utils.get_home_location
 
547
    getuser_unicode = win32utils.get_user_name
476
548
 
477
549
elif sys.platform == 'darwin':
478
550
    getcwd = _mac_getcwd
910
982
    return os.fstat(f.fileno())[stat.ST_SIZE]
911
983
 
912
984
 
913
 
# Define rand_bytes based on platform.
914
 
try:
915
 
    # Python 2.4 and later have os.urandom,
916
 
    # but it doesn't work on some arches
917
 
    os.urandom(1)
918
 
    rand_bytes = os.urandom
919
 
except (NotImplementedError, AttributeError):
920
 
    # If python doesn't have os.urandom, or it doesn't work,
921
 
    # then try to first pull random data from /dev/urandom
 
985
# Alias os.urandom to support platforms (which?) without /dev/urandom and 
 
986
# override if it doesn't work. Avoid checking on windows where there is
 
987
# significant initialisation cost that can be avoided for some bzr calls.
 
988
 
 
989
rand_bytes = os.urandom
 
990
 
 
991
if rand_bytes.__module__ != "nt":
922
992
    try:
923
 
        rand_bytes = file('/dev/urandom', 'rb').read
924
 
    # Otherwise, use this hack as a last resort
925
 
    except (IOError, OSError):
 
993
        rand_bytes(1)
 
994
    except NotImplementedError:
926
995
        # not well seeded, but better than nothing
927
996
        def rand_bytes(n):
928
997
            import random
958
1027
    rps = []
959
1028
    for f in ps:
960
1029
        if f == '..':
961
 
            raise errors.BzrError("sorry, %r not allowed in path" % f)
 
1030
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
962
1031
        elif (f == '.') or (f == ''):
963
1032
            pass
964
1033
        else:
969
1038
def joinpath(p):
970
1039
    for f in p:
971
1040
        if (f == '..') or (f is None) or (f == ''):
972
 
            raise errors.BzrError("sorry, %r not allowed in path" % f)
 
1041
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
973
1042
    return pathjoin(*p)
974
1043
 
975
1044
 
1019
1088
def report_extension_load_failures():
1020
1089
    if not _extension_load_failures:
1021
1090
        return
1022
 
    from bzrlib.config import GlobalConfig
1023
 
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
 
1091
    if config.GlobalStack().get('ignore_missing_extensions'):
1024
1092
        return
1025
1093
    # the warnings framework should by default show this only once
1026
1094
    from bzrlib.trace import warning
1188
1256
 
1189
1257
    if len(base) < MIN_ABS_PATHLENGTH:
1190
1258
        # must have space for e.g. a drive letter
1191
 
        raise ValueError('%r is too short to calculate a relative path'
 
1259
        raise ValueError(gettext('%r is too short to calculate a relative path')
1192
1260
            % (base,))
1193
1261
 
1194
1262
    rp = abspath(path)
1769
1837
    """
1770
1838
    global _selected_dir_reader
1771
1839
    if _selected_dir_reader is None:
1772
 
        fs_encoding = _fs_enc.upper()
1773
1840
        if sys.platform == "win32" and win32utils.winver == 'Windows NT':
1774
1841
            # Win98 doesn't have unicode apis like FindFirstFileW
1775
1842
            # TODO: We possibly could support Win98 by falling back to the
1781
1848
                _selected_dir_reader = Win32ReadDir()
1782
1849
            except ImportError:
1783
1850
                pass
1784
 
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1785
 
            # ANSI_X3.4-1968 is a form of ASCII
 
1851
        elif _fs_enc in ('utf-8', 'ascii'):
1786
1852
            try:
1787
1853
                from bzrlib._readdir_pyx import UTF8DirReader
1788
1854
                _selected_dir_reader = UTF8DirReader()
1947
2013
_cached_user_encoding = None
1948
2014
 
1949
2015
 
1950
 
def get_user_encoding(use_cache=True):
 
2016
def get_user_encoding(use_cache=DEPRECATED_PARAMETER):
1951
2017
    """Find out what the preferred user encoding is.
1952
2018
 
1953
2019
    This is generally the encoding that is used for command line parameters
1954
2020
    and file contents. This may be different from the terminal encoding
1955
2021
    or the filesystem encoding.
1956
2022
 
1957
 
    :param  use_cache:  Enable cache for detected encoding.
1958
 
                        (This parameter is turned on by default,
1959
 
                        and required only for selftesting)
1960
 
 
1961
2023
    :return: A string defining the preferred user encoding
1962
2024
    """
1963
2025
    global _cached_user_encoding
1964
 
    if _cached_user_encoding is not None and use_cache:
 
2026
    if deprecated_passed(use_cache):
 
2027
        warn_deprecated("use_cache should only have been used for tests",
 
2028
            DeprecationWarning, stacklevel=2) 
 
2029
    if _cached_user_encoding is not None:
1965
2030
        return _cached_user_encoding
1966
2031
 
1967
 
    if sys.platform == 'darwin':
1968
 
        # python locale.getpreferredencoding() always return
1969
 
        # 'mac-roman' on darwin. That's a lie.
1970
 
        sys.platform = 'posix'
1971
 
        try:
1972
 
            if os.environ.get('LANG', None) is None:
1973
 
                # If LANG is not set, we end up with 'ascii', which is bad
1974
 
                # ('mac-roman' is more than ascii), so we set a default which
1975
 
                # will give us UTF-8 (which appears to work in all cases on
1976
 
                # OSX). Users are still free to override LANG of course, as
1977
 
                # long as it give us something meaningful. This work-around
1978
 
                # *may* not be needed with python 3k and/or OSX 10.5, but will
1979
 
                # work with them too -- vila 20080908
1980
 
                os.environ['LANG'] = 'en_US.UTF-8'
1981
 
            import locale
1982
 
        finally:
1983
 
            sys.platform = 'darwin'
 
2032
    if os.name == 'posix' and getattr(locale, 'CODESET', None) is not None:
 
2033
        # Use the existing locale settings and call nl_langinfo directly
 
2034
        # rather than going through getpreferredencoding. This avoids
 
2035
        # <http://bugs.python.org/issue6202> on OSX Python 2.6 and the
 
2036
        # possibility of the setlocale call throwing an error.
 
2037
        user_encoding = locale.nl_langinfo(locale.CODESET)
1984
2038
    else:
1985
 
        import locale
 
2039
        # GZ 2011-12-19: On windows could call GetACP directly instead.
 
2040
        user_encoding = locale.getpreferredencoding(False)
1986
2041
 
1987
2042
    try:
1988
 
        user_encoding = locale.getpreferredencoding()
1989
 
    except locale.Error, e:
1990
 
        sys.stderr.write('bzr: warning: %s\n'
1991
 
                         '  Could not determine what text encoding to use.\n'
1992
 
                         '  This error usually means your Python interpreter\n'
1993
 
                         '  doesn\'t support the locale set by $LANG (%s)\n'
1994
 
                         "  Continuing with ascii encoding.\n"
1995
 
                         % (e, os.environ.get('LANG')))
1996
 
        user_encoding = 'ascii'
1997
 
 
1998
 
    # Windows returns 'cp0' to indicate there is no code page. So we'll just
1999
 
    # treat that as ASCII, and not support printing unicode characters to the
2000
 
    # console.
2001
 
    #
2002
 
    # For python scripts run under vim, we get '', so also treat that as ASCII
2003
 
    if user_encoding in (None, 'cp0', ''):
2004
 
        user_encoding = 'ascii'
2005
 
    else:
2006
 
        # check encoding
2007
 
        try:
2008
 
            codecs.lookup(user_encoding)
2009
 
        except LookupError:
 
2043
        user_encoding = codecs.lookup(user_encoding).name
 
2044
    except LookupError:
 
2045
        if user_encoding not in ("", "cp0"):
2010
2046
            sys.stderr.write('bzr: warning:'
2011
2047
                             ' unknown encoding %s.'
2012
2048
                             ' Continuing with ascii encoding.\n'
2013
2049
                             % user_encoding
2014
2050
                            )
2015
 
            user_encoding = 'ascii'
2016
 
 
2017
 
    if use_cache:
2018
 
        _cached_user_encoding = user_encoding
2019
 
 
 
2051
        user_encoding = 'ascii'
 
2052
    else:
 
2053
        # Get 'ascii' when setlocale has not been called or LANG=C or unset.
 
2054
        if user_encoding == 'ascii':
 
2055
            if sys.platform == 'darwin':
 
2056
                # OSX is special-cased in Python to have a UTF-8 filesystem
 
2057
                # encoding and previously had LANG set here if not present.
 
2058
                user_encoding = 'utf-8'
 
2059
            # GZ 2011-12-19: Maybe UTF-8 should be the default in this case
 
2060
            #                for some other posix platforms as well.
 
2061
 
 
2062
    _cached_user_encoding = user_encoding
2020
2063
    return user_encoding
2021
2064
 
2022
2065
 
2031
2074
    behaves inconsistently on different platforms.
2032
2075
    """
2033
2076
    if sys.platform == "win32":
2034
 
        import win32utils
2035
2077
        return win32utils.get_host_name()
2036
2078
    else:
2037
2079
        import socket
2044
2086
# data at once.
2045
2087
MAX_SOCKET_CHUNK = 64 * 1024
2046
2088
 
2047
 
_end_of_stream_errors = [errno.ECONNRESET]
 
2089
_end_of_stream_errors = [errno.ECONNRESET, errno.EPIPE, errno.EINVAL]
2048
2090
for _eno in ['WSAECONNRESET', 'WSAECONNABORTED']:
2049
2091
    _eno = getattr(errno, _eno, None)
2050
2092
    if _eno is not None:
2116
2158
    while sent_total < byte_count:
2117
2159
        try:
2118
2160
            sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
2119
 
        except socket.error, e:
 
2161
        except (socket.error, IOError), e:
 
2162
            if e.args[0] in _end_of_stream_errors:
 
2163
                raise errors.ConnectionReset(
 
2164
                    "Error trying to write to socket", e)
2120
2165
            if e.args[0] != errno.EINTR:
2121
2166
                raise
2122
2167
        else:
 
2168
            if sent == 0:
 
2169
                raise errors.ConnectionReset('Sending to %s returned 0 bytes'
 
2170
                                             % (sock,))
2123
2171
            sent_total += sent
2124
 
            report_activity(sent, 'write')
 
2172
            if report_activity is not None:
 
2173
                report_activity(sent, 'write')
2125
2174
 
2126
2175
 
2127
2176
def connect_socket(address):
2212
2261
    return file_kind_from_stat_mode(mode)
2213
2262
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
2214
2263
 
2215
 
 
2216
 
def file_kind(f, _lstat=os.lstat):
 
2264
def file_stat(f, _lstat=os.lstat):
2217
2265
    try:
2218
 
        return file_kind_from_stat_mode(_lstat(f).st_mode)
 
2266
        # XXX cache?
 
2267
        return _lstat(f)
2219
2268
    except OSError, e:
2220
2269
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
2221
2270
            raise errors.NoSuchFile(f)
2222
2271
        raise
2223
2272
 
 
2273
def file_kind(f, _lstat=os.lstat):
 
2274
    stat_value = file_stat(f, _lstat)
 
2275
    return file_kind_from_stat_mode(stat_value.st_mode)
2224
2276
 
2225
2277
def until_no_eintr(f, *a, **kw):
2226
2278
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2270
2322
 
2271
2323
 
2272
2324
if sys.platform == "win32":
2273
 
    import msvcrt
2274
2325
    def getchar():
 
2326
        import msvcrt
2275
2327
        return msvcrt.getch()
2276
2328
else:
2277
 
    import tty
2278
 
    import termios
2279
2329
    def getchar():
 
2330
        import tty
 
2331
        import termios
2280
2332
        fd = sys.stdin.fileno()
2281
2333
        settings = termios.tcgetattr(fd)
2282
2334
        try:
2286
2338
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2287
2339
        return ch
2288
2340
 
2289
 
if sys.platform == 'linux2':
 
2341
if sys.platform.startswith('linux'):
2290
2342
    def _local_concurrency():
2291
2343
        try:
2292
2344
            return os.sysconf('SC_NPROCESSORS_ONLN')
2331
2383
    if concurrency is None:
2332
2384
        try:
2333
2385
            import multiprocessing
2334
 
        except ImportError:
 
2386
            concurrency = multiprocessing.cpu_count()
 
2387
        except (ImportError, NotImplementedError):
2335
2388
            # multiprocessing is only available on Python >= 2.6
 
2389
            # and multiprocessing.cpu_count() isn't implemented on all
 
2390
            # platforms
2336
2391
            try:
2337
2392
                concurrency = _local_concurrency()
2338
2393
            except (OSError, IOError):
2339
2394
                pass
2340
 
        else:
2341
 
            concurrency = multiprocessing.cpu_count()
2342
2395
    try:
2343
2396
        concurrency = int(concurrency)
2344
2397
    except (TypeError, ValueError):
2406
2459
    open_file = open
2407
2460
 
2408
2461
 
2409
 
def getuser_unicode():
2410
 
    """Return the username as unicode.
2411
 
    """
2412
 
    try:
2413
 
        user_encoding = get_user_encoding()
2414
 
        username = getpass.getuser().decode(user_encoding)
2415
 
    except UnicodeDecodeError:
2416
 
        raise errors.BzrError("Can't decode username as %s." % \
2417
 
                user_encoding)
2418
 
    except ImportError, e:
2419
 
        if sys.platform != 'win32':
2420
 
            raise
2421
 
        if str(e) != 'No module named pwd':
2422
 
            raise
2423
 
        # https://bugs.launchpad.net/bzr/+bug/660174
2424
 
        # getpass.getuser() is unable to return username on Windows
2425
 
        # if there is no USERNAME environment variable set.
2426
 
        # That could be true if bzr is running as a service,
2427
 
        # e.g. running `bzr serve` as a service on Windows.
2428
 
        # We should not fail with traceback in this case.
2429
 
        username = u'UNKNOWN'
2430
 
    return username
2431
 
 
2432
 
 
2433
2462
def available_backup_name(base, exists):
2434
2463
    """Find a non-existing backup file name.
2435
2464
 
2473
2502
    :param name: The base name of the executable.
2474
2503
    :return: The path to the executable found or None.
2475
2504
    """
2476
 
    path = os.environ.get('PATH')
2477
 
    if path is None:
2478
 
        return None
2479
 
    path = path.split(os.pathsep)
2480
2505
    if sys.platform == 'win32':
2481
2506
        exts = os.environ.get('PATHEXT', '').split(os.pathsep)
2482
2507
        exts = [ext.lower() for ext in exts]
2488
2513
            exts = [ext]
2489
2514
    else:
2490
2515
        exts = ['']
2491
 
    for ext in exts:
2492
 
        for d in path:
2493
 
            f = os.path.join(d, name) + ext
2494
 
            if os.access(f, os.X_OK):
2495
 
                return f
 
2516
    path = os.environ.get('PATH')
 
2517
    if path is not None:
 
2518
        path = path.split(os.pathsep)
 
2519
        for ext in exts:
 
2520
            for d in path:
 
2521
                f = os.path.join(d, name) + ext
 
2522
                if os.access(f, os.X_OK):
 
2523
                    return f
 
2524
    if sys.platform == 'win32':
 
2525
        app_path = win32utils.get_app_path(name)
 
2526
        if app_path != name:
 
2527
            return app_path
2496
2528
    return None
2497
2529
 
2498
2530
 
2522
2554
else:
2523
2555
    is_local_pid_dead = _posix_is_local_pid_dead
2524
2556
 
 
2557
_maybe_ignored = ['EAGAIN', 'EINTR', 'ENOTSUP', 'EOPNOTSUPP', 'EACCES']
 
2558
_fdatasync_ignored = [getattr(errno, name) for name in _maybe_ignored
 
2559
                      if getattr(errno, name, None) is not None]
 
2560
 
2525
2561
 
2526
2562
def fdatasync(fileno):
2527
2563
    """Flush file contents to disk if possible.
2531
2567
    """
2532
2568
    fn = getattr(os, 'fdatasync', getattr(os, 'fsync', None))
2533
2569
    if fn is not None:
2534
 
        fn(fileno)
 
2570
        try:
 
2571
            fn(fileno)
 
2572
        except IOError, e:
 
2573
            # See bug #1075108, on some platforms fdatasync exists, but can
 
2574
            # raise ENOTSUP. However, we are calling fdatasync to be helpful
 
2575
            # and reduce the chance of corruption-on-powerloss situations. It
 
2576
            # is not a mandatory call, so it is ok to suppress failures.
 
2577
            trace.mutter("ignoring error calling fdatasync: %s" % (e,))
 
2578
            if getattr(e, 'errno', None) not in _fdatasync_ignored:
 
2579
                raise
2535
2580
 
2536
2581
 
2537
2582
def ensure_empty_directory_exists(path, exception_class):
2547
2592
            raise
2548
2593
        if os.listdir(path) != []:
2549
2594
            raise exception_class(path)
 
2595
 
 
2596
 
 
2597
def is_environment_error(evalue):
 
2598
    """True if exception instance is due to a process environment issue
 
2599
 
 
2600
    This includes OSError and IOError, but also other errors that come from
 
2601
    the operating system or core libraries but are not subclasses of those.
 
2602
    """
 
2603
    if isinstance(evalue, (EnvironmentError, select.error)):
 
2604
        return True
 
2605
    if sys.platform == "win32" and win32utils._is_pywintypes_error(evalue):
 
2606
        return True
 
2607
    return False