try:
st = os.stat(path)
except os.error:
- return 0
+ return False
return st[0] & 0111 != 0
def isatty(self):
if self.closed:
raise ValueError, "I/O operation on closed file"
- return 0
+ return False
def seek(self, pos, mode = 0):
if self.closed:
exception.
Usage:
-while 1:
+while True:
try:
chunk = Chunk(file)
except EOFError:
break
chunktype = chunk.getname()
- while 1:
+ while True:
data = chunk.read(nbytes)
if not data:
pass
"""
class Chunk:
- def __init__(self, file, align = 1, bigendian = 1, inclheader = 0):
+ def __init__(self, file, align=True, bigendian=True, inclheader=False):
import struct
- self.closed = 0
+ self.closed = False
self.align = align # whether to align to word (2-byte) boundaries
if bigendian:
strflag = '>'
try:
self.offset = self.file.tell()
except (AttributeError, IOError):
- self.seekable = 0
+ self.seekable = False
else:
- self.seekable = 1
+ self.seekable = True
def getname(self):
"""Return the name (ID) of the current chunk."""
def close(self):
if not self.closed:
self.skip()
- self.closed = 1
+ self.closed = True
def isatty(self):
if self.closed:
raise ValueError, "I/O operation on closed file"
- return 0
+ return False
- def seek(self, pos, whence = 0):
+ def seek(self, pos, whence=0):
"""Seek to specified position into the chunk.
Default position is 0 (start of chunk).
If the file is not seekable, this will result in an error.
raise ValueError, "I/O operation on closed file"
return self.size_read
- def read(self, size = -1):
+ def read(self, size=-1):
"""Read at most size bytes from the chunk.
If size is omitted or negative, read until the end
of the chunk.
"""Is a path a symbolic link?
This will always return false on systems where posix.lstat doesn't exist."""
- return 0
+ return False
def exists(path):
self._lineno = 0
self._filelineno = 0
self._file = None
- self._isstdin = 0
+ self._isstdin = False
self._backupfilename = None
self._buffer = []
self._bufindex = 0
try: os.unlink(backupfilename)
except: pass
- self._isstdin = 0
+ self._isstdin = False
self._buffer = []
self._bufindex = 0
self._files = self._files[1:]
self._filelineno = 0
self._file = None
- self._isstdin = 0
+ self._isstdin = False
self._backupfilename = 0
if self._filename == '-':
self._filename = '<stdin>'
self._file = sys.stdin
- self._isstdin = 1
+ self._isstdin = True
else:
if self._inplace:
self._backupfilename = (
if mode[0:1] == 'r':
self.mode = READ
# Set flag indicating start of a new member
- self._new_member = 1
+ self._new_member = True
self.extrabuf = ""
self.extrasize = 0
self.filename = filename
self.fileobj.read(xlen)
if flag & FNAME:
# Read and discard a null-terminated string containing the filename
- while (1):
+ while True:
s=self.fileobj.read(1)
if not s or s=='\000': break
if flag & FCOMMENT:
# Read and discard a null-terminated string containing a comment
- while (1):
+ while True:
s=self.fileobj.read(1)
if not s or s=='\000': break
if flag & FHCRC:
readsize = 1024
if size < 0: # get the whole thing
try:
- while 1:
+ while True:
self._read(readsize)
readsize = readsize * 2
except EOFError:
self._init_read()
self._read_gzip_header()
self.decompress = zlib.decompressobj(-zlib.MAX_WBITS)
- self._new_member = 0
+ self._new_member = False
# Read a chunk of data from the file
buf = self.fileobj.read(size)
# Check the CRC and file size, and set the flag so we read
# a new member on the next call
self._read_eof()
- self._new_member = 1
+ self._new_member = True
def _add_read_data(self, data):
self.crc = zlib.crc32(data, self.crc)
self.fileobj.flush()
def isatty(self):
- return 0
+ return False
def tell(self):
return self.offset
if self.mode != READ:
raise IOError("Can't rewind in write mode")
self.fileobj.seek(0)
- self._new_member = 1
+ self._new_member = True
self.extrabuf = ""
self.extrasize = 0
self.offset = 0
if size < 0: size = sys.maxint
bufs = []
readsize = min(100, size) # Read from the file in small chunks
- while 1:
+ while True:
if size == 0:
return "".join(bufs) # Return resulting line
while sizehint > 0:
line = self.readline()
if line == "": break
- L.append( line )
+ L.append(line)
sizehint = sizehint - len(line)
return L
else:
f = __builtin__.open(arg, "rb")
g = open(arg + ".gz", "wb")
- while 1:
+ while True:
chunk = f.read(1024)
if not chunk:
break
"""Return true if the pathname refers to a symbolic link.
Always false on the Mac, until we understand Aliases.)"""
- return 0
+ return False
def isfile(s):
try:
st = os.stat(s)
except os.error:
- return 0
+ return False
return S_ISREG(st[ST_MODE])
def islink(path):
"""Test for symbolic link. On WindowsNT/95 always returns false"""
- return 0
+ return False
# Does a path exist?
try:
st = os.stat(path)
except os.error:
- return 0
+ return False
return stat.S_ISDIR(st[stat.ST_MODE])
try:
st = os.stat(path)
except os.error:
- return 0
+ return False
return stat.S_ISREG(st[stat.ST_MODE])
def islink(path):
"""Test for symbolic link. On OS/2 always returns false"""
- return 0
+ return False
# Does a path exist?
try:
st = os.stat(path)
except os.error:
- return 0
+ return False
return stat.S_ISDIR(st[stat.ST_MODE])
try:
st = os.stat(path)
except os.error:
- return 0
+ return False
return stat.S_ISREG(st[stat.ST_MODE])
try:
st = os.lstat(path)
except (os.error, AttributeError):
- return 0
+ return False
return stat.S_ISLNK(st[stat.ST_MODE])
try:
st = os.stat(path)
except os.error:
- return 0
+ return False
return stat.S_ISDIR(st[stat.ST_MODE])
try:
st = os.stat(path)
except os.error:
- return 0
+ return False
return stat.S_ISREG(st[stat.ST_MODE])
import re
_varprog = re.compile(r'\$(\w+|\{[^}]*\})')
i = 0
- while 1:
+ while True:
m = _varprog.search(path, i)
if not m:
break
objid = _id(object)
if objid in context:
stream.write(_recursion(object))
- self.__recursive = 1
- self.__readable = 0
+ self.__recursive = True
+ self.__readable = False
return
rep = self.__repr(object, context, level - 1)
typ = _type(object)
repr, readable, recursive = self.format(object, context.copy(),
self.__depth, level)
if not readable:
- self.__readable = 0
+ self.__readable = False
if recursive:
- self.__recursive = 1
+ self.__recursive = True
return repr
def format(self, object, context, maxlevels, level):
typ = _type(object)
if typ is StringType:
if 'locale' not in _sys_modules:
- return `object`, 1, 0
+ return `object`, True, False
if "'" in object and '"' not in object:
closure = '"'
quotes = {'"': '\\"'}
write(char)
else:
write(qget(char, `char`[1:-1]))
- return ("%s%s%s" % (closure, sio.getvalue(), closure)), 1, 0
+ return ("%s%s%s" % (closure, sio.getvalue(), closure)), True, False
if typ is DictType:
if not object:
- return "{}", 1, 0
+ return "{}", True, False
objid = _id(object)
if maxlevels and level > maxlevels:
- return "{...}", 0, objid in context
+ return "{...}", False, objid in context
if objid in context:
- return _recursion(object), 0, 1
+ return _recursion(object), False, True
context[objid] = 1
- readable = 1
- recursive = 0
+ readable = True
+ recursive = False
components = []
append = components.append
level += 1
append("%s: %s" % (krepr, vrepr))
readable = readable and kreadable and vreadable
if krecur or vrecur:
- recursive = 1
+ recursive = True
del context[objid]
return "{%s}" % _commajoin(components), readable, recursive
if typ is ListType or typ is TupleType:
if typ is ListType:
if not object:
- return "[]", 1, 0
+ return "[]", True, False
format = "[%s]"
elif _len(object) == 1:
format = "(%s,)"
else:
if not object:
- return "()", 1, 0
+ return "()", True, False
format = "(%s)"
objid = _id(object)
if maxlevels and level > maxlevels:
- return format % "...", 0, objid in context
+ return format % "...", False, objid in context
if objid in context:
- return _recursion(object), 0, 1
+ return _recursion(object), False, True
context[objid] = 1
- readable = 1
- recursive = 0
+ readable = True
+ recursive = False
components = []
append = components.append
level += 1
orepr, oreadable, orecur = _safe_repr(o, context, maxlevels, level)
append(orepr)
if not oreadable:
- readable = 0
+ readable = False
if orecur:
- recursive = 1
+ recursive = True
del context[objid]
return format % _commajoin(components), readable, recursive
rep = `object`
- return rep, (rep and not rep.startswith('<')), 0
+ return rep, (rep and not rep.startswith('<')), False
def _recursion(object):
r'RFC[- ]?(\d+)|'
r'PEP[- ]?(\d+)|'
r'(self\.)?(\w+))')
- while 1:
+ while True:
match = pattern.search(text, here)
if not match: break
start, end = match.span()
def interact(self):
self.output.write('\n')
- while 1:
+ while True:
self.output.write('help> ')
self.output.flush()
try:
if not (os.path.islink(dir) and inode in self.inodes):
self.inodes.append(inode) # detect circular symbolic links
return ispackage(dir)
+ return False
def run(self, callback, key=None, completer=None):
if key: key = lower(key)
- self.quit = 0
+ self.quit = False
seen = {}
for modname in sys.builtin_module_names:
def serve_until_quit(self):
import select
- self.quit = 0
+ self.quit = False
while not self.quit:
rd, wr, ex = select.select([self.socket.fileno()], [], [], 1)
if rd: self.handle_request()
data in RFC 2822-like formats that support embedded comments or
free-text data.
"""
- return None
+ return False
def getallmatchingheaders(self, name):
"""Find all header lines matching a given header name.
def isname(name):
# check that group name is a valid string
if not isident(name[0]):
- return 0
+ return False
for char in name:
if not isident(char) and not isdigit(char):
- return 0
- return 1
+ return False
+ return True
def _group(escape, groups):
# check if the escape string represents a valid group
try:
st = stat(path)
except _os.error:
- return 0
+ return False
return S_ISDIR(st[ST_MODE])
# Debug support (adapted from ihooks.py)
-_VERBOSE = 0
+_VERBOSE = 0 # XXX Bool or int?
if __debug__:
# than 20 times per second (or the timeout time remaining).
endtime = _time() + timeout
delay = 0.0005 # 500 us -> initial delay of 1 ms
- while 1:
+ while True:
gotit = waiter.acquire(0)
if gotit:
break
self.__value = value
def acquire(self, blocking=1):
- rc = 0
+ rc = False
self.__cond.acquire()
while self.__value == 0:
if not blocking:
if __debug__:
self._note("%s.acquire: success, value=%s",
self, self.__value)
- rc = 1
+ rc = True
self.__cond.release()
return rc
def __init__(self, verbose=None):
_Verbose.__init__(self, verbose)
self.__cond = Condition(Lock())
- self.__flag = 0
+ self.__flag = False
def isSet(self):
return self.__flag
def set(self):
self.__cond.acquire()
- self.__flag = 1
+ self.__flag = True
self.__cond.notifyAll()
self.__cond.release()
def clear(self):
self.__cond.acquire()
- self.__flag = 0
+ self.__flag = False
self.__cond.release()
def wait(self, timeout=None):
class Thread(_Verbose):
- __initialized = 0
+ __initialized = False
def __init__(self, group=None, target=None, name=None,
args=(), kwargs={}, verbose=None):
self.__args = args
self.__kwargs = kwargs
self.__daemonic = self._set_daemon()
- self.__started = 0
- self.__stopped = 0
+ self.__started = False
+ self.__stopped = False
self.__block = Condition(Lock())
- self.__initialized = 1
+ self.__initialized = True
def _set_daemon(self):
# Overridden in _MainThread and _DummyThread
_limbo[self] = self
_active_limbo_lock.release()
_start_new_thread(self.__bootstrap, ())
- self.__started = 1
+ self.__started = True
_sleep(0.000001) # 1 usec, to let the thread run (Solaris hack)
def run(self):
def __bootstrap(self):
try:
- self.__started = 1
+ self.__started = True
_active_limbo_lock.acquire()
_active[_get_ident()] = self
del _limbo[self]
def __stop(self):
self.__block.acquire()
- self.__stopped = 1
+ self.__stopped = True
self.__block.notifyAll()
self.__block.release()
def __init__(self):
Thread.__init__(self, name="MainThread")
- self._Thread__started = 1
+ self._Thread__started = True
_active_limbo_lock.acquire()
_active[_get_ident()] = self
_active_limbo_lock.release()
atexit.register(self.__exitfunc)
def _set_daemon(self):
- return 0
+ return False
def __exitfunc(self):
self._Thread__stop()
def __init__(self):
Thread.__init__(self, name=_newname("Dummy-%d"))
- self._Thread__started = 1
+ self._Thread__started = True
_active_limbo_lock.acquire()
_active[_get_ident()] = self
_active_limbo_lock.release()
def _set_daemon(self):
- return 1
+ return True
def join(self, timeout=None):
- assert 0, "cannot join a dummy thread"
+ assert False, "cannot join a dummy thread"
# Global API functions
Both args must be URIs in reduced form.
"""
if base == test:
- return 1
+ return True
if base[0] != test[0]:
- return 0
+ return False
common = posixpath.commonprefix((base[1], test[1]))
if len(common) == len(base[1]):
- return 1
- return 0
+ return True
+ return False
class HTTPPasswordMgrWithDefaultRealm(HTTPPasswordMgr):
endrec = fpin.read()
fpin.close()
if endrec[0:4] == "PK\005\006" and endrec[-2:] == "\000\000":
- return 1 # file has correct magic number
+ return True # file has correct magic number
except IOError:
pass
+ return False
class ZipInfo:
projects / python / commitdiff