util.py
692 lines
| 20.8 KiB
| text/x-python
|
PythonLexer
/ mercurial / util.py
|
r1082 | """ | ||
util.py - Mercurial utility functions and platform specfic implementations | ||||
Copyright 2005 K. Thananchayan <thananck@yahoo.com> | ||||
This software may be used and distributed according to the terms | ||||
of the GNU General Public License, incorporated herein by reference. | ||||
This contains helper routines that are independent of the SCM core and hide | ||||
platform-specific details from the core. | ||||
""" | ||||
|
r419 | |||
|
r704 | import os, errno | ||
|
r1400 | from i18n import gettext as _ | ||
|
r724 | from demandload import * | ||
|
r1609 | demandload(globals(), "cStringIO errno popen2 re shutil sys tempfile") | ||
demandload(globals(), "threading time") | ||||
|
r1258 | |||
|
r1293 | def pipefilter(s, cmd): | ||
'''filter string S through command CMD, returning its output''' | ||||
|
r1258 | (pout, pin) = popen2.popen2(cmd, -1, 'b') | ||
def writer(): | ||||
pin.write(s) | ||||
pin.close() | ||||
# we should use select instead on UNIX, but this will work on most | ||||
# systems, including Windows | ||||
w = threading.Thread(target=writer) | ||||
w.start() | ||||
f = pout.read() | ||||
pout.close() | ||||
w.join() | ||||
return f | ||||
|
r419 | |||
|
r1293 | def tempfilter(s, cmd): | ||
'''filter string S through a pair of temporary files with CMD. | ||||
CMD is used as a template to create the real command to be run, | ||||
with the strings INFILE and OUTFILE replaced by the real names of | ||||
the temporary files generated.''' | ||||
inname, outname = None, None | ||||
try: | ||||
infd, inname = tempfile.mkstemp(prefix='hgfin') | ||||
fp = os.fdopen(infd, 'wb') | ||||
fp.write(s) | ||||
fp.close() | ||||
outfd, outname = tempfile.mkstemp(prefix='hgfout') | ||||
os.close(outfd) | ||||
cmd = cmd.replace('INFILE', inname) | ||||
cmd = cmd.replace('OUTFILE', outname) | ||||
code = os.system(cmd) | ||||
|
r1402 | if code: raise Abort(_("command '%s' failed: %s") % | ||
|
r1293 | (cmd, explain_exit(code))) | ||
return open(outname, 'rb').read() | ||||
finally: | ||||
try: | ||||
if inname: os.unlink(inname) | ||||
except: pass | ||||
try: | ||||
if outname: os.unlink(outname) | ||||
except: pass | ||||
filtertable = { | ||||
'tempfile:': tempfilter, | ||||
'pipe:': pipefilter, | ||||
} | ||||
def filter(s, cmd): | ||||
"filter a string through a command that transforms its input to its output" | ||||
for name, fn in filtertable.iteritems(): | ||||
if cmd.startswith(name): | ||||
return fn(s, cmd[len(name):].lstrip()) | ||||
return pipefilter(s, cmd) | ||||
|
r1285 | def patch(strip, patchname, ui): | ||
"""apply the patch <patchname> to the working directory. | ||||
a list of patched files is returned""" | ||||
fp = os.popen('patch -p%d < "%s"' % (strip, patchname)) | ||||
files = {} | ||||
for line in fp: | ||||
line = line.rstrip() | ||||
ui.status("%s\n" % line) | ||||
if line.startswith('patching file '): | ||||
pf = parse_patch_output(line) | ||||
files.setdefault(pf, 1) | ||||
code = fp.close() | ||||
if code: | ||||
|
r1402 | raise Abort(_("patch command failed: %s") % explain_exit(code)[0]) | ||
|
r1285 | return files.keys() | ||
|
r1308 | |||
|
r1015 | def binary(s): | ||
|
r1082 | """return true if a string is binary data using diff's heuristic""" | ||
|
r1015 | if s and '\0' in s[:4096]: | ||
return True | ||||
return False | ||||
|
r556 | def unique(g): | ||
|
r1082 | """return the uniq elements of iterable g""" | ||
|
r556 | seen = {} | ||
for f in g: | ||||
if f not in seen: | ||||
seen[f] = 1 | ||||
yield f | ||||
|
r870 | class Abort(Exception): | ||
"""Raised if a command needs to print an error and exit.""" | ||||
|
r508 | |||
|
r724 | def always(fn): return True | ||
def never(fn): return False | ||||
|
r1563 | def patkind(name, dflt_pat='glob'): | ||
"""Split a string into an optional pattern kind prefix and the | ||||
actual pattern.""" | ||||
for prefix in 're', 'glob', 'path', 'relglob', 'relpath', 'relre': | ||||
if name.startswith(prefix + ':'): return name.split(':', 1) | ||||
return dflt_pat, name | ||||
|
r1062 | def globre(pat, head='^', tail='$'): | ||
|
r724 | "convert a glob pattern into a regexp" | ||
i, n = 0, len(pat) | ||||
res = '' | ||||
group = False | ||||
def peek(): return i < n and pat[i] | ||||
while i < n: | ||||
c = pat[i] | ||||
i = i+1 | ||||
if c == '*': | ||||
if peek() == '*': | ||||
i += 1 | ||||
res += '.*' | ||||
else: | ||||
res += '[^/]*' | ||||
elif c == '?': | ||||
res += '.' | ||||
elif c == '[': | ||||
j = i | ||||
if j < n and pat[j] in '!]': | ||||
j += 1 | ||||
while j < n and pat[j] != ']': | ||||
j += 1 | ||||
if j >= n: | ||||
res += '\\[' | ||||
else: | ||||
stuff = pat[i:j].replace('\\','\\\\') | ||||
i = j + 1 | ||||
if stuff[0] == '!': | ||||
stuff = '^' + stuff[1:] | ||||
elif stuff[0] == '^': | ||||
stuff = '\\' + stuff | ||||
res = '%s[%s]' % (res, stuff) | ||||
elif c == '{': | ||||
group = True | ||||
res += '(?:' | ||||
elif c == '}' and group: | ||||
res += ')' | ||||
group = False | ||||
elif c == ',' and group: | ||||
res += '|' | ||||
else: | ||||
res += re.escape(c) | ||||
return head + res + tail | ||||
|
r812 | _globchars = {'[': 1, '{': 1, '*': 1, '?': 1} | ||
|
r884 | def pathto(n1, n2): | ||
|
r886 | '''return the relative path from one place to another. | ||
this returns a path in the form used by the local filesystem, not hg.''' | ||||
if not n1: return localpath(n2) | ||||
a, b = n1.split('/'), n2.split('/') | ||||
|
r1541 | a.reverse() | ||
b.reverse() | ||||
|
r884 | while a and b and a[-1] == b[-1]: | ||
|
r1541 | a.pop() | ||
b.pop() | ||||
|
r884 | b.reverse() | ||
return os.sep.join((['..'] * len(a)) + b) | ||||
|
r1081 | def canonpath(root, cwd, myname): | ||
|
r1082 | """return the canonical path of myname, given cwd and root""" | ||
|
r1566 | if root == os.sep: | ||
rootsep = os.sep | ||||
else: | ||||
rootsep = root + os.sep | ||||
|
r870 | name = myname | ||
if not name.startswith(os.sep): | ||||
|
r1081 | name = os.path.join(root, cwd, name) | ||
|
r870 | name = os.path.normpath(name) | ||
if name.startswith(rootsep): | ||||
|
r886 | return pconvert(name[len(rootsep):]) | ||
|
r1081 | elif name == root: | ||
|
r870 | return '' | ||
else: | ||||
|
r1081 | raise Abort('%s not under root' % myname) | ||
|
r897 | |||
|
r1610 | def matcher(canonroot, cwd='', names=['.'], inc=[], exc=[], head='', src=None): | ||
return _matcher(canonroot, cwd, names, inc, exc, head, 'glob', src) | ||||
|
r1413 | |||
|
r1610 | def cmdmatcher(canonroot, cwd='', names=['.'], inc=[], exc=[], head='', src=None): | ||
|
r1413 | if os.name == 'nt': | ||
dflt_pat = 'glob' | ||||
else: | ||||
dflt_pat = 'relpath' | ||||
|
r1610 | return _matcher(canonroot, cwd, names, inc, exc, head, dflt_pat, src) | ||
|
r1413 | |||
|
r1610 | def _matcher(canonroot, cwd, names, inc, exc, head, dflt_pat, src): | ||
|
r1082 | """build a function to match a set of file patterns | ||
arguments: | ||||
canonroot - the canonical root of the tree you're matching against | ||||
cwd - the current working directory, if relevant | ||||
names - patterns to find | ||||
inc - patterns to include | ||||
exc - patterns to exclude | ||||
head - a regex to prepend to patterns to control whether a match is rooted | ||||
a pattern is one of: | ||||
|
r1270 | 'glob:<rooted glob>' | ||
're:<rooted regexp>' | ||||
'path:<rooted path>' | ||||
'relglob:<relative glob>' | ||||
|
r1082 | 'relpath:<relative path>' | ||
|
r1270 | 'relre:<relative regexp>' | ||
'<rooted path or regexp>' | ||||
|
r1082 | |||
returns: | ||||
a 3-tuple containing | ||||
- list of explicit non-pattern names passed in | ||||
- a bool match(filename) function | ||||
- a bool indicating if any patterns were passed in | ||||
todo: | ||||
make head regex a rooted bool | ||||
""" | ||||
|
r1413 | def contains_glob(name): | ||
|
r812 | for c in name: | ||
|
r1413 | if c in _globchars: return True | ||
return False | ||||
|
r820 | |||
|
r888 | def regex(kind, name, tail): | ||
|
r742 | '''convert a pattern into a regular expression''' | ||
|
r820 | if kind == 're': | ||
return name | ||||
elif kind == 'path': | ||||
|
r888 | return '^' + re.escape(name) + '(?:/|$)' | ||
|
r1270 | elif kind == 'relglob': | ||
return head + globre(name, '(?:|.*/)', tail) | ||||
|
r888 | elif kind == 'relpath': | ||
return head + re.escape(name) + tail | ||||
|
r1270 | elif kind == 'relre': | ||
if name.startswith('^'): | ||||
return name | ||||
return '.*' + name | ||||
|
r742 | return head + globre(name, '', tail) | ||
def matchfn(pats, tail): | ||||
"""build a matching function from a set of patterns""" | ||||
|
r1454 | if not pats: | ||
return | ||||
|
r1446 | matches = [] | ||
for k, p in pats: | ||||
try: | ||||
pat = '(?:%s)' % regex(k, p, tail) | ||||
matches.append(re.compile(pat).match) | ||||
|
r1541 | except re.error: | ||
|
r1611 | if src: raise Abort("%s: invalid pattern (%s): %s" % (src, k, p)) | ||
else: raise Abort("invalid pattern (%s): %s" % (k, p)) | ||||
|
r1446 | |||
def buildfn(text): | ||||
for m in matches: | ||||
r = m(text) | ||||
if r: | ||||
return r | ||||
return buildfn | ||||
|
r742 | |||
|
r820 | def globprefix(pat): | ||
'''return the non-glob prefix of a path, e.g. foo/* -> foo''' | ||||
root = [] | ||||
for p in pat.split(os.sep): | ||||
|
r1413 | if contains_glob(p): break | ||
|
r820 | root.append(p) | ||
|
r886 | return '/'.join(root) | ||
|
r820 | |||
|
r870 | pats = [] | ||
files = [] | ||||
roots = [] | ||||
|
r1413 | for kind, name in [patkind(p, dflt_pat) for p in names]: | ||
|
r870 | if kind in ('glob', 'relpath'): | ||
|
r1081 | name = canonpath(canonroot, cwd, name) | ||
|
r870 | if name == '': | ||
kind, name = 'glob', '**' | ||||
|
r888 | if kind in ('glob', 'path', 're'): | ||
pats.append((kind, name)) | ||||
|
r870 | if kind == 'glob': | ||
root = globprefix(name) | ||||
if root: roots.append(root) | ||||
elif kind == 'relpath': | ||||
|
r888 | files.append((kind, name)) | ||
|
r870 | roots.append(name) | ||
|
r897 | |||
|
r820 | patmatch = matchfn(pats, '$') or always | ||
filematch = matchfn(files, '(?:/|$)') or always | ||||
|
r897 | incmatch = always | ||
if inc: | ||||
incmatch = matchfn(map(patkind, inc), '(?:/|$)') | ||||
excmatch = lambda fn: False | ||||
if exc: | ||||
excmatch = matchfn(map(patkind, exc), '(?:/|$)') | ||||
|
r742 | |||
|
r1031 | return (roots, | ||
lambda fn: (incmatch(fn) and not excmatch(fn) and | ||||
(fn.endswith('/') or | ||||
(not pats and not files) or | ||||
(pats and patmatch(fn)) or | ||||
(files and filematch(fn)))), | ||||
(inc or exc or (pats and pats != [('glob', '**')])) and True) | ||||
|
r742 | |||
|
r521 | def system(cmd, errprefix=None): | ||
|
r508 | """execute a shell command that must succeed""" | ||
rc = os.system(cmd) | ||||
if rc: | ||||
|
r521 | errmsg = "%s %s" % (os.path.basename(cmd.split(None, 1)[0]), | ||
explain_exit(rc)[0]) | ||||
if errprefix: | ||||
errmsg = "%s: %s" % (errprefix, errmsg) | ||||
|
r870 | raise Abort(errmsg) | ||
|
r508 | |||
|
r421 | def rename(src, dst): | ||
|
r1082 | """forcibly rename a file""" | ||
|
r421 | try: | ||
os.rename(src, dst) | ||||
except: | ||||
os.unlink(dst) | ||||
os.rename(src, dst) | ||||
|
r1415 | def unlink(f): | ||
"""unlink and remove the directory if it is empty""" | ||||
os.unlink(f) | ||||
# try removing directories that might now be empty | ||||
try: os.removedirs(os.path.dirname(f)) | ||||
except: pass | ||||
|
r1241 | def copyfiles(src, dst, hardlink=None): | ||
"""Copy a directory tree using hardlinks if possible""" | ||||
if hardlink is None: | ||||
hardlink = (os.stat(src).st_dev == | ||||
os.stat(os.path.dirname(dst)).st_dev) | ||||
|
r698 | |||
|
r1207 | if os.path.isdir(src): | ||
os.mkdir(dst) | ||||
for name in os.listdir(src): | ||||
srcname = os.path.join(src, name) | ||||
dstname = os.path.join(dst, name) | ||||
|
r1241 | copyfiles(srcname, dstname, hardlink) | ||
|
r1207 | else: | ||
|
r1241 | if hardlink: | ||
try: | ||||
os_link(src, dst) | ||||
except: | ||||
hardlink = False | ||||
|
r1591 | shutil.copy(src, dst) | ||
|
r1241 | else: | ||
|
r1591 | shutil.copy(src, dst) | ||
|
r698 | |||
|
r1090 | def opener(base): | ||
""" | ||||
return a function that opens files relative to base | ||||
this function is used to hide the details of COW semantics and | ||||
remote file access from higher level code. | ||||
""" | ||||
p = base | ||||
|
r1528 | |||
def mktempcopy(name): | ||||
d, fn = os.path.split(name) | ||||
fd, temp = tempfile.mkstemp(prefix=fn, dir=d) | ||||
fp = os.fdopen(fd, "wb") | ||||
try: | ||||
fp.write(file(name, "rb").read()) | ||||
except: | ||||
try: os.unlink(temp) | ||||
except: pass | ||||
raise | ||||
fp.close() | ||||
st = os.lstat(name) | ||||
os.chmod(temp, st.st_mode) | ||||
return temp | ||||
class atomicfile(file): | ||||
"""the file will only be copied on close""" | ||||
def __init__(self, name, mode, atomic=False): | ||||
self.__name = name | ||||
self.temp = mktempcopy(name) | ||||
file.__init__(self, self.temp, mode) | ||||
def close(self): | ||||
if not self.closed: | ||||
|
r1546 | file.close(self) | ||
|
r1528 | rename(self.temp, self.__name) | ||
def __del__(self): | ||||
self.close() | ||||
def o(path, mode="r", text=False, atomic=False): | ||||
|
r1090 | f = os.path.join(p, path) | ||
|
r1329 | if not text: | ||
mode += "b" # for that other OS | ||||
|
r1090 | |||
if mode[0] != "r": | ||||
try: | ||||
|
r1241 | nlink = nlinks(f) | ||
|
r1090 | except OSError: | ||
d = os.path.dirname(f) | ||||
if not os.path.isdir(d): | ||||
os.makedirs(d) | ||||
else: | ||||
|
r1528 | if atomic: | ||
return atomicfile(f, mode) | ||||
|
r1241 | if nlink > 1: | ||
|
r1528 | rename(mktempcopy(f), f) | ||
|
r1090 | return file(f, mode) | ||
return o | ||||
|
r704 | def _makelock_file(info, pathname): | ||
ld = os.open(pathname, os.O_CREAT | os.O_WRONLY | os.O_EXCL) | ||||
os.write(ld, info) | ||||
os.close(ld) | ||||
def _readlock_file(pathname): | ||||
return file(pathname).read() | ||||
|
r1241 | def nlinks(pathname): | ||
"""Return number of hardlinks for the given file.""" | ||||
return os.stat(pathname).st_nlink | ||||
if hasattr(os, 'link'): | ||||
os_link = os.link | ||||
else: | ||||
def os_link(src, dst): | ||||
|
r1402 | raise OSError(0, _("Hardlinks not supported")) | ||
|
r1241 | |||
|
r1082 | # Platform specific variants | ||
|
r419 | if os.name == 'nt': | ||
|
r1420 | demandload(globals(), "msvcrt") | ||
|
r461 | nulldev = 'NUL:' | ||
|
r1609 | |||
class winstdout: | ||||
'''stdout on windows misbehaves if sent through a pipe''' | ||||
def __init__(self, fp): | ||||
self.fp = fp | ||||
def __getattr__(self, key): | ||||
return getattr(self.fp, key) | ||||
def close(self): | ||||
try: | ||||
self.fp.close() | ||||
except: pass | ||||
def write(self, s): | ||||
try: | ||||
return self.fp.write(s) | ||||
except IOError, inst: | ||||
if inst.errno != 0: raise | ||||
self.close() | ||||
raise IOError(errno.EPIPE, 'Broken pipe') | ||||
sys.stdout = winstdout(sys.stdout) | ||||
|
r1399 | try: | ||
import win32api, win32process | ||||
filename = win32process.GetModuleFileNameEx(win32api.GetCurrentProcess(), 0) | ||||
systemrc = os.path.join(os.path.dirname(filename), 'mercurial.ini') | ||||
|
r1609 | |||
|
r1399 | except ImportError: | ||
systemrc = r'c:\mercurial\mercurial.ini' | ||||
pass | ||||
|
r461 | |||
|
r1399 | rcpath = (systemrc, | ||
|
r1292 | os.path.join(os.path.expanduser('~'), 'mercurial.ini')) | ||
|
r1285 | def parse_patch_output(output_line): | ||
"""parses the output produced by patch and returns the file name""" | ||||
pf = output_line[14:] | ||||
if pf[0] == '`': | ||||
pf = pf[1:-1] # Remove the quotes | ||||
return pf | ||||
|
r1241 | try: # ActivePython can create hard links using win32file module | ||
import win32file | ||||
def os_link(src, dst): # NB will only succeed on NTFS | ||||
win32file.CreateHardLink(dst, src) | ||||
def nlinks(pathname): | ||||
"""Return number of hardlinks for the given file.""" | ||||
try: | ||||
fh = win32file.CreateFile(pathname, | ||||
win32file.GENERIC_READ, win32file.FILE_SHARE_READ, | ||||
None, win32file.OPEN_EXISTING, 0, None) | ||||
res = win32file.GetFileInformationByHandle(fh) | ||||
fh.Close() | ||||
return res[7] | ||||
except: | ||||
return os.stat(pathname).st_nlink | ||||
except ImportError: | ||||
pass | ||||
|
r441 | def is_exec(f, last): | ||
return last | ||||
def set_exec(f, mode): | ||||
pass | ||||
|
r515 | |||
|
r1420 | def set_binary(fd): | ||
msvcrt.setmode(fd.fileno(), os.O_BINARY) | ||||
|
r419 | def pconvert(path): | ||
return path.replace("\\", "/") | ||||
|
r422 | |||
|
r886 | def localpath(path): | ||
return path.replace('/', '\\') | ||||
def normpath(path): | ||||
return pconvert(os.path.normpath(path)) | ||||
|
r704 | makelock = _makelock_file | ||
readlock = _readlock_file | ||||
|
r461 | |||
|
r782 | def explain_exit(code): | ||
|
r1402 | return _("exited with status %d") % code, code | ||
|
r782 | |||
|
r419 | else: | ||
|
r461 | nulldev = '/dev/null' | ||
|
r1583 | def rcfiles(path): | ||
rcs = [os.path.join(path, 'hgrc')] | ||||
rcdir = os.path.join(path, 'hgrc.d') | ||||
try: | ||||
rcs.extend([os.path.join(rcdir, f) for f in os.listdir(rcdir) | ||||
if f.endswith(".rc")]) | ||||
except OSError, inst: pass | ||||
return rcs | ||||
|
r1635 | rcpath = [] | ||
if len(sys.argv) > 0: | ||||
rcpath.extend(rcfiles(os.path.dirname(sys.argv[0]) + '/../etc/mercurial')) | ||||
|
r1583 | rcpath.extend(rcfiles('/etc/mercurial')) | ||
rcpath.append(os.path.expanduser('~/.hgrc')) | ||||
rcpath = [os.path.normpath(f) for f in rcpath] | ||||
|
r1292 | |||
|
r1285 | def parse_patch_output(output_line): | ||
"""parses the output produced by patch and returns the file name""" | ||||
|
r1593 | pf = output_line[14:] | ||
if pf.startswith("'") and pf.endswith("'") and pf.find(" ") >= 0: | ||||
pf = pf[1:-1] # Remove the quotes | ||||
return pf | ||||
|
r1285 | |||
|
r441 | def is_exec(f, last): | ||
|
r1082 | """check whether a file is executable""" | ||
|
r441 | return (os.stat(f).st_mode & 0100 != 0) | ||
def set_exec(f, mode): | ||||
s = os.stat(f).st_mode | ||||
if (s & 0100 != 0) == mode: | ||||
return | ||||
if mode: | ||||
# Turn on +x for every +r bit when making a file executable | ||||
# and obey umask. | ||||
umask = os.umask(0) | ||||
os.umask(umask) | ||||
os.chmod(f, s | (s & 0444) >> 2 & ~umask) | ||||
else: | ||||
os.chmod(f, s & 0666) | ||||
|
r1420 | def set_binary(fd): | ||
pass | ||||
|
r419 | def pconvert(path): | ||
return path | ||||
|
r886 | def localpath(path): | ||
return path | ||||
normpath = os.path.normpath | ||||
|
r422 | def makelock(info, pathname): | ||
|
r704 | try: | ||
os.symlink(info, pathname) | ||||
except OSError, why: | ||||
if why.errno == errno.EEXIST: | ||||
raise | ||||
else: | ||||
_makelock_file(info, pathname) | ||||
|
r422 | |||
def readlock(pathname): | ||||
|
r704 | try: | ||
return os.readlink(pathname) | ||||
except OSError, why: | ||||
if why.errno == errno.EINVAL: | ||||
return _readlock_file(pathname) | ||||
else: | ||||
raise | ||||
|
r782 | |||
def explain_exit(code): | ||||
"""return a 2-tuple (desc, code) describing a process's status""" | ||||
if os.WIFEXITED(code): | ||||
val = os.WEXITSTATUS(code) | ||||
|
r1402 | return _("exited with status %d") % val, val | ||
|
r782 | elif os.WIFSIGNALED(code): | ||
val = os.WTERMSIG(code) | ||||
|
r1402 | return _("killed by signal %d") % val, val | ||
|
r782 | elif os.WIFSTOPPED(code): | ||
|
r912 | val = os.WSTOPSIG(code) | ||
|
r1402 | return _("stopped by signal %d") % val, val | ||
raise ValueError(_("invalid exit code")) | ||||
|
r1199 | |||
class chunkbuffer(object): | ||||
"""Allow arbitrary sized chunks of data to be efficiently read from an | ||||
iterator over chunks of arbitrary size.""" | ||||
|
r1200 | |||
|
r1199 | def __init__(self, in_iter, targetsize = 2**16): | ||
"""in_iter is the iterator that's iterating over the input chunks. | ||||
targetsize is how big a buffer to try to maintain.""" | ||||
self.in_iter = iter(in_iter) | ||||
self.buf = '' | ||||
self.targetsize = int(targetsize) | ||||
|
r1200 | if self.targetsize <= 0: | ||
|
r1402 | raise ValueError(_("targetsize must be greater than 0, was %d") % | ||
|
r1200 | targetsize) | ||
|
r1199 | self.iterempty = False | ||
|
r1200 | |||
|
r1199 | def fillbuf(self): | ||
|
r1200 | """Ignore target size; read every chunk from iterator until empty.""" | ||
|
r1199 | if not self.iterempty: | ||
collector = cStringIO.StringIO() | ||||
collector.write(self.buf) | ||||
for ch in self.in_iter: | ||||
collector.write(ch) | ||||
self.buf = collector.getvalue() | ||||
self.iterempty = True | ||||
def read(self, l): | ||||
|
r1200 | """Read L bytes of data from the iterator of chunks of data. | ||
|
r1308 | Returns less than L bytes if the iterator runs dry.""" | ||
|
r1199 | if l > len(self.buf) and not self.iterempty: | ||
# Clamp to a multiple of self.targetsize | ||||
targetsize = self.targetsize * ((l // self.targetsize) + 1) | ||||
collector = cStringIO.StringIO() | ||||
collector.write(self.buf) | ||||
collected = len(self.buf) | ||||
for chunk in self.in_iter: | ||||
collector.write(chunk) | ||||
collected += len(chunk) | ||||
if collected >= targetsize: | ||||
break | ||||
if collected < targetsize: | ||||
self.iterempty = True | ||||
self.buf = collector.getvalue() | ||||
|
r1200 | s, self.buf = self.buf[:l], buffer(self.buf, l) | ||
|
r1199 | return s | ||
def filechunkiter(f, size = 65536): | ||||
|
r1200 | """Create a generator that produces all the data in the file size | ||
(default 65536) bytes at a time. Chunks may be less than size | ||||
bytes if the chunk is the last chunk in the file, or the file is a | ||||
socket or some other type of file that sometimes reads less data | ||||
than is requested.""" | ||||
|
r1199 | s = f.read(size) | ||
|
r1377 | while len(s) > 0: | ||
|
r1199 | yield s | ||
s = f.read(size) | ||||
|
r1320 | |||
|
r1321 | def makedate(): | ||
|
r1482 | lt = time.localtime() | ||
if lt[8] == 1 and time.daylight: | ||||
tz = time.altzone | ||||
else: | ||||
tz = time.timezone | ||||
return time.mktime(lt), tz | ||||
|
r1329 | |||
|
r1321 | def datestr(date=None, format='%c'): | ||
"""represent a (unixtime, offset) tuple as a localized time. | ||||
unixtime is seconds since the epoch, and offset is the time zone's | ||||
number of seconds away from UTC.""" | ||||
t, tz = date or makedate() | ||||
|
r1320 | return ("%s %+03d%02d" % | ||
(time.strftime(format, time.gmtime(float(t) - tz)), | ||||
-tz / 3600, | ||||
((-tz % 3600) / 60))) | ||||