← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Alexander Belchenko
  • Date: 2012-03-29 08:34:13 UTC
  • mto: (6015.44.14 2.4)
  • mto: This revision was merged to the branch mainline in revision 6513.
  • Revision ID: bialix@ukr.net-20120329083413-d4bqqdtfn2yrxp4f
change st_dev, st_ino, st_uid, st_gid from int members to properties.

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
 
 
19
17
import errno
20
18
import os
21
19
import re
28
26
lazy_import(globals(), """
29
27
from datetime import datetime
30
28
import getpass
31
 
import locale
32
29
import ntpath
33
30
import posixpath
34
 
import select
35
31
# We need to import both shutil and rmtree as we export the later on posix
36
32
# and need the former on windows
37
33
import shutil
46
42
 
47
43
from bzrlib import (
48
44
    cache_utf8,
49
 
    config,
50
45
    errors,
51
46
    trace,
52
47
    win32utils,
53
48
    )
54
 
from bzrlib.i18n import gettext
55
49
""")
56
50
 
57
51
from bzrlib.symbol_versioning import (
58
 
    DEPRECATED_PARAMETER,
59
52
    deprecated_function,
60
53
    deprecated_in,
61
 
    deprecated_passed,
62
 
    warn as warn_deprecated,
63
54
    )
64
55
 
65
56
from hashlib import (
69
60
 
70
61
 
71
62
import bzrlib
72
 
from bzrlib import symbol_versioning, _fs_enc
 
63
from bzrlib import symbol_versioning
73
64
 
74
65
 
75
66
# Cross platform wall-clock time functionality with decent resolution.
97
88
        user_encoding = get_user_encoding()
98
89
        return [a.decode(user_encoding) for a in sys.argv[1:]]
99
90
    except UnicodeDecodeError:
100
 
        raise errors.BzrError(gettext("Parameter {0!r} encoding is unsupported by {1} "
101
 
            "application locale.").format(a, user_encoding))
 
91
        raise errors.BzrError("Parameter %r encoding is unsupported by %s "
 
92
            "application locale." % (a, user_encoding))
102
93
 
103
94
 
104
95
def make_readonly(filename):
217
208
            if e.errno == errno.ENOENT:
218
209
                return False;
219
210
            else:
220
 
                raise errors.BzrError(gettext("lstat/stat of ({0!r}): {1!r}").format(f, e))
 
211
                raise errors.BzrError("lstat/stat of (%r): %r" % (f, e))
221
212
 
222
213
 
223
214
def fancy_rename(old, new, rename_func, unlink_func):
299
290
# choke on a Unicode string containing a relative path if
300
291
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
301
292
# string.
 
293
_fs_enc = sys.getfilesystemencoding() or 'utf-8'
302
294
def _posix_abspath(path):
303
295
    # jam 20060426 rather than encoding to fsencoding
304
296
    # copy posixpath.abspath, but use os.getcwdu instead
326
318
    return path
327
319
 
328
320
 
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
 
 
365
321
def _win32_fixdrive(path):
366
322
    """Force drive letters to be consistent.
367
323
 
450
406
    return unicodedata.normalize('NFC', os.getcwdu())
451
407
 
452
408
 
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
 
 
476
409
# Default is to just use the python builtins, but these can be rebound on
477
410
# particular platforms.
478
411
abspath = _posix_abspath
479
412
realpath = _posix_realpath
480
413
pathjoin = os.path.join
481
414
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
485
415
getcwd = os.getcwdu
 
416
rename = os.rename
486
417
dirname = os.path.dirname
487
418
basename = os.path.basename
488
419
split = os.path.split
510
441
    normpath = _win32_normpath
511
442
    getcwd = _win32_getcwd
512
443
    mkdtemp = _win32_mkdtemp
513
 
    rename = _rename_wrap_exception(_win32_rename)
 
444
    rename = _win32_rename
514
445
    try:
515
446
        from bzrlib import _walkdirs_win32
516
447
    except ImportError:
542
473
    f = win32utils.get_unicode_argv     # special function or None
543
474
    if f is not None:
544
475
        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
548
476
 
549
477
elif sys.platform == 'darwin':
550
478
    getcwd = _mac_getcwd
982
910
    return os.fstat(f.fileno())[stat.ST_SIZE]
983
911
 
984
912
 
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":
 
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
992
922
    try:
993
 
        rand_bytes(1)
994
 
    except NotImplementedError:
 
923
        rand_bytes = file('/dev/urandom', 'rb').read
 
924
    # Otherwise, use this hack as a last resort
 
925
    except (IOError, OSError):
995
926
        # not well seeded, but better than nothing
996
927
        def rand_bytes(n):
997
928
            import random
1027
958
    rps = []
1028
959
    for f in ps:
1029
960
        if f == '..':
1030
 
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
 
961
            raise errors.BzrError("sorry, %r not allowed in path" % f)
1031
962
        elif (f == '.') or (f == ''):
1032
963
            pass
1033
964
        else:
1038
969
def joinpath(p):
1039
970
    for f in p:
1040
971
        if (f == '..') or (f is None) or (f == ''):
1041
 
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
 
972
            raise errors.BzrError("sorry, %r not allowed in path" % f)
1042
973
    return pathjoin(*p)
1043
974
 
1044
975
 
1088
1019
def report_extension_load_failures():
1089
1020
    if not _extension_load_failures:
1090
1021
        return
1091
 
    if config.GlobalStack().get('ignore_missing_extensions'):
 
1022
    from bzrlib.config import GlobalConfig
 
1023
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
1092
1024
        return
1093
1025
    # the warnings framework should by default show this only once
1094
1026
    from bzrlib.trace import warning
1256
1188
 
1257
1189
    if len(base) < MIN_ABS_PATHLENGTH:
1258
1190
        # must have space for e.g. a drive letter
1259
 
        raise ValueError(gettext('%r is too short to calculate a relative path')
 
1191
        raise ValueError('%r is too short to calculate a relative path'
1260
1192
            % (base,))
1261
1193
 
1262
1194
    rp = abspath(path)
1837
1769
    """
1838
1770
    global _selected_dir_reader
1839
1771
    if _selected_dir_reader is None:
 
1772
        fs_encoding = _fs_enc.upper()
1840
1773
        if sys.platform == "win32" and win32utils.winver == 'Windows NT':
1841
1774
            # Win98 doesn't have unicode apis like FindFirstFileW
1842
1775
            # TODO: We possibly could support Win98 by falling back to the
1848
1781
                _selected_dir_reader = Win32ReadDir()
1849
1782
            except ImportError:
1850
1783
                pass
1851
 
        elif _fs_enc in ('utf-8', 'ascii'):
 
1784
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
 
1785
            # ANSI_X3.4-1968 is a form of ASCII
1852
1786
            try:
1853
1787
                from bzrlib._readdir_pyx import UTF8DirReader
1854
1788
                _selected_dir_reader = UTF8DirReader()
2013
1947
_cached_user_encoding = None
2014
1948
 
2015
1949
 
2016
 
def get_user_encoding(use_cache=DEPRECATED_PARAMETER):
 
1950
def get_user_encoding(use_cache=True):
2017
1951
    """Find out what the preferred user encoding is.
2018
1952
 
2019
1953
    This is generally the encoding that is used for command line parameters
2020
1954
    and file contents. This may be different from the terminal encoding
2021
1955
    or the filesystem encoding.
2022
1956
 
 
1957
    :param  use_cache:  Enable cache for detected encoding.
 
1958
                        (This parameter is turned on by default,
 
1959
                        and required only for selftesting)
 
1960
 
2023
1961
    :return: A string defining the preferred user encoding
2024
1962
    """
2025
1963
    global _cached_user_encoding
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:
 
1964
    if _cached_user_encoding is not None and use_cache:
2030
1965
        return _cached_user_encoding
2031
1966
 
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)
 
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'
2038
1984
    else:
2039
 
        # GZ 2011-12-19: On windows could call GetACP directly instead.
2040
 
        user_encoding = locale.getpreferredencoding(False)
 
1985
        import locale
2041
1986
 
2042
1987
    try:
2043
 
        user_encoding = codecs.lookup(user_encoding).name
2044
 
    except LookupError:
2045
 
        if user_encoding not in ("", "cp0"):
 
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:
2046
2010
            sys.stderr.write('bzr: warning:'
2047
2011
                             ' unknown encoding %s.'
2048
2012
                             ' Continuing with ascii encoding.\n'
2049
2013
                             % user_encoding
2050
2014
                            )
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
 
2015
            user_encoding = 'ascii'
 
2016
 
 
2017
    if use_cache:
 
2018
        _cached_user_encoding = user_encoding
 
2019
 
2063
2020
    return user_encoding
2064
2021
 
2065
2022
 
2074
2031
    behaves inconsistently on different platforms.
2075
2032
    """
2076
2033
    if sys.platform == "win32":
 
2034
        import win32utils
2077
2035
        return win32utils.get_host_name()
2078
2036
    else:
2079
2037
        import socket
2086
2044
# data at once.
2087
2045
MAX_SOCKET_CHUNK = 64 * 1024
2088
2046
 
2089
 
_end_of_stream_errors = [errno.ECONNRESET, errno.EPIPE, errno.EINVAL]
 
2047
_end_of_stream_errors = [errno.ECONNRESET]
2090
2048
for _eno in ['WSAECONNRESET', 'WSAECONNABORTED']:
2091
2049
    _eno = getattr(errno, _eno, None)
2092
2050
    if _eno is not None:
2158
2116
    while sent_total < byte_count:
2159
2117
        try:
2160
2118
            sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
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)
 
2119
        except socket.error, e:
2165
2120
            if e.args[0] != errno.EINTR:
2166
2121
                raise
2167
2122
        else:
2168
 
            if sent == 0:
2169
 
                raise errors.ConnectionReset('Sending to %s returned 0 bytes'
2170
 
                                             % (sock,))
2171
2123
            sent_total += sent
2172
 
            if report_activity is not None:
2173
 
                report_activity(sent, 'write')
 
2124
            report_activity(sent, 'write')
2174
2125
 
2175
2126
 
2176
2127
def connect_socket(address):
2261
2212
    return file_kind_from_stat_mode(mode)
2262
2213
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
2263
2214
 
2264
 
def file_stat(f, _lstat=os.lstat):
 
2215
 
 
2216
def file_kind(f, _lstat=os.lstat):
2265
2217
    try:
2266
 
        # XXX cache?
2267
 
        return _lstat(f)
 
2218
        return file_kind_from_stat_mode(_lstat(f).st_mode)
2268
2219
    except OSError, e:
2269
2220
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
2270
2221
            raise errors.NoSuchFile(f)
2271
2222
        raise
2272
2223
 
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)
2276
2224
 
2277
2225
def until_no_eintr(f, *a, **kw):
2278
2226
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2322
2270
 
2323
2271
 
2324
2272
if sys.platform == "win32":
 
2273
    import msvcrt
2325
2274
    def getchar():
2326
 
        import msvcrt
2327
2275
        return msvcrt.getch()
2328
2276
else:
 
2277
    import tty
 
2278
    import termios
2329
2279
    def getchar():
2330
 
        import tty
2331
 
        import termios
2332
2280
        fd = sys.stdin.fileno()
2333
2281
        settings = termios.tcgetattr(fd)
2334
2282
        try:
2338
2286
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2339
2287
        return ch
2340
2288
 
2341
 
if sys.platform.startswith('linux'):
 
2289
if sys.platform == 'linux2':
2342
2290
    def _local_concurrency():
2343
2291
        try:
2344
2292
            return os.sysconf('SC_NPROCESSORS_ONLN')
2383
2331
    if concurrency is None:
2384
2332
        try:
2385
2333
            import multiprocessing
2386
 
            concurrency = multiprocessing.cpu_count()
2387
 
        except (ImportError, NotImplementedError):
 
2334
        except ImportError:
2388
2335
            # multiprocessing is only available on Python >= 2.6
2389
 
            # and multiprocessing.cpu_count() isn't implemented on all
2390
 
            # platforms
2391
2336
            try:
2392
2337
                concurrency = _local_concurrency()
2393
2338
            except (OSError, IOError):
2394
2339
                pass
 
2340
        else:
 
2341
            concurrency = multiprocessing.cpu_count()
2395
2342
    try:
2396
2343
        concurrency = int(concurrency)
2397
2344
    except (TypeError, ValueError):
2459
2406
    open_file = open
2460
2407
 
2461
2408
 
 
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
 
2462
2433
def available_backup_name(base, exists):
2463
2434
    """Find a non-existing backup file name.
2464
2435
 
2502
2473
    :param name: The base name of the executable.
2503
2474
    :return: The path to the executable found or None.
2504
2475
    """
 
2476
    path = os.environ.get('PATH')
 
2477
    if path is None:
 
2478
        return None
 
2479
    path = path.split(os.pathsep)
2505
2480
    if sys.platform == 'win32':
2506
2481
        exts = os.environ.get('PATHEXT', '').split(os.pathsep)
2507
2482
        exts = [ext.lower() for ext in exts]
2513
2488
            exts = [ext]
2514
2489
    else:
2515
2490
        exts = ['']
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
 
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
2528
2496
    return None
2529
2497
 
2530
2498
 
2554
2522
else:
2555
2523
    is_local_pid_dead = _posix_is_local_pid_dead
2556
2524
 
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
 
 
2561
2525
 
2562
2526
def fdatasync(fileno):
2563
2527
    """Flush file contents to disk if possible.
2567
2531
    """
2568
2532
    fn = getattr(os, 'fdatasync', getattr(os, 'fsync', None))
2569
2533
    if fn is not None:
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
 
2534
        fn(fileno)
2580
2535
 
2581
2536
 
2582
2537
def ensure_empty_directory_exists(path, exception_class):
2592
2547
            raise
2593
2548
        if os.listdir(path) != []:
2594
2549
            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