← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

Initial commit for russian version of documents.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
1
 
# Copyright (C) 2005, 2006, 2007, 2009 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
 
17
from cStringIO import StringIO
17
18
import os
18
19
import re
19
20
import stat
34
35
                    splitdrive as _nt_splitdrive,
35
36
                    )
36
37
import posixpath
 
38
import sha
37
39
import shutil
38
40
from shutil import (
39
41
    rmtree,
40
42
    )
41
 
import subprocess
42
43
import tempfile
43
44
from tempfile import (
44
45
    mkdtemp,
52
53
    )
53
54
""")
54
55
 
55
 
# sha and md5 modules are deprecated in python2.6 but hashlib is available as
56
 
# of 2.5
57
 
if sys.version_info < (2, 5):
58
 
    import md5 as _mod_md5
59
 
    md5 = _mod_md5.new
60
 
    import sha as _mod_sha
61
 
    sha = _mod_sha.new
62
 
else:
63
 
    from hashlib import (
64
 
        md5,
65
 
        sha1 as sha,
66
 
        )
67
 
 
68
56
 
69
57
import bzrlib
70
58
from bzrlib import symbol_versioning
 
59
from bzrlib.symbol_versioning import (
 
60
    deprecated_function,
 
61
    )
 
62
from bzrlib.trace import mutter
71
63
 
72
64
 
73
65
# On win32, O_BINARY is used to indicate the file should
78
70
O_BINARY = getattr(os, 'O_BINARY', 0)
79
71
 
80
72
 
81
 
def get_unicode_argv():
82
 
    try:
83
 
        user_encoding = get_user_encoding()
84
 
        return [a.decode(user_encoding) for a in sys.argv[1:]]
85
 
    except UnicodeDecodeError:
86
 
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
87
 
                                                            "encoding." % a))
88
 
 
89
 
 
90
73
def make_readonly(filename):
91
74
    """Make a filename read-only."""
92
75
    mod = os.lstat(filename).st_mode
107
90
 
108
91
    :param paths: A container (and hence not None) of paths.
109
92
    :return: A set of paths sufficient to include everything in paths via
110
 
        is_inside, drawn from the paths parameter.
 
93
        is_inside_any, drawn from the paths parameter.
111
94
    """
112
 
    if len(paths) < 2:
113
 
        return set(paths)
114
 
 
115
 
    def sort_key(path):
116
 
        return path.split('/')
117
 
    sorted_paths = sorted(list(paths), key=sort_key)
118
 
 
119
 
    search_paths = [sorted_paths[0]]
120
 
    for path in sorted_paths[1:]:
121
 
        if not is_inside(search_paths[-1], path):
122
 
            # This path is unique, add it
123
 
            search_paths.append(path)
124
 
 
125
 
    return set(search_paths)
 
95
    search_paths = set()
 
96
    paths = set(paths)
 
97
    for path in paths:
 
98
        other_paths = paths.difference([path])
 
99
        if not is_inside_any(other_paths, path):
 
100
            # this is a top level path, we must check it.
 
101
            search_paths.add(path)
 
102
    return search_paths
126
103
 
127
104
 
128
105
_QUOTE_RE = None
137
114
    global _QUOTE_RE
138
115
    if _QUOTE_RE is None:
139
116
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
140
 
 
 
117
        
141
118
    if _QUOTE_RE.search(f):
142
119
        return '"' + f + '"'
143
120
    else:
146
123
 
147
124
_directory_kind = 'directory'
148
125
 
 
126
_formats = {
 
127
    stat.S_IFDIR:_directory_kind,
 
128
    stat.S_IFCHR:'chardev',
 
129
    stat.S_IFBLK:'block',
 
130
    stat.S_IFREG:'file',
 
131
    stat.S_IFIFO:'fifo',
 
132
    stat.S_IFLNK:'symlink',
 
133
    stat.S_IFSOCK:'socket',
 
134
}
 
135
 
 
136
 
 
137
def file_kind_from_stat_mode(stat_mode, _formats=_formats, _unknown='unknown'):
 
138
    """Generate a file kind from a stat mode. This is used in walkdirs.
 
139
 
 
140
    Its performance is critical: Do not mutate without careful benchmarking.
 
141
    """
 
142
    try:
 
143
        return _formats[stat_mode & 0170000]
 
144
    except KeyError:
 
145
        return _unknown
 
146
 
 
147
 
 
148
def file_kind(f, _lstat=os.lstat, _mapper=file_kind_from_stat_mode):
 
149
    try:
 
150
        return _mapper(_lstat(f).st_mode)
 
151
    except OSError, e:
 
152
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
 
153
            raise errors.NoSuchFile(f)
 
154
        raise
 
155
 
 
156
 
149
157
def get_umask():
150
158
    """Return the current umask"""
151
159
    # Assume that people aren't messing with the umask while running
187
195
 
188
196
def fancy_rename(old, new, rename_func, unlink_func):
189
197
    """A fancy rename, when you don't have atomic rename.
190
 
 
 
198
    
191
199
    :param old: The old path, to rename from
192
200
    :param new: The new path, to rename to
193
201
    :param rename_func: The potentially non-atomic rename function
195
203
    """
196
204
 
197
205
    # sftp rename doesn't allow overwriting, so play tricks:
 
206
    import random
198
207
    base = os.path.basename(new)
199
208
    dirname = os.path.dirname(new)
200
209
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
307
316
        path = cwd + '\\' + path
308
317
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
309
318
 
 
319
if win32utils.winver == 'Windows 98':
 
320
    _win32_abspath = _win98_abspath
 
321
 
310
322
 
311
323
def _win32_realpath(path):
312
324
    # Real _nt_realpath doesn't have a problem with a unicode cwd
333
345
    """We expect to be able to atomically replace 'new' with old.
334
346
 
335
347
    On win32, if new exists, it must be moved out of the way first,
336
 
    and then deleted.
 
348
    and then deleted. 
337
349
    """
338
350
    try:
339
351
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
340
352
    except OSError, e:
341
353
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
342
 
            # If we try to rename a non-existant file onto cwd, we get
343
 
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT
 
354
            # If we try to rename a non-existant file onto cwd, we get 
 
355
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT 
344
356
            # if the old path doesn't exist, sometimes we get EACCES
345
357
            # On Linux, we seem to get EBUSY, on Mac we get EINVAL
346
358
            os.lstat(old)
371
383
 
372
384
 
373
385
if sys.platform == 'win32':
374
 
    if win32utils.winver == 'Windows 98':
375
 
        abspath = _win98_abspath
376
 
    else:
377
 
        abspath = _win32_abspath
 
386
    abspath = _win32_abspath
378
387
    realpath = _win32_realpath
379
388
    pathjoin = _win32_pathjoin
380
389
    normpath = _win32_normpath
400
409
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
401
410
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
402
411
        return shutil.rmtree(path, ignore_errors, onerror)
403
 
 
404
 
    f = win32utils.get_unicode_argv     # special function or None
405
 
    if f is not None:
406
 
        get_unicode_argv = f
407
 
 
408
412
elif sys.platform == 'darwin':
409
413
    getcwd = _mac_getcwd
410
414
 
414
418
 
415
419
    This attempts to check both sys.stdout and sys.stdin to see
416
420
    what encoding they are in, and if that fails it falls back to
417
 
    osutils.get_user_encoding().
 
421
    bzrlib.user_encoding.
418
422
    The problem is that on Windows, locale.getpreferredencoding()
419
423
    is not the same encoding as that used by the console:
420
424
    http://mail.python.org/pipermail/python-list/2003-May/162357.html
422
426
    On my standard US Windows XP, the preferred encoding is
423
427
    cp1252, but the console is cp437
424
428
    """
425
 
    from bzrlib.trace import mutter
426
429
    output_encoding = getattr(sys.stdout, 'encoding', None)
427
430
    if not output_encoding:
428
431
        input_encoding = getattr(sys.stdin, 'encoding', None)
429
432
        if not input_encoding:
430
 
            output_encoding = get_user_encoding()
431
 
            mutter('encoding stdout as osutils.get_user_encoding() %r',
432
 
                   output_encoding)
 
433
            output_encoding = bzrlib.user_encoding
 
434
            mutter('encoding stdout as bzrlib.user_encoding %r', output_encoding)
433
435
        else:
434
436
            output_encoding = input_encoding
435
437
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
437
439
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
438
440
    if output_encoding == 'cp0':
439
441
        # invalid encoding (cp0 means 'no codepage' on Windows)
440
 
        output_encoding = get_user_encoding()
 
442
        output_encoding = bzrlib.user_encoding
441
443
        mutter('cp0 is invalid encoding.'
442
 
               ' encoding stdout as osutils.get_user_encoding() %r',
443
 
               output_encoding)
 
444
               ' encoding stdout as bzrlib.user_encoding %r', output_encoding)
444
445
    # check encoding
445
446
    try:
446
447
        codecs.lookup(output_encoding)
448
449
        sys.stderr.write('bzr: warning:'
449
450
                         ' unknown terminal encoding %s.\n'
450
451
                         '  Using encoding %s instead.\n'
451
 
                         % (output_encoding, get_user_encoding())
 
452
                         % (output_encoding, bzrlib.user_encoding)
452
453
                        )
453
 
        output_encoding = get_user_encoding()
 
454
        output_encoding = bzrlib.user_encoding
454
455
 
455
456
    return output_encoding
456
457
 
491
492
 
492
493
def is_inside(dir, fname):
493
494
    """True if fname is inside dir.
494
 
 
 
495
    
495
496
    The parameters should typically be passed to osutils.normpath first, so
496
497
    that . and .. and repeated slashes are eliminated, and the separators
497
498
    are canonical for the platform.
498
 
 
499
 
    The empty string as a dir name is taken as top-of-tree and matches
 
499
    
 
500
    The empty string as a dir name is taken as top-of-tree and matches 
500
501
    everything.
501
502
    """
502
 
    # XXX: Most callers of this can actually do something smarter by
 
503
    # XXX: Most callers of this can actually do something smarter by 
503
504
    # looking at the inventory
504
505
    if dir == fname:
505
506
        return True
506
 
 
 
507
    
507
508
    if dir == '':
508
509
        return True
509
510
 
529
530
    return False
530
531
 
531
532
 
532
 
def pumpfile(from_file, to_file, read_length=-1, buff_size=32768,
533
 
             report_activity=None, direction='read'):
 
533
def pumpfile(from_file, to_file, read_length=-1, buff_size=32768):
534
534
    """Copy contents of one file to another.
535
535
 
536
536
    The read_length can either be -1 to read to end-of-file (EOF) or
539
539
    The buff_size represents the maximum size for each read operation
540
540
    performed on from_file.
541
541
 
542
 
    :param report_activity: Call this as bytes are read, see
543
 
        Transport._report_activity
544
 
    :param direction: Will be passed to report_activity
545
 
 
546
542
    :return: The number of bytes copied.
547
543
    """
548
544
    length = 0
556
552
            if not block:
557
553
                # EOF reached
558
554
                break
559
 
            if report_activity is not None:
560
 
                report_activity(len(block), direction)
561
555
            to_file.write(block)
562
556
 
563
557
            actual_bytes_read = len(block)
570
564
            if not block:
571
565
                # EOF reached
572
566
                break
573
 
            if report_activity is not None:
574
 
                report_activity(len(block), direction)
575
567
            to_file.write(block)
576
568
            length += len(block)
577
569
    return length
578
570
 
579
571
 
580
 
def pump_string_file(bytes, file_handle, segment_size=None):
581
 
    """Write bytes to file_handle in many smaller writes.
582
 
 
583
 
    :param bytes: The string to write.
584
 
    :param file_handle: The file to write to.
585
 
    """
586
 
    # Write data in chunks rather than all at once, because very large
587
 
    # writes fail on some platforms (e.g. Windows with SMB  mounted
588
 
    # drives).
589
 
    if not segment_size:
590
 
        segment_size = 5242880 # 5MB
591
 
    segments = range(len(bytes) / segment_size + 1)
592
 
    write = file_handle.write
593
 
    for segment_index in segments:
594
 
        segment = buffer(bytes, segment_index * segment_size, segment_size)
595
 
        write(segment)
596
 
 
597
 
 
598
572
def file_iterator(input_file, readsize=32768):
599
573
    while True:
600
574
        b = input_file.read(readsize)
608
582
 
609
583
    The file cursor should be already at the start.
610
584
    """
611
 
    s = sha()
 
585
    s = sha.new()
612
586
    BUFSIZE = 128<<10
613
587
    while True:
614
588
        b = f.read(BUFSIZE)
618
592
    return s.hexdigest()
619
593
 
620
594
 
621
 
def size_sha_file(f):
622
 
    """Calculate the size and hexdigest of an open file.
623
 
 
624
 
    The file cursor should be already at the start and
625
 
    the caller is responsible for closing the file afterwards.
626
 
    """
627
 
    size = 0
628
 
    s = sha()
629
 
    BUFSIZE = 128<<10
630
 
    while True:
631
 
        b = f.read(BUFSIZE)
632
 
        if not b:
633
 
            break
634
 
        size += len(b)
635
 
        s.update(b)
636
 
    return size, s.hexdigest()
637
 
 
638
 
 
639
595
def sha_file_by_name(fname):
640
596
    """Calculate the SHA1 of a file by reading the full text"""
641
 
    s = sha()
 
597
    s = sha.new()
642
598
    f = os.open(fname, os.O_RDONLY | O_BINARY)
643
599
    try:
644
600
        while True:
650
606
        os.close(f)
651
607
 
652
608
 
653
 
def sha_strings(strings, _factory=sha):
 
609
def sha_strings(strings, _factory=sha.new):
654
610
    """Return the sha-1 of concatenation of strings"""
655
611
    s = _factory()
656
612
    map(s.update, strings)
657
613
    return s.hexdigest()
658
614
 
659
615
 
660
 
def sha_string(f, _factory=sha):
 
616
def sha_string(f, _factory=sha.new):
661
617
    return _factory(f).hexdigest()
662
618
 
663
619
 
664
620
def fingerprint_file(f):
665
621
    b = f.read()
666
622
    return {'size': len(b),
667
 
            'sha1': sha(b).hexdigest()}
 
623
            'sha1': sha.new(b).hexdigest()}
668
624
 
669
625
 
670
626
def compare_files(a, b):
687
643
    return offset.days * 86400 + offset.seconds
688
644
 
689
645
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
690
 
 
 
646
    
691
647
def format_date(t, offset=0, timezone='original', date_fmt=None,
692
648
                show_offset=True):
693
649
    """Return a formatted date string.
697
653
    :param timezone: How to display the time: 'utc', 'original' for the
698
654
         timezone specified by offset, or 'local' for the process's current
699
655
         timezone.
700
 
    :param date_fmt: strftime format.
701
 
    :param show_offset: Whether to append the timezone.
702
 
    """
703
 
    (date_fmt, tt, offset_str) = \
704
 
               _format_date(t, offset, timezone, date_fmt, show_offset)
705
 
    date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
706
 
    date_str = time.strftime(date_fmt, tt)
707
 
    return date_str + offset_str
708
 
 
709
 
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
710
 
                      show_offset=True):
711
 
    """Return an unicode date string formatted according to the current locale.
712
 
 
713
 
    :param t: Seconds since the epoch.
714
 
    :param offset: Timezone offset in seconds east of utc.
715
 
    :param timezone: How to display the time: 'utc', 'original' for the
716
 
         timezone specified by offset, or 'local' for the process's current
717
 
         timezone.
718
 
    :param date_fmt: strftime format.
719
 
    :param show_offset: Whether to append the timezone.
720
 
    """
721
 
    (date_fmt, tt, offset_str) = \
722
 
               _format_date(t, offset, timezone, date_fmt, show_offset)
723
 
    date_str = time.strftime(date_fmt, tt)
724
 
    if not isinstance(date_str, unicode):
725
 
        date_str = date_str.decode(get_user_encoding(), 'replace')
726
 
    return date_str + offset_str
727
 
 
728
 
def _format_date(t, offset, timezone, date_fmt, show_offset):
 
656
    :param show_offset: Whether to append the timezone.
 
657
    :param date_fmt: strftime format.
 
658
    """
729
659
    if timezone == 'utc':
730
660
        tt = time.gmtime(t)
731
661
        offset = 0
744
674
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
745
675
    else:
746
676
        offset_str = ''
747
 
    return (date_fmt, tt, offset_str)
 
677
    # day of week depends on locale, so we do this ourself
 
678
    date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
 
679
    return (time.strftime(date_fmt, tt) +  offset_str)
748
680
 
749
681
 
750
682
def compact_date(when):
751
683
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
752
 
 
 
684
    
753
685
 
754
686
def format_delta(delta):
755
687
    """Get a nice looking string for a time delta.
831
763
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
832
764
def rand_chars(num):
833
765
    """Return a random string of num alphanumeric characters
834
 
 
835
 
    The result only contains lowercase chars because it may be used on
 
766
    
 
767
    The result only contains lowercase chars because it may be used on 
836
768
    case-insensitive filesystems.
837
769
    """
838
770
    s = ''
860
792
            rps.append(f)
861
793
    return rps
862
794
 
863
 
 
864
795
def joinpath(p):
865
796
    for f in p:
866
797
        if (f == '..') or (f is None) or (f == ''):
868
799
    return pathjoin(*p)
869
800
 
870
801
 
871
 
def parent_directories(filename):
872
 
    """Return the list of parent directories, deepest first.
873
 
    
874
 
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
875
 
    """
876
 
    parents = []
877
 
    parts = splitpath(dirname(filename))
878
 
    while parts:
879
 
        parents.append(joinpath(parts))
880
 
        parts.pop()
881
 
    return parents
882
 
 
883
 
 
884
 
try:
885
 
    from bzrlib._chunks_to_lines_pyx import chunks_to_lines
886
 
except ImportError:
887
 
    from bzrlib._chunks_to_lines_py import chunks_to_lines
888
 
 
889
 
 
890
802
def split_lines(s):
891
803
    """Split s into lines, but without removing the newline characters."""
892
 
    # Trivially convert a fulltext into a 'chunked' representation, and let
893
 
    # chunks_to_lines do the heavy lifting.
894
 
    if isinstance(s, str):
895
 
        # chunks_to_lines only supports 8-bit strings
896
 
        return chunks_to_lines([s])
897
 
    else:
898
 
        return _split_lines(s)
899
 
 
900
 
 
901
 
def _split_lines(s):
902
 
    """Split s into lines, but without removing the newline characters.
903
 
 
904
 
    This supports Unicode or plain string objects.
905
 
    """
906
804
    lines = s.split('\n')
907
805
    result = [line + '\n' for line in lines[:-1]]
908
806
    if lines[-1]:
927
825
        shutil.copyfile(src, dest)
928
826
 
929
827
 
 
828
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
 
829
# Forgiveness than Permission (EAFP) because:
 
830
# - root can damage a solaris file system by using unlink,
 
831
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
 
832
#   EACCES, OSX: EPERM) when invoked on a directory.
930
833
def delete_any(path):
931
 
    """Delete a file, symlink or directory.  
932
 
    
933
 
    Will delete even if readonly.
934
 
    """
935
 
    try:
936
 
       _delete_file_or_dir(path)
937
 
    except (OSError, IOError), e:
938
 
        if e.errno in (errno.EPERM, errno.EACCES):
939
 
            # make writable and try again
940
 
            try:
941
 
                make_writable(path)
942
 
            except (OSError, IOError):
943
 
                pass
944
 
            _delete_file_or_dir(path)
945
 
        else:
946
 
            raise
947
 
 
948
 
 
949
 
def _delete_file_or_dir(path):
950
 
    # Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
951
 
    # Forgiveness than Permission (EAFP) because:
952
 
    # - root can damage a solaris file system by using unlink,
953
 
    # - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
954
 
    #   EACCES, OSX: EPERM) when invoked on a directory.
 
834
    """Delete a file or directory."""
955
835
    if isdir(path): # Takes care of symlinks
956
836
        os.rmdir(path)
957
837
    else:
977
857
            and sys.platform not in ('cygwin', 'win32'))
978
858
 
979
859
 
980
 
def readlink(abspath):
981
 
    """Return a string representing the path to which the symbolic link points.
982
 
 
983
 
    :param abspath: The link absolute unicode path.
984
 
 
985
 
    This his guaranteed to return the symbolic link in unicode in all python
986
 
    versions.
987
 
    """
988
 
    link = abspath.encode(_fs_enc)
989
 
    target = os.readlink(link)
990
 
    target = target.decode(_fs_enc)
991
 
    return target
992
 
 
993
 
 
994
860
def contains_whitespace(s):
995
861
    """True if there are any whitespace characters in s."""
996
862
    # string.whitespace can include '\xa0' in certain locales, because it is
1040
906
 
1041
907
    s = []
1042
908
    head = rp
1043
 
    while True:
1044
 
        if len(head) <= len(base) and head != base:
1045
 
            raise errors.PathNotChild(rp, base)
 
909
    while len(head) >= len(base):
1046
910
        if head == base:
1047
911
            break
1048
 
        head, tail = split(head)
 
912
        head, tail = os.path.split(head)
1049
913
        if tail:
1050
 
            s.append(tail)
 
914
            s.insert(0, tail)
 
915
    else:
 
916
        raise errors.PathNotChild(rp, base)
1051
917
 
1052
918
    if s:
1053
 
        return pathjoin(*reversed(s))
 
919
        return pathjoin(*s)
1054
920
    else:
1055
921
        return ''
1056
922
 
1057
923
 
1058
 
def _cicp_canonical_relpath(base, path):
1059
 
    """Return the canonical path relative to base.
1060
 
 
1061
 
    Like relpath, but on case-insensitive-case-preserving file-systems, this
1062
 
    will return the relpath as stored on the file-system rather than in the
1063
 
    case specified in the input string, for all existing portions of the path.
1064
 
 
1065
 
    This will cause O(N) behaviour if called for every path in a tree; if you
1066
 
    have a number of paths to convert, you should use canonical_relpaths().
1067
 
    """
1068
 
    # TODO: it should be possible to optimize this for Windows by using the
1069
 
    # win32 API FindFiles function to look for the specified name - but using
1070
 
    # os.listdir() still gives us the correct, platform agnostic semantics in
1071
 
    # the short term.
1072
 
 
1073
 
    rel = relpath(base, path)
1074
 
    # '.' will have been turned into ''
1075
 
    if not rel:
1076
 
        return rel
1077
 
 
1078
 
    abs_base = abspath(base)
1079
 
    current = abs_base
1080
 
    _listdir = os.listdir
1081
 
 
1082
 
    # use an explicit iterator so we can easily consume the rest on early exit.
1083
 
    bit_iter = iter(rel.split('/'))
1084
 
    for bit in bit_iter:
1085
 
        lbit = bit.lower()
1086
 
        for look in _listdir(current):
1087
 
            if lbit == look.lower():
1088
 
                current = pathjoin(current, look)
1089
 
                break
1090
 
        else:
1091
 
            # got to the end, nothing matched, so we just return the
1092
 
            # non-existing bits as they were specified (the filename may be
1093
 
            # the target of a move, for example).
1094
 
            current = pathjoin(current, bit, *list(bit_iter))
1095
 
            break
1096
 
    return current[len(abs_base)+1:]
1097
 
 
1098
 
# XXX - TODO - we need better detection/integration of case-insensitive
1099
 
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
1100
 
# filesystems), for example, so could probably benefit from the same basic
1101
 
# support there.  For now though, only Windows and OSX get that support, and
1102
 
# they get it for *all* file-systems!
1103
 
if sys.platform in ('win32', 'darwin'):
1104
 
    canonical_relpath = _cicp_canonical_relpath
1105
 
else:
1106
 
    canonical_relpath = relpath
1107
 
 
1108
 
def canonical_relpaths(base, paths):
1109
 
    """Create an iterable to canonicalize a sequence of relative paths.
1110
 
 
1111
 
    The intent is for this implementation to use a cache, vastly speeding
1112
 
    up multiple transformations in the same directory.
1113
 
    """
1114
 
    # but for now, we haven't optimized...
1115
 
    return [canonical_relpath(base, p) for p in paths]
1116
 
 
1117
924
def safe_unicode(unicode_or_utf8_string):
1118
925
    """Coerce unicode_or_utf8_string into unicode.
1119
926
 
1120
927
    If it is unicode, it is returned.
1121
 
    Otherwise it is decoded from utf-8. If decoding fails, the exception is
1122
 
    wrapped in a BzrBadParameterNotUnicode exception.
 
928
    Otherwise it is decoded from utf-8. If a decoding error
 
929
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
 
930
    as a BzrBadParameter exception.
1123
931
    """
1124
932
    if isinstance(unicode_or_utf8_string, unicode):
1125
933
        return unicode_or_utf8_string
1212
1020
 
1213
1021
    On platforms where the system normalizes filenames (Mac OSX),
1214
1022
    you can access a file by any path which will normalize correctly.
1215
 
    On platforms where the system does not normalize filenames
 
1023
    On platforms where the system does not normalize filenames 
1216
1024
    (Windows, Linux), you have to access a file by its exact path.
1217
1025
 
1218
 
    Internally, bzr only supports NFC normalization, since that is
 
1026
    Internally, bzr only supports NFC normalization, since that is 
1219
1027
    the standard for XML documents.
1220
1028
 
1221
1029
    So return the normalized path, and a flag indicating if the file
1292
1100
            del os.environ[env_variable]
1293
1101
    else:
1294
1102
        if isinstance(value, unicode):
1295
 
            value = value.encode(get_user_encoding())
 
1103
            value = value.encode(bzrlib.user_encoding)
1296
1104
        os.environ[env_variable] = value
1297
1105
    return orig_val
1298
1106
 
1301
1109
 
1302
1110
 
1303
1111
def check_legal_path(path):
1304
 
    """Check whether the supplied path is legal.
 
1112
    """Check whether the supplied path is legal.  
1305
1113
    This is only required on Windows, so we don't test on other platforms
1306
1114
    right now.
1307
1115
    """
1341
1149
 
1342
1150
def walkdirs(top, prefix=""):
1343
1151
    """Yield data about all the directories in a tree.
1344
 
 
 
1152
    
1345
1153
    This yields all the data about the contents of a directory at a time.
1346
1154
    After each directory has been yielded, if the caller has mutated the list
1347
1155
    to exclude some directories, they are then not descended into.
1348
 
 
 
1156
    
1349
1157
    The data yielded is of the form:
1350
1158
    ((directory-relpath, directory-path-from-top),
1351
1159
    [(relpath, basename, kind, lstat, path-from-top), ...]),
1352
1160
     - directory-relpath is the relative path of the directory being returned
1353
1161
       with respect to top. prefix is prepended to this.
1354
 
     - directory-path-from-root is the path including top for this directory.
 
1162
     - directory-path-from-root is the path including top for this directory. 
1355
1163
       It is suitable for use with os functions.
1356
1164
     - relpath is the relative path within the subtree being walked.
1357
1165
     - basename is the basename of the path
1359
1167
       present within the tree - but it may be recorded as versioned. See
1360
1168
       versioned_kind.
1361
1169
     - lstat is the stat data *if* the file was statted.
1362
 
     - planned, not implemented:
 
1170
     - planned, not implemented: 
1363
1171
       path_from_tree_root is the path from the root of the tree.
1364
1172
 
1365
 
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This
 
1173
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This 
1366
1174
        allows one to walk a subtree but get paths that are relative to a tree
1367
1175
        rooted higher up.
1368
1176
    :return: an iterator over the dirs.
1369
1177
    """
1370
1178
    #TODO there is a bit of a smell where the results of the directory-
1371
 
    # summary in this, and the path from the root, may not agree
 
1179
    # summary in this, and the path from the root, may not agree 
1372
1180
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
1373
1181
    # potentially confusing output. We should make this more robust - but
1374
1182
    # not at a speed cost. RBC 20060731
1375
1183
    _lstat = os.lstat
1376
1184
    _directory = _directory_kind
1377
1185
    _listdir = os.listdir
1378
 
    _kind_from_mode = file_kind_from_stat_mode
 
1186
    _kind_from_mode = _formats.get
1379
1187
    pending = [(safe_unicode(prefix), "", _directory, None, safe_unicode(top))]
1380
1188
    while pending:
1381
1189
        # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1397
1205
            for name in names:
1398
1206
                abspath = top_slash + name
1399
1207
                statvalue = _lstat(abspath)
1400
 
                kind = _kind_from_mode(statvalue.st_mode)
 
1208
                kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
1401
1209
                append((relprefix + name, name, kind, statvalue, abspath))
1402
1210
        yield (relroot, top), dirblock
1403
1211
 
1405
1213
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
1406
1214
 
1407
1215
 
1408
 
class DirReader(object):
1409
 
    """An interface for reading directories."""
1410
 
 
1411
 
    def top_prefix_to_starting_dir(self, top, prefix=""):
1412
 
        """Converts top and prefix to a starting dir entry
1413
 
 
1414
 
        :param top: A utf8 path
1415
 
        :param prefix: An optional utf8 path to prefix output relative paths
1416
 
            with.
1417
 
        :return: A tuple starting with prefix, and ending with the native
1418
 
            encoding of top.
1419
 
        """
1420
 
        raise NotImplementedError(self.top_prefix_to_starting_dir)
1421
 
 
1422
 
    def read_dir(self, prefix, top):
1423
 
        """Read a specific dir.
1424
 
 
1425
 
        :param prefix: A utf8 prefix to be preprended to the path basenames.
1426
 
        :param top: A natively encoded path to read.
1427
 
        :return: A list of the directories contents. Each item contains:
1428
 
            (utf8_relpath, utf8_name, kind, lstatvalue, native_abspath)
1429
 
        """
1430
 
        raise NotImplementedError(self.read_dir)
1431
 
 
1432
 
 
1433
 
_selected_dir_reader = None
1434
 
 
 
1216
_real_walkdirs_utf8 = None
1435
1217
 
1436
1218
def _walkdirs_utf8(top, prefix=""):
1437
1219
    """Yield data about all the directories in a tree.
1447
1229
        path-from-top might be unicode or utf8, but it is the correct path to
1448
1230
        pass to os functions to affect the file in question. (such as os.lstat)
1449
1231
    """
1450
 
    global _selected_dir_reader
1451
 
    if _selected_dir_reader is None:
 
1232
    global _real_walkdirs_utf8
 
1233
    if _real_walkdirs_utf8 is None:
1452
1234
        fs_encoding = _fs_enc.upper()
1453
 
        if sys.platform == "win32" and win32utils.winver == 'Windows NT':
 
1235
        if win32utils.winver == 'Windows NT':
1454
1236
            # Win98 doesn't have unicode apis like FindFirstFileW
1455
1237
            # TODO: We possibly could support Win98 by falling back to the
1456
1238
            #       original FindFirstFile, and using TCHAR instead of WCHAR,
1457
1239
            #       but that gets a bit tricky, and requires custom compiling
1458
1240
            #       for win98 anyway.
1459
1241
            try:
1460
 
                from bzrlib._walkdirs_win32 import Win32ReadDir
1461
 
                _selected_dir_reader = Win32ReadDir()
 
1242
                from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
1462
1243
            except ImportError:
1463
 
                pass
1464
 
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
 
1244
                _real_walkdirs_utf8 = _walkdirs_unicode_to_utf8
 
1245
            else:
 
1246
                _real_walkdirs_utf8 = _walkdirs_utf8_win32_find_file
 
1247
        elif fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1465
1248
            # ANSI_X3.4-1968 is a form of ASCII
1466
 
            try:
1467
 
                from bzrlib._readdir_pyx import UTF8DirReader
1468
 
                _selected_dir_reader = UTF8DirReader()
1469
 
            except ImportError:
1470
 
                pass
1471
 
 
1472
 
    if _selected_dir_reader is None:
1473
 
        # Fallback to the python version
1474
 
        _selected_dir_reader = UnicodeDirReader()
 
1249
            _real_walkdirs_utf8 = _walkdirs_unicode_to_utf8
 
1250
        else:
 
1251
            _real_walkdirs_utf8 = _walkdirs_fs_utf8
 
1252
    return _real_walkdirs_utf8(top, prefix=prefix)
 
1253
 
 
1254
 
 
1255
def _walkdirs_fs_utf8(top, prefix=""):
 
1256
    """See _walkdirs_utf8.
 
1257
 
 
1258
    This sub-function is called when we know the filesystem is already in utf8
 
1259
    encoding. So we don't need to transcode filenames.
 
1260
    """
 
1261
    _lstat = os.lstat
 
1262
    _directory = _directory_kind
 
1263
    _listdir = os.listdir
 
1264
    _kind_from_mode = _formats.get
1475
1265
 
1476
1266
    # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1477
1267
    # But we don't actually uses 1-3 in pending, so set them to None
1478
 
    pending = [[_selected_dir_reader.top_prefix_to_starting_dir(top, prefix)]]
1479
 
    read_dir = _selected_dir_reader.read_dir
1480
 
    _directory = _directory_kind
 
1268
    pending = [(safe_utf8(prefix), None, None, None, safe_utf8(top))]
1481
1269
    while pending:
1482
 
        relroot, _, _, _, top = pending[-1].pop()
1483
 
        if not pending[-1]:
1484
 
            pending.pop()
1485
 
        dirblock = sorted(read_dir(relroot, top))
 
1270
        relroot, _, _, _, top = pending.pop()
 
1271
        if relroot:
 
1272
            relprefix = relroot + '/'
 
1273
        else:
 
1274
            relprefix = ''
 
1275
        top_slash = top + '/'
 
1276
 
 
1277
        dirblock = []
 
1278
        append = dirblock.append
 
1279
        for name in sorted(_listdir(top)):
 
1280
            abspath = top_slash + name
 
1281
            statvalue = _lstat(abspath)
 
1282
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
 
1283
            append((relprefix + name, name, kind, statvalue, abspath))
1486
1284
        yield (relroot, top), dirblock
 
1285
 
1487
1286
        # push the user specified dirs from dirblock
1488
 
        next = [d for d in reversed(dirblock) if d[2] == _directory]
1489
 
        if next:
1490
 
            pending.append(next)
1491
 
 
1492
 
 
1493
 
class UnicodeDirReader(DirReader):
1494
 
    """A dir reader for non-utf8 file systems, which transcodes."""
1495
 
 
1496
 
    __slots__ = ['_utf8_encode']
1497
 
 
1498
 
    def __init__(self):
1499
 
        self._utf8_encode = codecs.getencoder('utf8')
1500
 
 
1501
 
    def top_prefix_to_starting_dir(self, top, prefix=""):
1502
 
        """See DirReader.top_prefix_to_starting_dir."""
1503
 
        return (safe_utf8(prefix), None, None, None, safe_unicode(top))
1504
 
 
1505
 
    def read_dir(self, prefix, top):
1506
 
        """Read a single directory from a non-utf8 file system.
1507
 
 
1508
 
        top, and the abspath element in the output are unicode, all other paths
1509
 
        are utf8. Local disk IO is done via unicode calls to listdir etc.
1510
 
 
1511
 
        This is currently the fallback code path when the filesystem encoding is
1512
 
        not UTF-8. It may be better to implement an alternative so that we can
1513
 
        safely handle paths that are not properly decodable in the current
1514
 
        encoding.
1515
 
 
1516
 
        See DirReader.read_dir for details.
1517
 
        """
1518
 
        _utf8_encode = self._utf8_encode
1519
 
        _lstat = os.lstat
1520
 
        _listdir = os.listdir
1521
 
        _kind_from_mode = file_kind_from_stat_mode
1522
 
 
1523
 
        if prefix:
1524
 
            relprefix = prefix + '/'
 
1287
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
 
1288
 
 
1289
 
 
1290
def _walkdirs_unicode_to_utf8(top, prefix=""):
 
1291
    """See _walkdirs_utf8
 
1292
 
 
1293
    Because Win32 has a Unicode api, all of the 'path-from-top' entries will be
 
1294
    Unicode paths.
 
1295
    This is currently the fallback code path when the filesystem encoding is
 
1296
    not UTF-8. It may be better to implement an alternative so that we can
 
1297
    safely handle paths that are not properly decodable in the current
 
1298
    encoding.
 
1299
    """
 
1300
    _utf8_encode = codecs.getencoder('utf8')
 
1301
    _lstat = os.lstat
 
1302
    _directory = _directory_kind
 
1303
    _listdir = os.listdir
 
1304
    _kind_from_mode = _formats.get
 
1305
 
 
1306
    pending = [(safe_utf8(prefix), None, None, None, safe_unicode(top))]
 
1307
    while pending:
 
1308
        relroot, _, _, _, top = pending.pop()
 
1309
        if relroot:
 
1310
            relprefix = relroot + '/'
1525
1311
        else:
1526
1312
            relprefix = ''
1527
1313
        top_slash = top + u'/'
1529
1315
        dirblock = []
1530
1316
        append = dirblock.append
1531
1317
        for name in sorted(_listdir(top)):
1532
 
            try:
1533
 
                name_utf8 = _utf8_encode(name)[0]
1534
 
            except UnicodeDecodeError:
1535
 
                raise errors.BadFilenameEncoding(
1536
 
                    _utf8_encode(relprefix)[0] + name, _fs_enc)
 
1318
            name_utf8 = _utf8_encode(name)[0]
1537
1319
            abspath = top_slash + name
1538
1320
            statvalue = _lstat(abspath)
1539
 
            kind = _kind_from_mode(statvalue.st_mode)
 
1321
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
1540
1322
            append((relprefix + name_utf8, name_utf8, kind, statvalue, abspath))
1541
 
        return dirblock
 
1323
        yield (relroot, top), dirblock
 
1324
 
 
1325
        # push the user specified dirs from dirblock
 
1326
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
1542
1327
 
1543
1328
 
1544
1329
def copy_tree(from_path, to_path, handlers={}):
1545
1330
    """Copy all of the entries in from_path into to_path.
1546
1331
 
1547
 
    :param from_path: The base directory to copy.
 
1332
    :param from_path: The base directory to copy. 
1548
1333
    :param to_path: The target directory. If it does not exist, it will
1549
1334
        be created.
1550
1335
    :param handlers: A dictionary of functions, which takes a source and
1619
1404
        return _cached_user_encoding
1620
1405
 
1621
1406
    if sys.platform == 'darwin':
1622
 
        # python locale.getpreferredencoding() always return
1623
 
        # 'mac-roman' on darwin. That's a lie.
 
1407
        # work around egregious python 2.4 bug
1624
1408
        sys.platform = 'posix'
1625
1409
        try:
1626
 
            if os.environ.get('LANG', None) is None:
1627
 
                # If LANG is not set, we end up with 'ascii', which is bad
1628
 
                # ('mac-roman' is more than ascii), so we set a default which
1629
 
                # will give us UTF-8 (which appears to work in all cases on
1630
 
                # OSX). Users are still free to override LANG of course, as
1631
 
                # long as it give us something meaningful. This work-around
1632
 
                # *may* not be needed with python 3k and/or OSX 10.5, but will
1633
 
                # work with them too -- vila 20080908
1634
 
                os.environ['LANG'] = 'en_US.UTF-8'
1635
1410
            import locale
1636
1411
        finally:
1637
1412
            sys.platform = 'darwin'
1674
1449
    return user_encoding
1675
1450
 
1676
1451
 
1677
 
def get_host_name():
1678
 
    """Return the current unicode host name.
1679
 
 
1680
 
    This is meant to be used in place of socket.gethostname() because that
1681
 
    behaves inconsistently on different platforms.
1682
 
    """
1683
 
    if sys.platform == "win32":
1684
 
        import win32utils
1685
 
        return win32utils.get_host_name()
1686
 
    else:
1687
 
        import socket
1688
 
        return socket.gethostname().decode(get_user_encoding())
1689
 
 
1690
 
 
1691
1452
def recv_all(socket, bytes):
1692
1453
    """Receive an exact number of bytes.
1693
1454
 
1700
1461
    """
1701
1462
    b = ''
1702
1463
    while len(b) < bytes:
1703
 
        new = until_no_eintr(socket.recv, bytes - len(b))
 
1464
        new = socket.recv(bytes - len(b))
1704
1465
        if new == '':
1705
1466
            break # eof
1706
1467
        b += new
1707
1468
    return b
1708
1469
 
1709
1470
 
1710
 
def send_all(socket, bytes, report_activity=None):
 
1471
def send_all(socket, bytes):
1711
1472
    """Send all bytes on a socket.
1712
1473
 
1713
1474
    Regular socket.sendall() can give socket error 10053 on Windows.  This
1714
1475
    implementation sends no more than 64k at a time, which avoids this problem.
1715
 
 
1716
 
    :param report_activity: Call this as bytes are read, see
1717
 
        Transport._report_activity
1718
1476
    """
1719
1477
    chunk_size = 2**16
1720
1478
    for pos in xrange(0, len(bytes), chunk_size):
1721
 
        block = bytes[pos:pos+chunk_size]
1722
 
        if report_activity is not None:
1723
 
            report_activity(len(block), 'write')
1724
 
        until_no_eintr(socket.sendall, block)
 
1479
        socket.sendall(bytes[pos:pos+chunk_size])
1725
1480
 
1726
1481
 
1727
1482
def dereference_path(path):
1770
1525
        base = abspath(pathjoin(base, '..', '..'))
1771
1526
    filename = pathjoin(base, resource_relpath)
1772
1527
    return open(filename, 'rU').read()
1773
 
 
1774
 
 
1775
 
def file_kind_from_stat_mode_thunk(mode):
1776
 
    global file_kind_from_stat_mode
1777
 
    if file_kind_from_stat_mode is file_kind_from_stat_mode_thunk:
1778
 
        try:
1779
 
            from bzrlib._readdir_pyx import UTF8DirReader
1780
 
            file_kind_from_stat_mode = UTF8DirReader().kind_from_mode
1781
 
        except ImportError:
1782
 
            from bzrlib._readdir_py import (
1783
 
                _kind_from_mode as file_kind_from_stat_mode
1784
 
                )
1785
 
    return file_kind_from_stat_mode(mode)
1786
 
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
1787
 
 
1788
 
 
1789
 
def file_kind(f, _lstat=os.lstat):
1790
 
    try:
1791
 
        return file_kind_from_stat_mode(_lstat(f).st_mode)
1792
 
    except OSError, e:
1793
 
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
1794
 
            raise errors.NoSuchFile(f)
1795
 
        raise
1796
 
 
1797
 
 
1798
 
def until_no_eintr(f, *a, **kw):
1799
 
    """Run f(*a, **kw), retrying if an EINTR error occurs."""
1800
 
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
1801
 
    while True:
1802
 
        try:
1803
 
            return f(*a, **kw)
1804
 
        except (IOError, OSError), e:
1805
 
            if e.errno == errno.EINTR:
1806
 
                continue
1807
 
            raise
1808
 
 
1809
 
def re_compile_checked(re_string, flags=0, where=""):
1810
 
    """Return a compiled re, or raise a sensible error.
1811
 
 
1812
 
    This should only be used when compiling user-supplied REs.
1813
 
 
1814
 
    :param re_string: Text form of regular expression.
1815
 
    :param flags: eg re.IGNORECASE
1816
 
    :param where: Message explaining to the user the context where
1817
 
        it occurred, eg 'log search filter'.
1818
 
    """
1819
 
    # from https://bugs.launchpad.net/bzr/+bug/251352
1820
 
    try:
1821
 
        re_obj = re.compile(re_string, flags)
1822
 
        re_obj.search("")
1823
 
        return re_obj
1824
 
    except re.error, e:
1825
 
        if where:
1826
 
            where = ' in ' + where
1827
 
        # despite the name 'error' is a type
1828
 
        raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
1829
 
            % (where, re_string, e))
1830
 
 
1831
 
 
1832
 
if sys.platform == "win32":
1833
 
    import msvcrt
1834
 
    def getchar():
1835
 
        return msvcrt.getch()
1836
 
else:
1837
 
    import tty
1838
 
    import termios
1839
 
    def getchar():
1840
 
        fd = sys.stdin.fileno()
1841
 
        settings = termios.tcgetattr(fd)
1842
 
        try:
1843
 
            tty.setraw(fd)
1844
 
            ch = sys.stdin.read(1)
1845
 
        finally:
1846
 
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
1847
 
        return ch
1848
 
 
1849
 
 
1850
 
if sys.platform == 'linux2':
1851
 
    def _local_concurrency():
1852
 
        concurrency = None
1853
 
        prefix = 'processor'
1854
 
        for line in file('/proc/cpuinfo', 'rb'):
1855
 
            if line.startswith(prefix):
1856
 
                concurrency = int(line[line.find(':')+1:]) + 1
1857
 
        return concurrency
1858
 
elif sys.platform == 'darwin':
1859
 
    def _local_concurrency():
1860
 
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
1861
 
                                stdout=subprocess.PIPE).communicate()[0]
1862
 
elif sys.platform[0:7] == 'freebsd':
1863
 
    def _local_concurrency():
1864
 
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
1865
 
                                stdout=subprocess.PIPE).communicate()[0]
1866
 
elif sys.platform == 'sunos5':
1867
 
    def _local_concurrency():
1868
 
        return subprocess.Popen(['psrinfo', '-p',],
1869
 
                                stdout=subprocess.PIPE).communicate()[0]
1870
 
elif sys.platform == "win32":
1871
 
    def _local_concurrency():
1872
 
        # This appears to return the number of cores.
1873
 
        return os.environ.get('NUMBER_OF_PROCESSORS')
1874
 
else:
1875
 
    def _local_concurrency():
1876
 
        # Who knows ?
1877
 
        return None
1878
 
 
1879
 
 
1880
 
_cached_local_concurrency = None
1881
 
 
1882
 
def local_concurrency(use_cache=True):
1883
 
    """Return how many processes can be run concurrently.
1884
 
 
1885
 
    Rely on platform specific implementations and default to 1 (one) if
1886
 
    anything goes wrong.
1887
 
    """
1888
 
    global _cached_local_concurrency
1889
 
    if _cached_local_concurrency is not None and use_cache:
1890
 
        return _cached_local_concurrency
1891
 
 
1892
 
    try:
1893
 
        concurrency = _local_concurrency()
1894
 
    except (OSError, IOError):
1895
 
        concurrency = None
1896
 
    try:
1897
 
        concurrency = int(concurrency)
1898
 
    except (TypeError, ValueError):
1899
 
        concurrency = 1
1900
 
    if use_cache:
1901
 
        _cached_concurrency = concurrency
1902
 
    return concurrency