150
149
return _mapper(_lstat(f).st_mode)
151
150
except OSError, e:
152
if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
151
if getattr(e, 'errno', None) == errno.ENOENT:
153
152
raise errors.NoSuchFile(f)
238
# This may throw an exception, in which case success will
240
rename_func(old, new)
242
except (IOError, OSError), e:
243
# source and target may be aliases of each other (e.g. on a
244
# case-insensitive filesystem), so we may have accidentally renamed
245
# source by when we tried to rename target
246
if not (file_existed and e.errno in (None, errno.ENOENT)):
236
# This may throw an exception, in which case success will
238
rename_func(old, new)
250
242
# If the file used to exist, rename it back into place
362
354
def _mac_getcwd():
363
return unicodedata.normalize('NFC', os.getcwdu())
355
return unicodedata.normalize('NFKC', os.getcwdu())
366
358
# Default is to just use the python builtins, but these can be rebound on
468
460
return pathjoin(F(p), e)
464
"""Copy a file to a backup.
466
Backups are named in GNU-style, with a ~ suffix.
468
If the file is already a backup, it's not copied.
474
if has_symlinks() and os.path.islink(fn):
475
target = os.readlink(fn)
476
os.symlink(target, bfn)
484
outf = file(bfn, 'wb')
472
492
"""True if f is an accessible directory."""
533
def pumpfile(from_file, to_file, read_length=-1, buff_size=32768):
553
def pumpfile(fromfile, tofile):
534
554
"""Copy contents of one file to another.
536
The read_length can either be -1 to read to end-of-file (EOF) or
537
it can specify the maximum number of bytes to read.
539
The buff_size represents the maximum size for each read operation
540
performed on from_file.
542
556
:return: The number of bytes copied.
546
# read specified number of bytes
548
while read_length > 0:
549
num_bytes_to_read = min(read_length, buff_size)
551
block = from_file.read(num_bytes_to_read)
557
actual_bytes_read = len(block)
558
read_length -= actual_bytes_read
559
length += actual_bytes_read
563
block = from_file.read(buff_size)
561
b = fromfile.read(BUFSIZE)
572
def pump_string_file(bytes, file_handle, segment_size=None):
573
"""Write bytes to file_handle in many smaller writes.
575
:param bytes: The string to write.
576
:param file_handle: The file to write to.
578
# Write data in chunks rather than all at once, because very large
579
# writes fail on some platforms (e.g. Windows with SMB mounted
582
segment_size = 5242880 # 5MB
583
segments = range(len(bytes) / segment_size + 1)
584
write = file_handle.write
585
for segment_index in segments:
586
segment = buffer(bytes, segment_index * segment_size, segment_size)
590
569
def file_iterator(input_file, readsize=32768):
592
571
b = input_file.read(readsize)
660
637
offset = datetime.fromtimestamp(t) - datetime.utcfromtimestamp(t)
661
638
return offset.days * 86400 + offset.seconds
663
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
665
641
def format_date(t, offset=0, timezone='original', date_fmt=None,
666
642
show_offset=True):
685
661
tt = time.localtime(t)
686
662
offset = local_time_offset(t)
688
raise errors.UnsupportedTimezoneFormat(timezone)
664
raise errors.BzrError("unsupported timezone format %r" % timezone,
665
['options are "utc", "original", "local"'])
689
666
if date_fmt is None:
690
667
date_fmt = "%a %Y-%m-%d %H:%M:%S"
692
669
offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
695
# day of week depends on locale, so we do this ourself
696
date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
697
672
return (time.strftime(date_fmt, tt) + offset_str)
797
772
def splitpath(p):
798
773
"""Turn string into list of parts."""
774
assert isinstance(p, basestring)
799
776
# split on either delimiter because people might use either on
801
778
ps = re.split(r'[\\/]', p)
791
assert isinstance(p, (list, tuple))
815
793
if (f == '..') or (f is None) or (f == ''):
816
794
raise errors.BzrError("sorry, %r not allowed in path" % f)
867
if getattr(os, 'link', None) is not None:
873
def host_os_dereferences_symlinks():
874
return (has_symlinks()
875
and sys.platform not in ('cygwin', 'win32'))
878
844
def contains_whitespace(s):
879
845
"""True if there are any whitespace characters in s."""
880
846
# string.whitespace can include '\xa0' in certain locales, because it is
915
881
avoids that problem.
918
if len(base) < MIN_ABS_PATHLENGTH:
919
# must have space for e.g. a drive letter
920
raise ValueError('%r is too short to calculate a relative path'
884
assert len(base) >= MIN_ABS_PATHLENGTH, ('Length of base must be equal or'
885
' exceed the platform minimum length (which is %d)' %
923
888
rp = abspath(path)
1041
1006
On platforms where the system does not normalize filenames
1042
1007
(Windows, Linux), you have to access a file by its exact path.
1044
Internally, bzr only supports NFC normalization, since that is
1009
Internally, bzr only supports NFC/NFKC normalization, since that is
1045
1010
the standard for XML documents.
1047
1012
So return the normalized path, and a flag indicating if the file
1048
1013
can be accessed by that path.
1051
return unicodedata.normalize('NFC', unicode(path)), True
1016
return unicodedata.normalize('NFKC', unicode(path)), True
1054
1019
def _inaccessible_normalized_filename(path):
1055
1020
__doc__ = _accessible_normalized_filename.__doc__
1057
normalized = unicodedata.normalize('NFC', unicode(path))
1022
normalized = unicodedata.normalize('NFKC', unicode(path))
1058
1023
return normalized, normalized == path
1137
1102
raise errors.IllegalPath(path)
1140
_WIN32_ERROR_DIRECTORY = 267 # Similar to errno.ENOTDIR
1142
def _is_error_enotdir(e):
1143
"""Check if this exception represents ENOTDIR.
1145
Unfortunately, python is very inconsistent about the exception
1146
here. The cases are:
1147
1) Linux, Mac OSX all versions seem to set errno == ENOTDIR
1148
2) Windows, Python2.4, uses errno == ERROR_DIRECTORY (267)
1149
which is the windows error code.
1150
3) Windows, Python2.5 uses errno == EINVAL and
1151
winerror == ERROR_DIRECTORY
1153
:param e: An Exception object (expected to be OSError with an errno
1154
attribute, but we should be able to cope with anything)
1155
:return: True if this represents an ENOTDIR error. False otherwise.
1157
en = getattr(e, 'errno', None)
1158
if (en == errno.ENOTDIR
1159
or (sys.platform == 'win32'
1160
and (en == _WIN32_ERROR_DIRECTORY
1161
or (en == errno.EINVAL
1162
and getattr(e, 'winerror', None) == _WIN32_ERROR_DIRECTORY)
1168
1105
def walkdirs(top, prefix=""):
1169
1106
"""Yield data about all the directories in a tree.
1216
1153
append = dirblock.append
1218
names = sorted(_listdir(top))
1220
if not _is_error_enotdir(e):
1224
abspath = top_slash + name
1225
statvalue = _lstat(abspath)
1226
kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
1227
append((relprefix + name, name, kind, statvalue, abspath))
1154
for name in sorted(_listdir(top)):
1155
abspath = top_slash + name
1156
statvalue = _lstat(abspath)
1157
kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
1158
append((relprefix + name, name, kind, statvalue, abspath))
1228
1159
yield (relroot, top), dirblock
1230
1161
# push the user specified dirs from dirblock
1231
1162
pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
1234
_real_walkdirs_utf8 = None
1236
1165
def _walkdirs_utf8(top, prefix=""):
1237
1166
"""Yield data about all the directories in a tree.
1247
1176
path-from-top might be unicode or utf8, but it is the correct path to
1248
1177
pass to os functions to affect the file in question. (such as os.lstat)
1250
global _real_walkdirs_utf8
1251
if _real_walkdirs_utf8 is None:
1252
fs_encoding = _fs_enc.upper()
1253
if win32utils.winver == 'Windows NT':
1254
# Win98 doesn't have unicode apis like FindFirstFileW
1255
# TODO: We possibly could support Win98 by falling back to the
1256
# original FindFirstFile, and using TCHAR instead of WCHAR,
1257
# but that gets a bit tricky, and requires custom compiling
1260
from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
1262
_real_walkdirs_utf8 = _walkdirs_unicode_to_utf8
1264
_real_walkdirs_utf8 = _walkdirs_utf8_win32_find_file
1265
elif fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1266
# ANSI_X3.4-1968 is a form of ASCII
1267
_real_walkdirs_utf8 = _walkdirs_unicode_to_utf8
1269
_real_walkdirs_utf8 = _walkdirs_fs_utf8
1270
return _real_walkdirs_utf8(top, prefix=prefix)
1179
fs_encoding = _fs_enc.upper()
1180
if (sys.platform == 'win32' or
1181
fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968')): # ascii
1182
return _walkdirs_unicode_to_utf8(top, prefix=prefix)
1184
return _walkdirs_fs_utf8(top, prefix=prefix)
1273
1187
def _walkdirs_fs_utf8(top, prefix=""):
1279
1193
_lstat = os.lstat
1280
1194
_directory = _directory_kind
1281
# Use C accelerated directory listing.
1282
_listdir = _read_dir
1195
_listdir = os.listdir
1283
1196
_kind_from_mode = _formats.get
1285
1198
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1297
1210
append = dirblock.append
1298
# read_dir supplies in should-stat order.
1299
for _, name in sorted(_listdir(top)):
1211
for name in sorted(_listdir(top)):
1300
1212
abspath = top_slash + name
1301
1213
statvalue = _lstat(abspath)
1302
1214
kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
1303
1215
append((relprefix + name, name, kind, statvalue, abspath))
1305
1216
yield (relroot, top), dirblock
1307
1218
# push the user specified dirs from dirblock
1448
1359
# Windows returns 'cp0' to indicate there is no code page. So we'll just
1449
1360
# treat that as ASCII, and not support printing unicode characters to the
1452
# For python scripts run under vim, we get '', so also treat that as ASCII
1453
if user_encoding in (None, 'cp0', ''):
1362
if user_encoding in (None, 'cp0'):
1454
1363
user_encoding = 'ascii'
1456
1365
# check encoding
1470
1379
return user_encoding
1473
def get_host_name():
1474
"""Return the current unicode host name.
1476
This is meant to be used in place of socket.gethostname() because that
1477
behaves inconsistently on different platforms.
1479
if sys.platform == "win32":
1481
return win32utils.get_host_name()
1484
return socket.gethostname().decode(get_user_encoding())
1487
1382
def recv_all(socket, bytes):
1488
1383
"""Receive an exact number of bytes.
1506
def send_all(socket, bytes):
1507
"""Send all bytes on a socket.
1509
Regular socket.sendall() can give socket error 10053 on Windows. This
1510
implementation sends no more than 64k at a time, which avoids this problem.
1513
for pos in xrange(0, len(bytes), chunk_size):
1514
socket.sendall(bytes[pos:pos+chunk_size])
1517
1400
def dereference_path(path):
1518
1401
"""Determine the real path to a file.
1531
1414
def supports_mapi():
1532
1415
"""Return True if we can use MAPI to launch a mail client."""
1533
1416
return sys.platform == "win32"
1536
def resource_string(package, resource_name):
1537
"""Load a resource from a package and return it as a string.
1539
Note: Only packages that start with bzrlib are currently supported.
1541
This is designed to be a lightweight implementation of resource
1542
loading in a way which is API compatible with the same API from
1544
http://peak.telecommunity.com/DevCenter/PkgResources#basic-resource-access.
1545
If and when pkg_resources becomes a standard library, this routine
1548
# Check package name is within bzrlib
1549
if package == "bzrlib":
1550
resource_relpath = resource_name
1551
elif package.startswith("bzrlib."):
1552
package = package[len("bzrlib."):].replace('.', os.sep)
1553
resource_relpath = pathjoin(package, resource_name)
1555
raise errors.BzrError('resource package %s not in bzrlib' % package)
1557
# Map the resource to a file and read its contents
1558
base = dirname(bzrlib.__file__)
1559
if getattr(sys, 'frozen', None): # bzr.exe
1560
base = abspath(pathjoin(base, '..', '..'))
1561
filename = pathjoin(base, resource_relpath)
1562
return open(filename, 'rU').read()
1566
from bzrlib._readdir_pyx import read_dir as _read_dir
1568
from bzrlib._readdir_py import read_dir as _read_dir
added
removed
bzrlib/osutils.py
