def write_file(filename, data, mode):
if zip:
info = ZipInfo(filename)
info.external_attr = 0o755 << 16
zip_file.writestr(info, data)
else:
f = open(os.path.join(target, filename), mode)
try:
f.write(data)
finally:
f.close()
def testZipImporterMethodsInSubDirectory(self):
packdir = TESTPACK + os.sep
packdir2 = packdir + TESTPACK2 + os.sep
files = {
packdir2 + "__init__" + pyc_ext: (NOW, test_pyc),
packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)
}
z = ZipFile(TEMP_ZIP, "w")
try:
for name, (mtime, data) in files.items():
zinfo = ZipInfo(name, time.localtime(mtime))
zinfo.compress_type = self.compression
zinfo.comment = b"eggs"
z.writestr(zinfo, data)
z.close()
zi = zipimport.zipimporter(TEMP_ZIP + os.sep + packdir)
self.assertEqual(zi.archive, TEMP_ZIP)
self.assertEqual(zi.prefix, packdir)
self.assertEqual(zi.is_package(TESTPACK2), True)
mod = zi.load_module(TESTPACK2)
self.assertEqual(zi.get_filename(TESTPACK2), mod.__file__)
self.assertEqual(zi.is_package(TESTPACK2 + os.sep + '__init__'),
False)
self.assertEqual(zi.is_package(TESTPACK2 + os.sep + TESTMOD),
False)
pkg_path = TEMP_ZIP + os.sep + packdir + TESTPACK2
zi2 = zipimport.zipimporter(pkg_path)
find_mod_dotted = zi2.find_module(TESTMOD)
self.assertIsNotNone(find_mod_dotted)
self.assertIsInstance(find_mod_dotted, zipimport.zipimporter)
self.assertFalse(zi2.is_package(TESTMOD))
load_mod = find_mod_dotted.load_module(TESTMOD)
self.assertEqual(find_mod_dotted.get_filename(TESTMOD),
load_mod.__file__)
mod_path = TESTPACK2 + os.sep + TESTMOD
mod_name = module_path_to_dotted_name(mod_path)
mod = importlib.import_module(mod_name)
self.assertTrue(mod_name in sys.modules)
self.assertEqual(zi.get_source(TESTPACK2), None)
self.assertEqual(zi.get_source(mod_path), None)
self.assertEqual(zi.get_filename(mod_path), mod.__file__)
# To pass in the module name instead of the path, we must use the
# right importer.
loader = mod.__loader__
self.assertEqual(loader.get_source(mod_name), None)
self.assertEqual(loader.get_filename(mod_name), mod.__file__)
finally:
z.close()
os.remove(TEMP_ZIP)
def write(self, filename, arcname=None, compress_type=None):
with open(filename, 'rb') as f:
st = os.fstat(f.fileno())
data = f.read()
zinfo = ZipInfo(arcname or filename,
date_time=get_zipinfo_datetime(st.st_mtime))
zinfo.external_attr = (stat.S_IMODE(st.st_mode)
| stat.S_IFMT(st.st_mode)) << 16
zinfo.compress_type = ZIP_DEFLATED
self.writestr(zinfo, data, compress_type)
def testUnencodable(self):
filename = support.TESTFN_UNENCODABLE + ".zip"
z = ZipFile(filename, "w")
zinfo = ZipInfo(TESTMOD + ".py", time.localtime(NOW))
zinfo.compress_type = self.compression
z.writestr(zinfo, test_src)
z.close()
try:
zipimport.zipimporter(filename).load_module(TESTMOD)
finally:
os.remove(filename)
def write_file(filename, data):
if zip:
info = ZipInfo(filename)
info.external_attr = 0o755 << 16
zip_file.writestr(info, data)
else:
if isinstance(data, text_type):
data = data.encode("utf8")
with open(os.path.join(target, filename), "wb") as f:
f.write(data)
def _write_content(self, archive, path: str, content: str) -> None:
content = content.encode('utf-8')
# write content into archive
zip_info = ZipInfo(path)
archive.writestr(zip_info, content, compress_type=ZIP_DEFLATED)
# calculate hashsum
digest = sha256(content).digest()
digest = urlsafe_b64encode(digest).decode().rstrip('=')
self._records.append((path, digest, len(content)))
def testInvalidateCaches(self):
packdir = TESTPACK + os.sep
packdir2 = packdir + TESTPACK2 + os.sep
files = {packdir + "__init__" + pyc_ext: (NOW, test_pyc),
packdir2 + "__init__" + pyc_ext: (NOW, test_pyc),
packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc),
"spam" + pyc_ext: (NOW, test_pyc)}
self.addCleanup(os_helper.unlink, TEMP_ZIP)
with ZipFile(TEMP_ZIP, "w") as z:
for name, (mtime, data) in files.items():
zinfo = ZipInfo(name, time.localtime(mtime))
zinfo.compress_type = self.compression
zinfo.comment = b"spam"
z.writestr(zinfo, data)
zi = zipimport.zipimporter(TEMP_ZIP)
self.assertEqual(zi._files.keys(), files.keys())
# Check that the file information remains accurate after reloading
zi.invalidate_caches()
self.assertEqual(zi._files.keys(), files.keys())
# Add a new file to the ZIP archive
newfile = {"spam2" + pyc_ext: (NOW, test_pyc)}
files.update(newfile)
with ZipFile(TEMP_ZIP, "a") as z:
for name, (mtime, data) in newfile.items():
zinfo = ZipInfo(name, time.localtime(mtime))
zinfo.compress_type = self.compression
zinfo.comment = b"spam"
z.writestr(zinfo, data)
# Check that we can detect the new file after invalidating the cache
zi.invalidate_caches()
self.assertEqual(zi._files.keys(), files.keys())
spec = zi.find_spec('spam2')
self.assertIsNotNone(spec)
self.assertIsInstance(spec.loader, zipimport.zipimporter)
# Check that the cached data is removed if the file is deleted
os.remove(TEMP_ZIP)
zi.invalidate_caches()
self.assertFalse(zi._files)
self.assertIsNone(zipimport._zip_directory_cache.get(zi.archive))
self.assertIsNone(zi.find_spec("name_does_not_matter"))
def main(args):
unix_ts = max(ZIP_EPOCH, args.timestamp)
ts = parse_date(unix_ts)
with ZipFile(args.output, 'w') as _zip:
main = args.entrypoint
pre = args.stripprefix
preamble = _gen_path_loader(args.delimiteddirs, args.extrapaths, pre)
with open(main, 'rb') as entrypoint:
path = os.path.relpath(main, pre)
entry_info = ZipInfo(filename=path, date_time=ts)
entry_info.external_attr = 0o777 << 16 #NB Python3 only
entry_info.compress_type = ZIP_DEFLATED
data = preamble.encode('utf-8') + b'\n' + entrypoint.read()
_zip.writestr(entry_info, data)
for _file in [f for f in args.files if not f == main]:
entry_info = ZipInfo(filename=_file, date_time=ts)
entry_info.external_attr = 0o777 << 16 #NB Python3 only
entry_info.compress_type = ZIP_DEFLATED
with open(_file, 'rb') as src:
data = src.read()
_zip.writestr(entry_info, data)
def testBytesPath(self):
filename = support.TESTFN + ".zip"
self.addCleanup(support.unlink, filename)
with ZipFile(filename, "w") as z:
zinfo = ZipInfo(TESTMOD + ".py", time.localtime(NOW))
zinfo.compress_type = self.compression
z.writestr(zinfo, test_src)
zipimport.zipimporter(filename)
zipimport.zipimporter(os.fsencode(filename))
zipimport.zipimporter(bytearray(os.fsencode(filename)))
zipimport.zipimporter(memoryview(os.fsencode(filename)))
def test_parse_zip_empty_dir():
spider = spider_with_crawler(spider_class=CompressedFileSpider)
spider.data_type = 'release_package'
io = BytesIO()
with ZipFile(io, 'w', compression=ZIP_DEFLATED) as zipfile:
empty_folder = ZipInfo(os.path.join('test', 'test', '/'))
zipfile.writestr(empty_folder, '')
response = response_fixture(body=io.getvalue())
generator = spider.parse(response)
with pytest.raises(StopIteration):
next(generator)
def test_filter_members_no_prefix():
members = _filter_members(
[
ZipInfo("__MACOSX/foo"),
ZipInfo("submi1ssion/submission.csv"),
ZipInfo("submi2ssion/__MACOSX/bar"),
ZipInfo("baz/.DS_Store"),
ZipInfo("submi3ssion/images/image10x10x10.mhd"),
ZipInfo("submission/images/image10x10x10.zraw"),
]
)
assert members == [
{
"src": "submi1ssion/submission.csv",
"dest": "submi1ssion/submission.csv",
},
{
"src": "submi3ssion/images/image10x10x10.mhd",
"dest": "submi3ssion/images/image10x10x10.mhd",
},
{
"src": "submission/images/image10x10x10.zraw",
"dest": "submission/images/image10x10x10.zraw",
},
]
def handle(self, *args, **options):
if not options["filename"]:
raise CommandError("-f filename.zip is required")
if options["courses"]:
courses = options["courses"]
courses = Course.objects.filter(slug__in=options["courses"])
else:
courses = Course.objects.all()
if not courses:
raise CommandError("Courses not found")
if options["filename"].endswith(".zip"):
self.filename = options["filename"]
else:
self.filename = "%s.zip" % options["filename"]
h = HTMLParser()
zip = ZipFile(self.filename, mode="w")
for course in courses:
self.message("Adding course file %s.csv" % course.slug)
course_file = StringIO.StringIO()
course_csv = csv.writer(course_file, quoting=csv.QUOTE_ALL)
headers = ["first_name", "last_name", "email"]
course_csv.writerow(headers)
for student in course.students.all():
row = []
for field in headers:
fieldvalue = getattr(student, field)
row.append(h.unescape(fieldvalue.encode("ascii",
"ignore")))
course_csv.writerow(row)
course_fileinfo = ZipInfo("%s.csv" % course.slug)
course_file.seek(0)
zip.writestr(course_fileinfo, course_file.read())
course_file.close()
zip.close()
self.message("Created %s file" % self.filename)
def testZipImporterMethods(self):
packdir = TESTPACK + os.sep
packdir2 = packdir + TESTPACK2 + os.sep
files = {
packdir + "__init__" + pyc_ext: (NOW, test_pyc),
packdir2 + "__init__" + pyc_ext: (NOW, test_pyc),
packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)
}
z = ZipFile(TEMP_ZIP, "w")
try:
for name, (mtime, data) in files.items():
zinfo = ZipInfo(name, time.localtime(mtime))
zinfo.compress_type = self.compression
zinfo.comment = b"spam"
z.writestr(zinfo, data)
z.close()
zi = zipimport.zipimporter(TEMP_ZIP)
self.assertEqual(zi.archive, TEMP_ZIP)
self.assertEqual(zi.is_package(TESTPACK), True)
mod = zi.load_module(TESTPACK)
self.assertEqual(zi.get_filename(TESTPACK), mod.__file__)
existing_pack_path = importlib.import_module(TESTPACK).__path__[0]
expected_path_path = os.path.join(TEMP_ZIP, TESTPACK)
self.assertEqual(existing_pack_path, expected_path_path)
self.assertEqual(zi.is_package(packdir + '__init__'), False)
self.assertEqual(zi.is_package(packdir + TESTPACK2), True)
self.assertEqual(zi.is_package(packdir2 + TESTMOD), False)
mod_path = packdir2 + TESTMOD
mod_name = module_path_to_dotted_name(mod_path)
mod = importlib.import_module(mod_name)
self.assertTrue(mod_name in sys.modules)
self.assertEqual(zi.get_source(TESTPACK), None)
self.assertEqual(zi.get_source(mod_path), None)
self.assertEqual(zi.get_filename(mod_path), mod.__file__)
# To pass in the module name instead of the path, we must use the
# right importer
loader = mod.__loader__
self.assertEqual(loader.get_source(mod_name), None)
self.assertEqual(loader.get_filename(mod_name), mod.__file__)
# test prefix and archivepath members
zi2 = zipimport.zipimporter(TEMP_ZIP + os.sep + TESTPACK)
self.assertEqual(zi2.archive, TEMP_ZIP)
self.assertEqual(zi2.prefix, TESTPACK + os.sep)
finally:
z.close()
os.remove(TEMP_ZIP)
def export():
"""Export all recipes as plaintext in compressed directory."""
recipes = db.execute("SELECT recipes.recipe_id FROM recipes JOIN owners ON recipes.recipe_id="
"owners.recipe_id WHERE user_id = ?", (session["user_id"],))
memory_file = BytesIO()
with ZipFile(memory_file, "w") as zf:
for recipe in recipes:
data = ZipInfo(str(recipe[0]) + ".txt")
data.date_time = time.localtime(time.time())[:6]
data.compress_type = ZIP_DEFLATED
zf.writestr(data, plaintext(recipe[0], db))
memory_file.seek(0)
return send_file(memory_file, attachment_filename='recipes.zip', as_attachment=True)
def setup_method(self):
for filename in [
"test.exe",
"test.zip",
"test.jar",
"test.apk",
"test.msi",
"test.egg",
"test.whl",
]:
zippath = os.path.join(self.tempdir, filename)
with ZipFile(zippath, "w") as zipfile:
zipfile.writestr(ZipInfo("test.txt"), "feedface")
def __zip_content(context, zip_file, zip_file_path, destination_path, content):
context.view.add_zip_content(destination_path, zip_file_path)
try:
info = ZipInfo(destination_path)
info.external_attr = 0777 << 16L # give full access to included file
zip_file.writestr(info, content)
except Exception as e:
raise HandledError('Could not add content to zip file: {}'.format(e.message))
def _add_file_to_zip(zipfile, path, archive_dest=None):
with open(path, 'r') as f:
file_bytes = f.read()
info = ZipInfo(path)
info.date_time = time.localtime()
# Set permissions to be executable
info.external_attr = 0o100755 << 16
# If archive dest was provided, use that as path
if archive_dest:
info.filename = archive_dest
zipfile.writestr(info, file_bytes, ZIP_DEFLATED)
def compress_files(packs: typing.List['str'], files: Dict[str, str]):
for pack in packs:
archive = BytesIO()
with ZipFile(archive, 'w') as zip_archive:
for key, value in files.items():
file = ZipInfo(key)
zip_archive.writestr(file, pack[1] + value)
with open(f'static/chayi_models_{pack[0]}.zip', 'wb+') as f:
# noinspection PyTypeChecker
f.write(archive.getbuffer())
archive.close()
def testBytesPath(self):
filename = support.TESTFN + '.zip'
self.addCleanup(support.unlink, filename)
with ZipFile(filename, 'w') as z:
zinfo = ZipInfo(TESTMOD + '.py', time.localtime(NOW))
zinfo.compress_type = self.compression
z.writestr(zinfo, test_src)
zipimport.zipimporter(filename)
zipimport.zipimporter(os.fsencode(filename))
with self.assertWarns(DeprecationWarning):
zipimport.zipimporter(bytearray(os.fsencode(filename)))
with self.assertWarns(DeprecationWarning):
zipimport.zipimporter(memoryview(os.fsencode(filename)))
def process_one(self, infile, filename):
""" process a non-zipped file. Is this needed? """
self.init_report()
resultfile = Tools.make_return_file(filename)
stat = os.stat(infile.fileno)
#Create a fake zipinfo
zi = ZipInfo(filename=filename)
zi.file_size = stat.st_size
data = self.process_file(infile)
resultfile.write(data)
self.finalize_report(resultfile)
return report
def handle(self, *args, **options):
if not options["filename"]:
raise CommandError("-f filename.zip is required")
if options["courses"]:
courses = options["courses"]
courses = Course.objects.filter(slug__in=options["courses"])
else:
courses = Course.objects.all()
if not courses:
raise CommandError("Courses not found")
if options["filename"].endswith(".zip"):
self.filename = options["filename"]
else:
self.filename = "%s.zip" % options["filename"]
zip = ZipFile(self.filename, mode="w")
for course in courses:
self.message("Adding course file %s.csv" % course.slug)
course_file = StringIO.StringIO()
course_csv = csv.writer(course_file, quoting=csv.QUOTE_ALL)
headers = ["course", "username", "email"]
course_csv.writerow(headers)
for teacher in course.teachers.all():
row = []
row.append(course.slug)
row.append(teacher.username)
row.append(teacher.email)
course_csv.writerow(row)
course_fileinfo = ZipInfo("%s.csv" % course.slug)
course_file.seek(0)
zip.writestr(course_fileinfo, course_file.read())
course_file.close()
zip.close()
self.message("Created %s file" % self.filename)
def makeZip(self, files, zipName=TEMP_ZIP, **kw):
self.addCleanup(support.unlink, zipName)
with ZipFile(zipName, 'w') as z:
for name, (mtime, data) in files.items():
zinfo = ZipInfo(name, time.localtime(mtime))
zinfo.compress_type = self.compression
z.writestr(zinfo, data)
stuff = kw.get('stuff', None)
if stuff is not None:
with open(zipName, 'rb') as f:
data = f.read()
with open(zipName, 'wb') as f:
f.write(stuff)
f.write(data)
def testZipImporterMethods(self):
packdir = TESTPACK + os.sep
packdir2 = packdir + TESTPACK2 + os.sep
files = {
(packdir + '__init__' + pyc_ext): (NOW, test_pyc),
(packdir2 + '__init__' + pyc_ext): (NOW, test_pyc),
(packdir2 + TESTMOD + pyc_ext): (NOW, test_pyc),
('spam' + pyc_ext): (NOW, test_pyc)
}
z = ZipFile(TEMP_ZIP, 'w')
try:
for name, (mtime, data) in files.items():
zinfo = ZipInfo(name, time.localtime(mtime))
zinfo.compress_type = self.compression
zinfo.comment = b'spam'
z.writestr(zinfo, data)
z.close()
zi = zipimport.zipimporter(TEMP_ZIP)
self.assertEqual(zi.archive, TEMP_ZIP)
self.assertEqual(zi.is_package(TESTPACK), True)
find_mod = zi.find_module('spam')
self.assertIsNotNone(find_mod)
self.assertIsInstance(find_mod, zipimport.zipimporter)
self.assertFalse(find_mod.is_package('spam'))
load_mod = find_mod.load_module('spam')
self.assertEqual(find_mod.get_filename('spam'), load_mod.__file__)
mod = zi.load_module(TESTPACK)
self.assertEqual(zi.get_filename(TESTPACK), mod.__file__)
existing_pack_path = importlib.import_module(TESTPACK).__path__[0]
expected_path_path = os.path.join(TEMP_ZIP, TESTPACK)
self.assertEqual(existing_pack_path, expected_path_path)
self.assertEqual(zi.is_package(packdir + '__init__'), False)
self.assertEqual(zi.is_package(packdir + TESTPACK2), True)
self.assertEqual(zi.is_package(packdir2 + TESTMOD), False)
mod_path = packdir2 + TESTMOD
mod_name = module_path_to_dotted_name(mod_path)
mod = importlib.import_module(mod_name)
self.assertTrue(mod_name in sys.modules)
self.assertEqual(zi.get_source(TESTPACK), None)
self.assertEqual(zi.get_source(mod_path), None)
self.assertEqual(zi.get_filename(mod_path), mod.__file__)
loader = mod.__loader__
self.assertEqual(loader.get_source(mod_name), None)
self.assertEqual(loader.get_filename(mod_name), mod.__file__)
zi2 = zipimport.zipimporter(TEMP_ZIP + os.sep + TESTPACK)
self.assertEqual(zi2.archive, TEMP_ZIP)
self.assertEqual(zi2.prefix, TESTPACK + os.sep)
finally:
z.close()
os.remove(TEMP_ZIP)
def define_zip_info(path: str, timestamp: int = MIN_EPOCH, strip_prefix: str = None):
if strip_prefix is not None:
path = os.path.relpath(path, strip_prefix)
if timestamp < MIN_EPOCH: # prevent errors with zip dated before 1980
dt = MIN_EPOCH
else:
dt = convert_epoch_to_datetime_parts(timestamp)
info = ZipInfo(filename=path, date_time=dt)
info.external_attr = 0o777 << 16 # give full access to included file
info.compress_type = ZIP_DEFLATED
return info
def close(self):
# Write RECORD
if self.fp is not None and self.mode == 'w' and self._file_hashes:
content = '\n'.join(
'{},{}={},{}'.format(fname, algorithm, hash_,
self._file_sizes[fname])
for fname, (algorithm, hash_) in self._file_hashes.items())
content += '\n{},,\n'.format(self.record_path)
zinfo = ZipInfo(native(self.record_path),
date_time=get_zipinfo_datetime())
zinfo.compress_type = ZIP_DEFLATED
self.writestr(zinfo, as_bytes(content))
super(WheelFile, self).close()
def _remake_static_zip(options, jdatas, alldata):
webroot = options.env['webroot_path']
zfiletmp = webroot + '/static_file/static.zip'
zipf = zipfile.ZipFile(zfiletmp,
mode="w",
compression=zipfile.ZIP_DEFLATED)
zinfo = ZipInfo(filename='static.json', date_time=(2015, 12, 16, 0, 0, 0))
jdatas = json.dumps(jdatas,
sort_keys=True,
indent=4,
separators=(', ', ' : '))
zipf.writestr(zinfo, jdatas, zipfile.ZIP_DEFLATED)
zipf.close()
zdata = fsutils.readFile(zfiletmp)
md5s = strutil.md5digest(zdata)
zfile = webroot + '/static_file/' + md5s + '.zip'
os.rename(zfiletmp, zfile)
conf = alldata.get('game:9999:upgrade_client_static:0', None)
if conf != None:
conf['static_file_md5'] = md5s
ulist = conf['static_file_url']
if options.pokerdict.get('mode') != 1:
http_game = options.pokerdict['http_game']
myurl = http_game + '/static_file'
if myurl not in ulist:
if options.pokerdict['mode'] > 1:
ulist.insert(0, myurl)
else:
ulist.append(myurl)
actlog.log('THE STATIC JSON CHANGED !! ',
myurl + '/' + md5s + '.zip')
actlog.log('THE STATIC JSON CHANGED !! ', zfile)
setattr(options, 'push_static', 0)
if fsutils.fileExists('./cdn/copy_static_file.sh'):
setattr(options, 'push_static', 1)
actlog.log('UPLOAD ZIP TO CDN !!')
st, out = commands.getstatusoutput('./cdn/copy_static_file.sh')
if st != 0:
actlog.log('UPLOAD ZIP TO CDN ERROR !!')
actlog.log(out)
return 0
else:
actlog.log('UPLOAD ZIP TO CDN OK !!', out)
else:
actlog.log('UPLOAD ZIP TO CDN THE SHELL NOT FOUND !')
return 1
def writeData(self, data):
""" @see:L{NullDataStorer<datafinder.persistence.data.datastorer.NullDataStorer>} """
if self._readonly:
raise PersistenceError(u"Tried to write to read-only archive.")
try:
info = self._archive.getinfo(self._persistenceId)
except KeyError:
info = ZipInfo(self._persistenceId)
try:
self._archive.writestr(info, data.read())
except IOError, error:
errorMessage = "Cannot write data of archive member '%s'.\nReason: '%s'" % (
self.identifier, error.message)
raise PersistenceError(errorMessage)
def download():
bcfzips64 = request.form["bcfdata"].split(",")
binaries = [base64.b64decode(x) for x in bcfzips64]
memory_file = BytesIO()
with ZipFile(memory_file, 'w') as zf:
for i, binary in enumerate(binaries):
data = ZipInfo("bcf_file_{}.bcfzip".format(i), time.localtime(time.time())[:6])
data.compress_type = ZIP_STORED
zf.writestr(data, binary)
memory_file.seek(0)
return send_file(memory_file, as_attachment=True, attachment_filename="bcf_check.zip", mimetype="application/zip")
def close(self):
# Write RECORD
if self.fp is not None and self.mode == "w" and self._file_hashes:
content = "\n".join(
"{},{}={},{}".format(fname, algorithm, hash_,
self._file_sizes[fname])
for fname, (algorithm, hash_) in self._file_hashes.items())
content += "\n{},,\n".format(self.record_path)
zinfo = ZipInfo(native(self.record_path),
date_time=get_zipinfo_datetime())
zinfo.compress_type = ZIP_DEFLATED
zinfo.external_attr = 0o664 << 16
self.writestr(zinfo, as_bytes(content))
ZipFile.close(self)
def make_dir_entry(name=None, date_time=None, mode=MODE_DIRECTORY):
tt = date_time.timetuple()
dir = ZipInfo()
dir.filename = name+('/' if name[-1] != '/' else '')
dir.orig_filename = dir.filename
dir.date_time = date_time.isocalendar() + (tt.tm_hour,
tt.tm_min, tt.tm_sec)
dir.compress_type = 0
dir.create_system = 0
dir.create_version = 20
dir.extract_version = 10
dir.external_attr = mode
return dir
