def create(self, output_path, dry_run=False, output_format=None): """ Create the archive at output_file_path. Type of the archive is determined either by extension of output_file_path or by output_format. Supported formats are: gz, zip, bz2, tar, tgz @param output_path: Output file path. @type output_path: string @param dry_run: Determines whether create should do nothing but print what it would archive. @type dry_run: bool @param output_format: Determines format of the output archive. If None, format is determined from extension of output_file_path. @type output_format: string """ if output_format is None: file_name, file_ext = path.splitext(output_path) output_format = file_ext[len(extsep):].lower() self.LOG.debug("Output format is not explicitly set, determined format is {0}.".format(output_format)) if not dry_run: if output_format == 'zip': archive = ZipFile(path.abspath(output_path), 'w') def add_file(file_path, arcname): if not path.islink(file_path): archive.write(file_path, arcname, ZIP_DEFLATED) else: i = ZipInfo(arcname) i.create_system = 3 i.external_attr = 0xA1ED0000 archive.writestr(i, readlink(file_path)) elif output_format in ['tar', 'bz2', 'gz', 'tgz']: if output_format == 'tar': t_mode = 'w' elif output_format == 'tgz': t_mode = 'w:gz' else: t_mode = 'w:{0}'.format(output_format) archive = tarfile.open(path.abspath(output_path), t_mode) add_file = lambda file_path, arcname: archive.add(file_path, arcname) else: raise RuntimeError("Unknown format: {0}".format(output_format)) def archiver(file_path, arcname): self.LOG.debug("Compressing {0} => {1}...".format(file_path, arcname)) add_file(file_path, arcname) else: archive = None archiver = lambda file_path, arcname: self.LOG.info("{0} => {1}".format(file_path, arcname)) self.archive_all_files(archiver) if archive is not None: archive.close()
def create(self, output_file): """ create(str output_file) -> None Creates the archive, written to the given output_file Filetype may be one of: gz, zip, bz2, tar, tgz """ # # determine the format # _, _, format = output_file.rpartition(".") format = format.lower() if format == 'zip': from zipfile import ZipFile, ZIP_DEFLATED output_archive = ZipFile(path.abspath(output_file), 'w') add = lambda name, arcname: output_archive.write( name, self.prefix + arcname, ZIP_DEFLATED) elif format in ['tar', 'bz2', 'gz', 'tgz']: import tarfile if format == 'tar': t_mode = 'w' elif format == 'tgz': t_mode = 'w:gz' else: t_mode = ('w:%s' % format) output_archive = tarfile.open(path.abspath(output_file), t_mode) add = lambda name, arcname: output_archive.add( name, self.prefix + arcname) else: raise RuntimeError("Unknown format: '%s'" % format) # # compress # # extra files first (we may change folder later) for name in self.extra: if self.verbose: toPath = '=> %s%s' % (self.prefix, name) if self.prefix else "" print 'Compressing %s %s ...' % (name, toPath) add(name, name) self._excludes = [] for name, arcname in self.listFiles(path.abspath('')): if self.verbose: toPath = '=> %s%s' % (self.prefix, arcname) if self.prefix else "" print 'Compressing %s %s ...' % (arcname, toPath) add(name, arcname) output_archive.close()
def create(self, output_file): """ create(str output_file) -> None Creates the archive, written to the given output_file Filetype may be one of: gz, zip, bz2, tar, tgz """ # # determine the format # _, _, format = output_file.rpartition(".") format = format.lower() if format == 'zip': from zipfile import ZipFile, ZIP_DEFLATED output_archive = ZipFile(path.abspath(output_file), 'w') add = lambda name, arcname: output_archive.write(name, self.prefix + arcname, ZIP_DEFLATED) elif format in ['tar', 'bz2', 'gz', 'tgz']: import tarfile if format == 'tar': t_mode = 'w' elif format == 'tgz': t_mode = 'w:gz' else: t_mode = ('w:%s' % format) output_archive = tarfile.open(path.abspath(output_file), t_mode) add = lambda name, arcname: output_archive.add(name, self.prefix + arcname) else: raise RuntimeError("Unknown format: '%s'" % format) # # compress # # extra files first (we may change folder later) for name in self.extra: if self.verbose: toPath = '=> %s%s' % (self.prefix, name) if self.prefix else "" print 'Compressing %s %s ...' % (name, toPath) add(name, name) self._excludes = [] for name, arcname in self.listFiles(path.abspath('')): if self.verbose: toPath = '=> %s%s' % (self.prefix, arcname) if self.prefix else "" print 'Compressing %s %s ...' % (arcname, toPath) add(name, arcname) output_archive.close()
def _createZip(self, outputFile): """ Helper method to create a ZIP file. :param outputFile: The target location for the new zip file. :type outputFile: `FilePath` :return: `ZipFile` """ def zip_writer(dirpath, zippath): basedir = os.path.dirname(dirpath) + os.sep entry = ZipInfo() entry.compress_type = compression if os.path.isdir(dirpath): for root, dirs, files in os.walk(dirpath): if os.path.basename(root).startswith('.'): # skip hidden directories continue dirname = root.replace(basedir, '') for f in files: if f[-1] == '~' or f.startswith('.'): # skip backup files and all hidden files continue src = root + '/' + f entry = ZipInfo() entry.compress_type = compression entry.filename = dirname + '/' + f entry.date_time = localtime(os.path.getmtime(src))[:6] # hacky if dirname.startswith("html"): if self.source == True: entry.filename = dirname.replace('html', 'doc', 1) + "/" + f else: entry.filename = dirname.replace('html/', '', 1) + "/" + f entry.filename = entry.filename.replace('html/', '', 1) if entry.filename.startswith("examples"): entry.filename = "tutorials/" + entry.filename file_data = open( src, 'rb').read() self.package.writestr(entry, file_data) else: # top files entry.date_time = localtime(os.path.getmtime(dirpath))[:6] entry.filename = os.path.basename(zippath) file_data = open( dirpath, 'rb').read() self.package.writestr(entry, file_data) zipfile = ZipFile(outputFile.path, 'w') zipfile.add = zip_writer return zipfile
def write_tarball(folder, wd, name, version, files, format, verbose=False, clobber=False): """ Write a new tarball to the designated folder Also name, version, included files are passed folder: output tarball in this folder; a string object. wd: working directory, where the pkg.spec file is; a string object. format: "gz", "bz2", "tar" or "zip" to choose output format; a string object. """ formats = { "gz": (".tar.gz", "w:gz"), "bz2" : (".tar.bz2", "w:bz2"), "tar" : (".tar", "w:"), "zip" : (".zip", "w") } try: extension, compress_mode = formats[format] except KeyError: raise Exception("Error: No such format %s" % format) basename = "%s-%s%s" % (name, version, extension) out_file = path.join(folder, basename) if not clobber: if path.exists(out_file): raise Exception("Error: Output %s already exists!" % basename) if "zip" in format: from zipfile import ZipFile, ZIP_DEFLATED zip_file = ZipFile(out_file, mode=compress_mode, compression=ZIP_DEFLATED) context = (zip_file, wd, verbose) write_member = lambda abs, rel: write_zip_file(context, abs, rel) else: from tarfile import TarFile zip_file = TarFile.open(out_file, mode=compress_mode) write_member = lambda abs, rel: zip_file.add(abs, arcname=rel) print "Creating", basename for rel_path in files: if verbose: print "Writing", rel_path abs_path = path.join(wd, rel_path) write_member(abs_path, rel_path) zip_file.close()
def make_archive(path, data_to_archive): """ Create archive with certain data :param path: Path to archive file (ex: /home/user/archive.tar) :type path: pathlib.Path :param data_to_archive: list of dirs/files for archiving Example: data_to_archive = [ { 'from_path': '/home/mediasdk/openSource/build_scripts/root_dir/repos/MediaSDK/__cmake/intel64.make.release', 'relative': [ { 'path': '__bin', 'pack_as': 'bin' }, { 'path': '__lib', 'pack_as': 'lib' } ] }, { 'from_path': '/home/mediasdk/openSource/build_scripts/root_dir/repos/MediaSDK', 'relative': [ { 'path': 'tests' }, { 'path': 'CMakeLists.txt' }, ] } ] :type data_to_archive: List :return: None """ no_errors = True log = logging.getLogger('helper.make_archive') log.info('-' * 50) log.info('create archive %s', path) if path.suffix == '.tar': pkg = tarfile.open(path, "w") elif path.suffix == '.gz': pkg = tarfile.open(path, "w:gz", compresslevel=6) elif path.suffix == '.bz2': pkg = tarfile.open(path, "w:bz2") elif path.suffix == '.zip': pkg = ZipFile(path, 'w', compression=ZIP_DEFLATED) else: log.error("Extension %s is not supported", path.suffix) no_errors = False for info in data_to_archive: for relative in info['relative']: path_to_archive = info['from_path'] / relative['path'] pack_as = pathlib.Path(relative.get('pack_as', relative['path'])) log.info('add to archive %s, pack as "%s"', path_to_archive, pack_as) try: if path.suffix in ('.tar', '.gz'): pkg.add(path_to_archive, arcname=pack_as) elif path.suffix == '.zip': _zip_data(path_to_archive, pack_as, pkg) except: log.exception("Can not pack results") no_errors = False pkg.close() return no_errors
def archive_git(output_file, format='tar', repo_root='.', verbose=False): def git_files(repo_root=repo_root, exclude=True, verbose=False, prefix=''): excludes = [] for filepath in Popen( 'cd %s && git ls-files --cached --full-name --no-empty-directory' % (repo_root, ), shell=True, stdout=PIPE).stdout.read().splitlines(): filename = path.join(filepath, prefix) fullpath = path.join(repo_root, filepath) # right now every time we find a .gitattributes, we # overwrite the previous patterns. might be nice to # use a dictionary that retains the patterns on a # parent-path level. But this works fine for a top-level # file in the main repo and top level of submodules if exclude and filename == '.gitattributes': excludes = [] fh = open(filepath, 'r') for line in fh: if not line: break tokens = line.strip().split() if 'export-ignore' in tokens[1:]: excludes.append(tokens[0]) fh.close() if not filename.startswith('.git') and not path.isdir(filepath): # check the patterns first ignore = False for pattern in excludes: if fnmatch(filepath, pattern) or fnmatch( filename, pattern): if verbose: print 'Exclude pattern matched (%s): %s' % ( pattern, filepath) ignore = True break if ignore: continue # baselevel is needed to tell the arhiver where it have to extract file yield fullpath, filename # get paths for every submodule for submodule in Popen( "cd %s && git submodule --quiet foreach --recursive 'pwd'" % (repo_root, ), shell=True, stdout=PIPE).stdout.read().splitlines(): #chdir(submodule) # in order to get output path we need to exclude repository path from the submodule path prefix = submodule[len(repo_root) + 1:] # recursion allows us to process repositories with more than one level of submodules #for git_file in git_files(path.join(repo_root,submodule)): for git_file in git_files(submodule, prefix=prefix): yield git_file if format == 'zip': from zipfile import ZipFile, ZIP_DEFLATED output_archive = ZipFile(path.abspath(output_file), 'w') for name, arcname in git_files(): if verbose: print 'Compressing ' + arcname + '...' output_archive.write(name, prefix + arcname, ZIP_DEFLATED) elif format == 'tar': from tarfile import TarFile output_archive = TarFile(path.abspath(output_file), 'w') for name, arcname in git_files(): if verbose: print 'Compressing ' + arcname + '...' #output_archive.add(path.join(name), arcname) #output_archive.add(path.join(name)) output_archive.add(name, arcname)
def create(self, output_path, dry_run=False, output_format=None): """ Creates the archive, written to the given output_file_path Type of the archive is determined either by extension of output_file_path or by the format argument. Supported formats are: gz, zip, bz2, tar, tgz @type output_path: string @param output_path: Output file path. @type dry_run: bool @param dry_run: Determines whether create should do nothing but print what it would archive. @type output_format: string @param output_format: Determines format of the output archive. If None, format is determined from extension of output_file_path. """ if output_format is None: file_name, file_ext = path.splitext(output_path) output_format = file_ext[len(extsep):].lower() if output_format == 'zip': from zipfile import ZipFile, ZIP_DEFLATED if not dry_run: archive = ZipFile(path.abspath(output_path), 'w') add = lambda file_path, file_name: archive.write( file_path, path.join(self.prefix, file_name), ZIP_DEFLATED) elif output_format in ['tar', 'bz2', 'gz', 'tgz']: import tarfile if output_format == 'tar': t_mode = 'w' elif output_format == 'tgz': t_mode = 'w:gz' else: t_mode = 'w:{f}'.format(f=output_format) if not dry_run: archive = tarfile.open(path.abspath(output_path), t_mode) add = lambda file_path, file_name: archive.add( file_path, path.join(self.prefix, file_name)) else: raise RuntimeError("Unknown format: {f}".format(f=output_format)) for file_path in self.extra: if not dry_run: if self.verbose: print("Compressing {f} => {a}...".format(f=file_path, a=path.join( self.prefix, file_path))) add(file_path, file_path) else: print("{f} => {a}".format(f=file_path, a=path.join(self.prefix, file_path))) for file_path in self.list_files(): if not dry_run: if self.verbose: print("Compressing {f} => {a}...".format( f=path.join(self.main_repo_abspath, file_path), a=path.join(self.prefix, file_path))) add(path.join(self.main_repo_abspath, file_path), file_path) else: print("{f} => {a}".format(f=path.join(self.main_repo_abspath, file_path), a=path.join(self.prefix, file_path))) if not dry_run: archive.close()
def package(target, source, env): """Builder action for packaging the distribution archives.""" # Print out. print('') print("#######################") print("# Packaging the files #") print("#######################") # List of distribution files. type_list = [env['DIST_TYPE']] if type_list[0] == 'ALL': type_list = ['zip', 'tar'] # Loop over the distribution files. for dist_type in type_list: # The file name. if dist_type == 'zip': file = env['DIST_FILE'] + '.zip' elif dist_type == 'tar': file = env['DIST_FILE'] + '.tar.bz2' elif dist_type == 'dmg': file = env['DIST_FILE'] + '.dmg' # Print out. print("\n\nCreating the package distribution " + repr(file) + ".\n") # Create the special Mac OS X DMG file and then stop execution. if dist_type == 'dmg': # Create the Mac OS X universal application. print("\n# Creating the Mac OS X universal application.\n\n") cmd = '%s setup.py py2app' % sys.executable print("%s\n" % cmd) pipe = Popen(cmd, shell=True, stdin=PIPE, close_fds=False) waitpid(pipe.pid, 0) # Create the dmg image. print("\n\n# Creating the DMG image.\n\n") cmd = 'hdiutil create -ov -fs HFS+ -volname "relax" -srcfolder dist/relax.app ../%s' % file print("%s\n" % cmd) pipe = Popen(cmd, shell=True, stdin=PIPE, close_fds=False) waitpid(pipe.pid, 0) # Stop executing. return # Open the Zip distribution file. if dist_type == 'zip': archive = ZipFile(path.pardir + path.sep + file, 'w', compression=8) # Open the Tar distribution file. elif dist_type == 'tar': if search('.bz2$', file): archive = TarFile.bz2open(path.pardir + path.sep + file, 'w') elif search('.gz$', file): archive = TarFile.gzopen(path.pardir + path.sep + file, 'w') else: archive = TarFile.open(path.pardir + path.sep + file, 'w') # Base directory. base = getcwd() + sep # Find all files untracked by the VC and not ignored. untracked = [] if path.isdir(getcwd() + path.sep + ".git"): cmd = "git ls-files --others --exclude-standard" pipe = Popen(cmd, shell=True, stdout=PIPE, close_fds=False) for file_name in pipe.stdout.readlines(): untracked.append(file_name.strip()) # Walk through the directories. for root, dirs, files in walk(getcwd()): # Skip the version control directories. skip = False for vc in VERSION_CONTROL_DIRS: if search(vc, root): skip = True if skip: continue # Add the files in the current directory to the archive. for i in range(len(files)): # Skip all blacklisted files. skip = False for file_name in BLACKLISTED_FILES: if search(file_name, files[i]): skip = True # Create the file name (without the base directory). name = path.join(root, files[i]) name = name[len(base):] # Skip all untracked files. if name in untracked: skip = True # Nothing to do. if skip: continue # The archive file name. arcname = 'relax-' + version + path.sep + name print(arcname) # Zip archives. if dist_type == 'zip': archive.write(filename=name, arcname=arcname) # Tar archives. if dist_type == 'tar': archive.add(name=name, arcname=arcname) # Close the archive. archive.close() # Final printout. print("\n\n\n")
def archive_git(output_file,format='tar',repo_root='.', verbose=False): def git_files(repo_root=repo_root,exclude=True,verbose=False,prefix=''): excludes = [] for filepath in Popen('cd %s && git ls-files --cached --full-name --no-empty-directory'%(repo_root,), shell=True, stdout=PIPE).stdout.read().splitlines(): filename = path.join(filepath,prefix) fullpath = path.join(repo_root,filepath) # right now every time we find a .gitattributes, we # overwrite the previous patterns. might be nice to # use a dictionary that retains the patterns on a # parent-path level. But this works fine for a top-level # file in the main repo and top level of submodules if exclude and filename == '.gitattributes': excludes = [] fh = open(filepath, 'r') for line in fh: if not line: break tokens = line.strip().split() if 'export-ignore' in tokens[1:]: excludes.append(tokens[0]) fh.close() if not filename.startswith('.git') and not path.isdir(filepath): # check the patterns first ignore = False for pattern in excludes: if fnmatch(filepath, pattern) or fnmatch(filename, pattern): if verbose: print 'Exclude pattern matched (%s): %s' % (pattern, filepath) ignore = True break if ignore: continue # baselevel is needed to tell the arhiver where it have to extract file yield fullpath,filename # get paths for every submodule for submodule in Popen("cd %s && git submodule --quiet foreach --recursive 'pwd'"%(repo_root,), shell=True, stdout=PIPE).stdout.read().splitlines(): #chdir(submodule) # in order to get output path we need to exclude repository path from the submodule path prefix = submodule[len(repo_root)+1:] # recursion allows us to process repositories with more than one level of submodules #for git_file in git_files(path.join(repo_root,submodule)): for git_file in git_files(submodule,prefix=prefix): yield git_file if format == 'zip': from zipfile import ZipFile, ZIP_DEFLATED output_archive = ZipFile(path.abspath(output_file), 'w') for name, arcname in git_files(): if verbose: print 'Compressing ' + arcname + '...' output_archive.write(name, prefix + arcname, ZIP_DEFLATED) elif format == 'tar': from tarfile import TarFile output_archive = TarFile(path.abspath(output_file), 'w') for name, arcname in git_files(): if verbose: print 'Compressing ' + arcname + '...' #output_archive.add(path.join(name), arcname) #output_archive.add(path.join(name)) output_archive.add(name,arcname)
def package(target, source, env): """Builder action for packaging the distribution archives.""" # Print out. print('') print("#######################") print("# Packaging the files #") print("#######################") # List of distribution files. type_list = [env['DIST_TYPE']] if type_list[0] == 'ALL': type_list = ['zip', 'tar'] # Loop over the distribution files. for dist_type in type_list: # The file name. if dist_type == 'zip': file = env['DIST_FILE'] + '.zip' elif dist_type == 'tar': file = env['DIST_FILE'] + '.tar.bz2' elif dist_type == 'dmg': file = env['DIST_FILE'] + '.dmg' # Print out. print("\n\nCreating the package distribution " + repr(file) + ".\n") # Create the special Mac OS X DMG file and then stop execution. if dist_type == 'dmg': # Create the Mac OS X universal application. print("\n# Creating the Mac OS X universal application.\n\n") cmd = '%s setup.py py2app' % sys.executable print("%s\n" % cmd) pipe = Popen(cmd, shell=True, stdin=PIPE, close_fds=False) waitpid(pipe.pid, 0) # Create the dmg image. print("\n\n# Creating the DMG image.\n\n") cmd = 'hdiutil create -ov -fs HFS+ -volname "relax" -srcfolder dist/relax.app ../%s' % file print("%s\n" % cmd) pipe = Popen(cmd, shell=True, stdin=PIPE, close_fds=False) waitpid(pipe.pid, 0) # Stop executing. return # Open the Zip distribution file. if dist_type == 'zip': archive = ZipFile(path.pardir + path.sep + file, 'w', compression=8) # Open the Tar distribution file. elif dist_type == 'tar': if search('.bz2$', file): archive = TarFile.bz2open(path.pardir + path.sep + file, 'w') elif search('.gz$', file): archive = TarFile.gzopen(path.pardir + path.sep + file, 'w') else: archive = TarFile.open(path.pardir + path.sep + file, 'w') # Base directory. base = getcwd() + sep # Walk through the directories. for root, dirs, files in walk(getcwd()): # Skip the subversion directories. if search("\.svn", root): continue # Add the files in the current directory to the archive. for i in range(len(files)): # Skip any '.sconsign' files, hidden files, byte-compiled '*.pyc' files, or binary objects '.o', '.os', 'obj', 'lib', and 'exp'. if search("\.sconsign", files[i]) or search("^\.", files[i]) or search("\.pyc$", files[i]) or search("\.o$", files[i]) or search("\.os$", files[i]) or search("\.obj$", files[i]) or search("\.lib$", files[i]) or search("\.exp$", files[i]): continue # Create the file name (without the base directory). name = path.join(root, files[i]) name = name[len(base):] print('relax-' + version + path.sep + name) # The archive file name. arcname = 'relax-' + version + path.sep + name # Zip archives. if dist_type == 'zip': archive.write(filename=name, arcname=arcname) # Tar archives. if dist_type == 'tar': archive.add(name=name, arcname=arcname) # Close the archive. archive.close() # Final printout. print("\n\n\n")
def create(self, output_path, dry_run=False, output_format=None): """ Create the archive at output_file_path. Type of the archive is determined either by extension of output_file_path or by output_format. Supported formats are: gz, zip, bz2, tar, tgz @param output_path: Output file path. @type output_path: string @param dry_run: Determines whether create should do nothing but print what it would archive. @type dry_run: bool @param output_format: Determines format of the output archive. If None, format is determined from extension of output_file_path. @type output_format: string """ if output_format is None: file_name, file_ext = path.splitext(output_path) output_format = file_ext[len(extsep):].lower() self.LOG.debug( "Output format is not explicitly set, determined format is {0}." .format(output_format)) if not dry_run: if output_format == 'zip': archive = ZipFile(path.abspath(output_path), 'w') def add_file(file_path, arcname): if not path.islink(file_path): archive.write(file_path, arcname, ZIP_DEFLATED) else: i = ZipInfo(arcname) i.create_system = 3 i.external_attr = 0xA1ED0000 archive.writestr(i, readlink(file_path)) elif output_format in ['tar', 'bz2', 'gz', 'tgz']: if output_format == 'tar': t_mode = 'w' elif output_format == 'tgz': t_mode = 'w:gz' else: t_mode = 'w:{0}'.format(output_format) archive = tarfile.open(path.abspath(output_path), t_mode) add_file = lambda file_path, arcname: archive.add( file_path, arcname) else: raise RuntimeError("Unknown format: {0}".format(output_format)) def archiver(file_path, arcname): self.LOG.debug("Compressing {0} => {1}...".format( file_path, arcname)) add_file(file_path, arcname) else: archive = None archiver = lambda file_path, arcname: self.LOG.info( "{0} => {1}".format(file_path, arcname)) self.archive_all_files(archiver) if archive is not None: archive.close()
def package(target, source, env): """Builder action for packaging the distribution archives.""" # Print out. print('') print("#######################") print("# Packaging the files #") print("#######################") # List of distribution files. type_list = [env['DIST_TYPE']] if type_list[0] == 'ALL': type_list = ['zip', 'tar'] # Loop over the distribution files. for dist_type in type_list: # The file name. if dist_type == 'zip': file = env['DIST_FILE'] + '.zip' elif dist_type == 'tar': file = env['DIST_FILE'] + '.tar.bz2' elif dist_type == 'dmg': file = env['DIST_FILE'] + '.dmg' # Print out. print("\n\nCreating the package distribution " + repr(file) + ".\n") # Create the special Mac OS X DMG file and then stop execution. if dist_type == 'dmg': # Create the Mac OS X universal application. print("\n# Creating the Mac OS X universal application.\n\n") cmd = '%s setup.py py2app' % sys.executable print("%s\n" % cmd) pipe = Popen(cmd, shell=True, stdin=PIPE, close_fds=False) waitpid(pipe.pid, 0) # Create the dmg image. print("\n\n# Creating the DMG image.\n\n") cmd = 'hdiutil create -ov -fs HFS+ -volname "relax" -srcfolder dist/relax.app ../%s' % file print("%s\n" % cmd) pipe = Popen(cmd, shell=True, stdin=PIPE, close_fds=False) waitpid(pipe.pid, 0) # Stop executing. return # Open the Zip distribution file. if dist_type == 'zip': archive = ZipFile(path.pardir + path.sep + file, 'w', compression=8) # Open the Tar distribution file. elif dist_type == 'tar': if search('.bz2$', file): archive = TarFile.bz2open(path.pardir + path.sep + file, 'w') elif search('.gz$', file): archive = TarFile.gzopen(path.pardir + path.sep + file, 'w') else: archive = TarFile.open(path.pardir + path.sep + file, 'w') # Base directory. base = getcwd() + sep # Walk through the directories. for root, dirs, files in walk(getcwd()): # Skip the subversion directories. if search("\.svn", root): continue # Add the files in the current directory to the archive. for i in range(len(files)): # Skip any '.sconsign' files, hidden files, byte-compiled '*.pyc' files, or binary objects '.o', '.os', 'obj', 'lib', and 'exp'. if search("\.sconsign", files[i]) or search("^\.", files[i]) or search( "\.pyc$", files[i]) or search( "\.o$", files[i]) or search( "\.os$", files[i]) or search( "\.obj$", files[i]) or search( "\.lib$", files[i]) or search( "\.exp$", files[i]): continue # Create the file name (without the base directory). name = path.join(root, files[i]) name = name[len(base):] print('relax-' + version + path.sep + name) # The archive file name. arcname = 'relax-' + version + path.sep + name # Zip archives. if dist_type == 'zip': archive.write(filename=name, arcname=arcname) # Tar archives. if dist_type == 'tar': archive.add(name=name, arcname=arcname) # Close the archive. archive.close() # Final printout. print("\n\n\n")