← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: John Arbash Meinel
  • Date: 2008-09-09 15:09:12 UTC
  • mto: This revision was merged to the branch mainline in revision 3699.
  • Revision ID: john@arbash-meinel.com-20080909150912-wyttm8he1zsls2ck
Use the right timing function on win32

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
608
600
 
609
601
    The file cursor should be already at the start.
610
602
    """
611
 
    s = sha()
 
603
    s = sha.new()
612
604
    BUFSIZE = 128<<10
613
605
    while True:
614
606
        b = f.read(BUFSIZE)
618
610
    return s.hexdigest()
619
611
 
620
612
 
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
613
def sha_file_by_name(fname):
640
614
    """Calculate the SHA1 of a file by reading the full text"""
641
 
    s = sha()
 
615
    s = sha.new()
642
616
    f = os.open(fname, os.O_RDONLY | O_BINARY)
643
617
    try:
644
618
        while True:
650
624
        os.close(f)
651
625
 
652
626
 
653
 
def sha_strings(strings, _factory=sha):
 
627
def sha_strings(strings, _factory=sha.new):
654
628
    """Return the sha-1 of concatenation of strings"""
655
629
    s = _factory()
656
630
    map(s.update, strings)
657
631
    return s.hexdigest()
658
632
 
659
633
 
660
 
def sha_string(f, _factory=sha):
 
634
def sha_string(f, _factory=sha.new):
661
635
    return _factory(f).hexdigest()
662
636
 
663
637
 
664
638
def fingerprint_file(f):
665
639
    b = f.read()
666
640
    return {'size': len(b),
667
 
            'sha1': sha(b).hexdigest()}
 
641
            'sha1': sha.new(b).hexdigest()}
668
642
 
669
643
 
670
644
def compare_files(a, b):
687
661
    return offset.days * 86400 + offset.seconds
688
662
 
689
663
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
690
 
 
 
664
    
691
665
def format_date(t, offset=0, timezone='original', date_fmt=None,
692
666
                show_offset=True):
693
667
    """Return a formatted date string.
697
671
    :param timezone: How to display the time: 'utc', 'original' for the
698
672
         timezone specified by offset, or 'local' for the process's current
699
673
         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):
 
674
    :param show_offset: Whether to append the timezone.
 
675
    :param date_fmt: strftime format.
 
676
    """
729
677
    if timezone == 'utc':
730
678
        tt = time.gmtime(t)
731
679
        offset = 0
744
692
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
745
693
    else:
746
694
        offset_str = ''
747
 
    return (date_fmt, tt, offset_str)
 
695
    # day of week depends on locale, so we do this ourself
 
696
    date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
 
697
    return (time.strftime(date_fmt, tt) +  offset_str)
748
698
 
749
699
 
750
700
def compact_date(when):
751
701
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
752
 
 
 
702
    
753
703
 
754
704
def format_delta(delta):
755
705
    """Get a nice looking string for a time delta.
831
781
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
832
782
def rand_chars(num):
833
783
    """Return a random string of num alphanumeric characters
834
 
 
835
 
    The result only contains lowercase chars because it may be used on
 
784
    
 
785
    The result only contains lowercase chars because it may be used on 
836
786
    case-insensitive filesystems.
837
787
    """
838
788
    s = ''
860
810
            rps.append(f)
861
811
    return rps
862
812
 
863
 
 
864
813
def joinpath(p):
865
814
    for f in p:
866
815
        if (f == '..') or (f is None) or (f == ''):
868
817
    return pathjoin(*p)
869
818
 
870
819
 
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
820
def split_lines(s):
891
821
    """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
822
    lines = s.split('\n')
907
823
    result = [line + '\n' for line in lines[:-1]]
908
824
    if lines[-1]:
927
843
        shutil.copyfile(src, dest)
928
844
 
929
845
 
 
846
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
 
847
# Forgiveness than Permission (EAFP) because:
 
848
# - root can damage a solaris file system by using unlink,
 
849
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
 
850
#   EACCES, OSX: EPERM) when invoked on a directory.
930
851
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.
 
852
    """Delete a file or directory."""
955
853
    if isdir(path): # Takes care of symlinks
956
854
        os.rmdir(path)
957
855
    else:
977
875
            and sys.platform not in ('cygwin', 'win32'))
978
876
 
979
877
 
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
878
def contains_whitespace(s):
995
879
    """True if there are any whitespace characters in s."""
996
880
    # string.whitespace can include '\xa0' in certain locales, because it is
1040
924
 
1041
925
    s = []
1042
926
    head = rp
1043
 
    while True:
1044
 
        if len(head) <= len(base) and head != base:
1045
 
            raise errors.PathNotChild(rp, base)
 
927
    while len(head) >= len(base):
1046
928
        if head == base:
1047
929
            break
1048
 
        head, tail = split(head)
 
930
        head, tail = os.path.split(head)
1049
931
        if tail:
1050
 
            s.append(tail)
 
932
            s.insert(0, tail)
 
933
    else:
 
934
        raise errors.PathNotChild(rp, base)
1051
935
 
1052
936
    if s:
1053
 
        return pathjoin(*reversed(s))
 
937
        return pathjoin(*s)
1054
938
    else:
1055
939
        return ''
1056
940
 
1057
941
 
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
942
def safe_unicode(unicode_or_utf8_string):
1118
943
    """Coerce unicode_or_utf8_string into unicode.
1119
944
 
1120
945
    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.
 
946
    Otherwise it is decoded from utf-8. If a decoding error
 
947
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
 
948
    as a BzrBadParameter exception.
1123
949
    """
1124
950
    if isinstance(unicode_or_utf8_string, unicode):
1125
951
        return unicode_or_utf8_string
1212
1038
 
1213
1039
    On platforms where the system normalizes filenames (Mac OSX),
1214
1040
    you can access a file by any path which will normalize correctly.
1215
 
    On platforms where the system does not normalize filenames
 
1041
    On platforms where the system does not normalize filenames 
1216
1042
    (Windows, Linux), you have to access a file by its exact path.
1217
1043
 
1218
 
    Internally, bzr only supports NFC normalization, since that is
 
1044
    Internally, bzr only supports NFC normalization, since that is 
1219
1045
    the standard for XML documents.
1220
1046
 
1221
1047
    So return the normalized path, and a flag indicating if the file
1292
1118
            del os.environ[env_variable]
1293
1119
    else:
1294
1120
        if isinstance(value, unicode):
1295
 
            value = value.encode(get_user_encoding())
 
1121
            value = value.encode(bzrlib.user_encoding)
1296
1122
        os.environ[env_variable] = value
1297
1123
    return orig_val
1298
1124
 
1301
1127
 
1302
1128
 
1303
1129
def check_legal_path(path):
1304
 
    """Check whether the supplied path is legal.
 
1130
    """Check whether the supplied path is legal.  
1305
1131
    This is only required on Windows, so we don't test on other platforms
1306
1132
    right now.
1307
1133
    """
1341
1167
 
1342
1168
def walkdirs(top, prefix=""):
1343
1169
    """Yield data about all the directories in a tree.
1344
 
 
 
1170
    
1345
1171
    This yields all the data about the contents of a directory at a time.
1346
1172
    After each directory has been yielded, if the caller has mutated the list
1347
1173
    to exclude some directories, they are then not descended into.
1348
 
 
 
1174
    
1349
1175
    The data yielded is of the form:
1350
1176
    ((directory-relpath, directory-path-from-top),
1351
1177
    [(relpath, basename, kind, lstat, path-from-top), ...]),
1352
1178
     - directory-relpath is the relative path of the directory being returned
1353
1179
       with respect to top. prefix is prepended to this.
1354
 
     - directory-path-from-root is the path including top for this directory.
 
1180
     - directory-path-from-root is the path including top for this directory. 
1355
1181
       It is suitable for use with os functions.
1356
1182
     - relpath is the relative path within the subtree being walked.
1357
1183
     - basename is the basename of the path
1359
1185
       present within the tree - but it may be recorded as versioned. See
1360
1186
       versioned_kind.
1361
1187
     - lstat is the stat data *if* the file was statted.
1362
 
     - planned, not implemented:
 
1188
     - planned, not implemented: 
1363
1189
       path_from_tree_root is the path from the root of the tree.
1364
1190
 
1365
 
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This
 
1191
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This 
1366
1192
        allows one to walk a subtree but get paths that are relative to a tree
1367
1193
        rooted higher up.
1368
1194
    :return: an iterator over the dirs.
1369
1195
    """
1370
1196
    #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
 
1197
    # summary in this, and the path from the root, may not agree 
1372
1198
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
1373
1199
    # potentially confusing output. We should make this more robust - but
1374
1200
    # not at a speed cost. RBC 20060731
1375
1201
    _lstat = os.lstat
1376
1202
    _directory = _directory_kind
1377
1203
    _listdir = os.listdir
1378
 
    _kind_from_mode = file_kind_from_stat_mode
 
1204
    _kind_from_mode = _formats.get
1379
1205
    pending = [(safe_unicode(prefix), "", _directory, None, safe_unicode(top))]
1380
1206
    while pending:
1381
1207
        # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1397
1223
            for name in names:
1398
1224
                abspath = top_slash + name
1399
1225
                statvalue = _lstat(abspath)
1400
 
                kind = _kind_from_mode(statvalue.st_mode)
 
1226
                kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
1401
1227
                append((relprefix + name, name, kind, statvalue, abspath))
1402
1228
        yield (relroot, top), dirblock
1403
1229
 
1405
1231
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
1406
1232
 
1407
1233
 
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
 
 
 
1234
_real_walkdirs_utf8 = None
1435
1235
 
1436
1236
def _walkdirs_utf8(top, prefix=""):
1437
1237
    """Yield data about all the directories in a tree.
1447
1247
        path-from-top might be unicode or utf8, but it is the correct path to
1448
1248
        pass to os functions to affect the file in question. (such as os.lstat)
1449
1249
    """
1450
 
    global _selected_dir_reader
1451
 
    if _selected_dir_reader is None:
 
1250
    global _real_walkdirs_utf8
 
1251
    if _real_walkdirs_utf8 is None:
1452
1252
        fs_encoding = _fs_enc.upper()
1453
 
        if sys.platform == "win32" and win32utils.winver == 'Windows NT':
 
1253
        if win32utils.winver == 'Windows NT':
1454
1254
            # Win98 doesn't have unicode apis like FindFirstFileW
1455
1255
            # TODO: We possibly could support Win98 by falling back to the
1456
1256
            #       original FindFirstFile, and using TCHAR instead of WCHAR,
1457
1257
            #       but that gets a bit tricky, and requires custom compiling
1458
1258
            #       for win98 anyway.
1459
1259
            try:
1460
 
                from bzrlib._walkdirs_win32 import Win32ReadDir
1461
 
                _selected_dir_reader = Win32ReadDir()
 
1260
                from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
1462
1261
            except ImportError:
1463
 
                pass
1464
 
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
 
1262
                _real_walkdirs_utf8 = _walkdirs_unicode_to_utf8
 
1263
            else:
 
1264
                _real_walkdirs_utf8 = _walkdirs_utf8_win32_find_file
 
1265
        elif fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1465
1266
            # 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()
 
1267
            _real_walkdirs_utf8 = _walkdirs_unicode_to_utf8
 
1268
        else:
 
1269
            _real_walkdirs_utf8 = _walkdirs_fs_utf8
 
1270
    return _real_walkdirs_utf8(top, prefix=prefix)
 
1271
 
 
1272
 
 
1273
def _walkdirs_fs_utf8(top, prefix=""):
 
1274
    """See _walkdirs_utf8.
 
1275
 
 
1276
    This sub-function is called when we know the filesystem is already in utf8
 
1277
    encoding. So we don't need to transcode filenames.
 
1278
    """
 
1279
    _lstat = os.lstat
 
1280
    _directory = _directory_kind
 
1281
    # Use C accelerated directory listing.
 
1282
    _listdir = _read_dir
 
1283
    _kind_from_mode = _formats.get
1475
1284
 
1476
1285
    # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1477
1286
    # 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
 
1287
    pending = [(safe_utf8(prefix), None, None, None, safe_utf8(top))]
1481
1288
    while pending:
1482
 
        relroot, _, _, _, top = pending[-1].pop()
1483
 
        if not pending[-1]:
1484
 
            pending.pop()
1485
 
        dirblock = sorted(read_dir(relroot, top))
 
1289
        relroot, _, _, _, top = pending.pop()
 
1290
        if relroot:
 
1291
            relprefix = relroot + '/'
 
1292
        else:
 
1293
            relprefix = ''
 
1294
        top_slash = top + '/'
 
1295
 
 
1296
        dirblock = []
 
1297
        append = dirblock.append
 
1298
        # read_dir supplies in should-stat order.
 
1299
        for _, name in sorted(_listdir(top)):
 
1300
            abspath = top_slash + name
 
1301
            statvalue = _lstat(abspath)
 
1302
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
 
1303
            append((relprefix + name, name, kind, statvalue, abspath))
 
1304
        dirblock.sort()
1486
1305
        yield (relroot, top), dirblock
 
1306
 
1487
1307
        # 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 + '/'
 
1308
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
 
1309
 
 
1310
 
 
1311
def _walkdirs_unicode_to_utf8(top, prefix=""):
 
1312
    """See _walkdirs_utf8
 
1313
 
 
1314
    Because Win32 has a Unicode api, all of the 'path-from-top' entries will be
 
1315
    Unicode paths.
 
1316
    This is currently the fallback code path when the filesystem encoding is
 
1317
    not UTF-8. It may be better to implement an alternative so that we can
 
1318
    safely handle paths that are not properly decodable in the current
 
1319
    encoding.
 
1320
    """
 
1321
    _utf8_encode = codecs.getencoder('utf8')
 
1322
    _lstat = os.lstat
 
1323
    _directory = _directory_kind
 
1324
    _listdir = os.listdir
 
1325
    _kind_from_mode = _formats.get
 
1326
 
 
1327
    pending = [(safe_utf8(prefix), None, None, None, safe_unicode(top))]
 
1328
    while pending:
 
1329
        relroot, _, _, _, top = pending.pop()
 
1330
        if relroot:
 
1331
            relprefix = relroot + '/'
1525
1332
        else:
1526
1333
            relprefix = ''
1527
1334
        top_slash = top + u'/'
1529
1336
        dirblock = []
1530
1337
        append = dirblock.append
1531
1338
        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)
 
1339
            name_utf8 = _utf8_encode(name)[0]
1537
1340
            abspath = top_slash + name
1538
1341
            statvalue = _lstat(abspath)
1539
 
            kind = _kind_from_mode(statvalue.st_mode)
 
1342
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
1540
1343
            append((relprefix + name_utf8, name_utf8, kind, statvalue, abspath))
1541
 
        return dirblock
 
1344
        yield (relroot, top), dirblock
 
1345
 
 
1346
        # push the user specified dirs from dirblock
 
1347
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
1542
1348
 
1543
1349
 
1544
1350
def copy_tree(from_path, to_path, handlers={}):
1545
1351
    """Copy all of the entries in from_path into to_path.
1546
1352
 
1547
 
    :param from_path: The base directory to copy.
 
1353
    :param from_path: The base directory to copy. 
1548
1354
    :param to_path: The target directory. If it does not exist, it will
1549
1355
        be created.
1550
1356
    :param handlers: A dictionary of functions, which takes a source and
1619
1425
        return _cached_user_encoding
1620
1426
 
1621
1427
    if sys.platform == 'darwin':
1622
 
        # python locale.getpreferredencoding() always return
1623
 
        # 'mac-roman' on darwin. That's a lie.
 
1428
        # work around egregious python 2.4 bug
1624
1429
        sys.platform = 'posix'
1625
1430
        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
1431
            import locale
1636
1432
        finally:
1637
1433
            sys.platform = 'darwin'
1700
1496
    """
1701
1497
    b = ''
1702
1498
    while len(b) < bytes:
1703
 
        new = until_no_eintr(socket.recv, bytes - len(b))
 
1499
        new = socket.recv(bytes - len(b))
1704
1500
        if new == '':
1705
1501
            break # eof
1706
1502
        b += new
1707
1503
    return b
1708
1504
 
1709
1505
 
1710
 
def send_all(socket, bytes, report_activity=None):
 
1506
def send_all(socket, bytes):
1711
1507
    """Send all bytes on a socket.
1712
1508
 
1713
1509
    Regular socket.sendall() can give socket error 10053 on Windows.  This
1714
1510
    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
1511
    """
1719
1512
    chunk_size = 2**16
1720
1513
    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)
 
1514
        socket.sendall(bytes[pos:pos+chunk_size])
1725
1515
 
1726
1516
 
1727
1517
def dereference_path(path):
1772
1562
    return open(filename, 'rU').read()
1773
1563
 
1774
1564
 
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
 
1565
try:
 
1566
    from bzrlib._readdir_pyx import read_dir as _read_dir
 
1567
except ImportError:
 
1568
    from bzrlib._readdir_py import read_dir as _read_dir