def get_data(self, space, filename):
filename = self._find_relative_path(filename)
w = space.wrap
try:
zip_file = RZipFile(self.filename, 'r')
try:
data = zip_file.read(filename)
finally:
zip_file.close()
return w(data)
except (KeyError, OSError):
raise OperationError(space.w_IOError, space.wrap("Error reading file"))
def get_data(self, space, filename):
filename = self._find_relative_path(filename)
w = space.wrap
try:
zip_file = RZipFile(self.filename, 'r')
try:
data = zip_file.read(filename)
finally:
zip_file.close()
return w(data)
except (KeyError, OSError):
raise OperationError(space.w_IOError,
space.wrap("Error reading file"))
def descr_new_zipimporter(space, w_type, name):
w = space.wrap
w_ZipImportError = space.getattr(space.getbuiltinmodule('zipimport'),
w('ZipImportError'))
ok = False
parts = name.split(os.path.sep)
filename = "" # make annotator happy
for i in range(1, len(parts) + 1):
filename = os.path.sep.join(parts[:i])
if not filename:
filename = os.path.sep
try:
s = os.stat(filename)
except OSError:
raise OperationError(
w_ZipImportError,
space.wrap("Cannot find name %s" % (filename, )))
if not stat.S_ISDIR(s.st_mode):
ok = True
break
if not ok:
raise OperationError(
w_ZipImportError,
space.wrap("Did not find %s to be a valid zippath" % (name, )))
try:
w_result = zip_cache.get(filename)
if w_result is None:
raise OperationError(
w_ZipImportError,
space.wrap(
"Cannot import %s from zipfile, recursion detected or"
"already tried and failed" % (name, )))
return w_result
except KeyError:
zip_cache.cache[filename] = None
try:
zip_file = RZipFile(filename, 'r')
except (BadZipfile, OSError):
raise OperationError(
w_ZipImportError,
space.wrap("%s seems not to be a zipfile" % (filename, )))
zip_file.close()
prefix = name[len(filename):]
if prefix.startswith(os.sep):
prefix = prefix[1:]
w_result = space.wrap(
W_ZipImporter(space, name, filename, zip_file.NameToInfo, prefix))
zip_cache.set(filename, w_result)
return w_result
def descr_new_zipimporter(space, w_type, name):
w = space.wrap
w_ZipImportError = space.getattr(space.getbuiltinmodule('zipimport'),
w('ZipImportError'))
ok = False
parts = name.split(os.path.sep)
filename = "" # make annotator happy
for i in range(1, len(parts) + 1):
filename = os.path.sep.join(parts[:i])
if not filename:
filename = os.path.sep
try:
s = os.stat(filename)
except OSError:
raise operationerrfmt(w_ZipImportError,
"Cannot find name %s", filename)
if not stat.S_ISDIR(s.st_mode):
ok = True
break
if not ok:
raise operationerrfmt(w_ZipImportError,
"Did not find %s to be a valid zippath", name)
try:
w_result = zip_cache.get(filename)
if w_result is None:
raise operationerrfmt(w_ZipImportError,
"Cannot import %s from zipfile, recursion detected or"
"already tried and failed", name)
return w_result
except KeyError:
zip_cache.cache[filename] = None
try:
zip_file = RZipFile(filename, 'r')
except (BadZipfile, OSError):
raise operationerrfmt(w_ZipImportError,
"%s seems not to be a zipfile", filename)
zip_file.close()
prefix = name[len(filename):]
if prefix.startswith(os.sep):
prefix = prefix[1:]
w_result = space.wrap(W_ZipImporter(space, name, filename,
zip_file.NameToInfo, prefix))
zip_cache.set(filename, w_result)
return w_result
def descr_new_zipimporter(space, w_type, name):
w = space.wrap
ok = False
parts_ends = [i for i in range(0, len(name))
if name[i] == os.path.sep or name[i] == ZIPSEP]
parts_ends.append(len(name))
filename = "" # make annotator happy
for i in parts_ends:
filename = name[:i]
if not filename:
filename = os.path.sep
try:
s = os.stat(filename)
except OSError:
raise operationerrfmt(get_error(space),
"Cannot find name %s", filename)
if not stat.S_ISDIR(s.st_mode):
ok = True
break
if not ok:
raise operationerrfmt(get_error(space),
"Did not find %s to be a valid zippath", name)
try:
w_result = zip_cache.get(filename)
if w_result is None:
raise operationerrfmt(get_error(space),
"Cannot import %s from zipfile, recursion detected or"
"already tried and failed", name)
except KeyError:
zip_cache.cache[filename] = None
try:
zip_file = RZipFile(filename, 'r')
except (BadZipfile, OSError):
raise operationerrfmt(get_error(space),
"%s seems not to be a zipfile", filename)
prefix = name[len(filename):]
if prefix.startswith(os.path.sep) or prefix.startswith(ZIPSEP):
prefix = prefix[1:]
if prefix and not prefix.endswith(ZIPSEP):
prefix += ZIPSEP
w_result = space.wrap(W_ZipImporter(space, name, filename, zip_file, prefix))
zip_cache.set(filename, w_result)
return w_result
def one():
rzip = RZipFile(zipname, "r", compression)
info = rzip.getinfo('one')
return (info.date_time[0] == year and
rzip.read('one') == 'stuff' and
rzip.read('three') == 'hello, world')
def one():
rzip = RZipFile(zipname, "r", compression)
info = rzip.getinfo("one")
return info.date_time[0] == year and rzip.read("one") == "stuff\n" and rzip.read("three") == "hello, world"
class W_ZipImporter(Wrappable):
def __init__(self, space, name, filename, dir, prefix):
self.space = space
self.name = name
self.filename = filename
self.dir = dir
self.prefix = prefix
self.w_ZipImportError = space.getattr(
space.getbuiltinmodule('zipimport'), space.wrap('ZipImportError'))
def getprefix(space, self):
return space.wrap(self.prefix)
def _find_relative_path(self, filename):
if filename.startswith(self.filename):
filename = filename[len(self.filename):]
if filename.startswith(os.sep):
filename = filename[1:]
if ZIPSEP != os.path.sep:
filename = filename.replace(os.path.sep, ZIPSEP)
return filename
def corr_zname(self, fname):
if ZIPSEP != os.path.sep:
return fname.replace(ZIPSEP, os.path.sep)
else:
return fname
def import_py_file(self, space, modname, filename, buf, pkgpath):
w = space.wrap
w_mod = w(Module(space, w(modname)))
real_name = self.name + os.path.sep + self.corr_zname(filename)
space.setattr(w_mod, w('__loader__'), space.wrap(self))
importing._prepare_module(space, w_mod, real_name, pkgpath)
result = importing.load_source_module(space,
w(modname),
w_mod,
filename,
buf,
write_pyc=False)
return result
def _parse_mtime(self, space, filename):
w = space.wrap
try:
info = self.dir[filename]
t = info.date_time
except KeyError:
return 0
else:
w_mktime = space.getattr(space.getbuiltinmodule('time'),
w('mktime'))
# XXX this is incredible fishing around module limitations
# in order to compare timestamps of .py and .pyc files
# we need time.mktime support on rpython level
all = [
w(t[0]),
w(t[1]),
w(t[2]),
w(t[3]),
w(t[4]),
w(t[5]),
w(0),
w(1),
w(-1)
]
mtime = int(
space.float_w(
space.call_function(w_mktime, space.newtuple(all))))
return mtime
def check_newer_pyfile(self, space, filename, timestamp):
mtime = self._parse_mtime(space, filename)
if mtime == 0:
return False
return mtime > timestamp
def check_compatible_mtime(self, space, filename, timestamp):
mtime = self._parse_mtime(space, filename)
if mtime == 0 or mtime != (timestamp & (~1)):
return False
return True
def import_pyc_file(self, space, modname, filename, buf, pkgpath):
w = space.wrap
magic = importing._get_long(buf[:4])
timestamp = importing._get_long(buf[4:8])
if (self.check_newer_pyfile(space, filename[:-1], timestamp) or
not self.check_compatible_mtime(space, filename, timestamp)):
return self.import_py_file(space, modname, filename[:-1], buf,
pkgpath)
buf = buf[8:] # XXX ugly copy, should use sequential read instead
w_mod = w(Module(space, w(modname)))
real_name = self.name + os.path.sep + self.corr_zname(filename)
space.setattr(w_mod, w('__loader__'), space.wrap(self))
importing._prepare_module(space, w_mod, real_name, pkgpath)
result = importing.load_compiled_module(space, w(modname), w_mod,
filename, magic, timestamp,
buf)
return result
def have_modulefile(self, space, filename):
if ZIPSEP != os.path.sep:
filename = filename.replace(os.path.sep, ZIPSEP)
w = space.wrap
try:
self.dir[filename]
return True
except KeyError:
return False
def find_module(self, space, fullname, w_path=None):
filename = self.mangle(fullname)
for _, _, ext in ENUMERATE_EXTS:
if self.have_modulefile(space, filename + ext):
return space.wrap(self)
find_module.unwrap_spec = ['self', ObjSpace, str, W_Root]
def mangle(self, name):
return name.replace('.', ZIPSEP)
def load_module(self, space, fullname):
w = space.wrap
w_modules = space.sys.get('modules')
try:
return space.getitem(w_modules, w(fullname))
except OperationError, e:
pass
filename = self.mangle(fullname)
last_exc = None
for compiled, is_package, ext in ENUMERATE_EXTS:
fname = filename + ext
try:
zip_file = RZipFile(self.filename, 'r')
try:
buf = zip_file.read(fname)
finally:
zip_file.close()
except (KeyError, OSError):
pass
else:
if is_package:
pkgpath = self.name
else:
pkgpath = None
try:
if compiled:
return self.import_pyc_file(space, fullname, fname,
buf, pkgpath)
else:
return self.import_py_file(space, fullname, fname, buf,
pkgpath)
except OperationError, e:
last_exc = e
w_mods = space.sys.get('modules')
space.call_method(w_mods, 'pop', w(fullname), space.w_None)
