254 lines
9.3 KiB
Python
254 lines
9.3 KiB
Python
#!/usr/bin/python
|
|
# -*- coding: iso-8859-1 -*-
|
|
# Copyright (C) 2010-2015 Bastian Kleineidam
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
"""
|
|
Setup file for the distuils module.
|
|
"""
|
|
from __future__ import print_function
|
|
import sys
|
|
if not hasattr(sys, "version_info") or sys.version_info < (2, 7, 0, "final", 0):
|
|
raise SystemExit("This program requires Python 2.7 or later.")
|
|
import os
|
|
import re
|
|
import shutil
|
|
import glob
|
|
import subprocess
|
|
from setuptools import setup
|
|
from distutils.core import Distribution
|
|
from distutils.command.install_lib import install_lib
|
|
from distutils import util
|
|
from distutils.file_util import write_file
|
|
|
|
AppName = "patool"
|
|
AppVersion = "1.9"
|
|
MyName = "Bastian Kleineidam"
|
|
MyEmail = "bastian.kleineidam@web.de"
|
|
|
|
|
|
def normpath (path):
|
|
"""Norm a path name to platform specific notation."""
|
|
return os.path.normpath(path)
|
|
|
|
|
|
def cnormpath (path):
|
|
"""Norm a path name to platform specific notation and make it absolute."""
|
|
path = normpath(path)
|
|
if os.name == 'nt':
|
|
# replace slashes with backslashes
|
|
path = path.replace("/", "\\")
|
|
if not os.path.isabs(path):
|
|
path = normpath(os.path.join(sys.prefix, path))
|
|
return path
|
|
|
|
|
|
release_ro = re.compile(r"\(released (.+)\)")
|
|
def get_release_date ():
|
|
"""Parse and return relase date as string from doc/changelog.txt."""
|
|
fname = os.path.join("doc", "changelog.txt")
|
|
release_date = "unknown"
|
|
with open(fname) as fd:
|
|
# the release date is on the first line
|
|
line = fd.readline()
|
|
mo = release_ro.search(line)
|
|
if mo:
|
|
release_date = mo.groups(1)
|
|
return release_date
|
|
|
|
|
|
data_files = []
|
|
if os.name == 'nt':
|
|
data_files.append(('share', ['doc/patool.txt']))
|
|
else:
|
|
data_files.append(('share/man/man1', ['doc/patool.1']))
|
|
|
|
|
|
def get_nt_platform_vars ():
|
|
"""Return program file path and architecture for NT systems."""
|
|
platform = util.get_platform()
|
|
if platform == "win-amd64":
|
|
# the Visual C++ runtime files are installed in the x86 directory
|
|
progvar = "%ProgramFiles(x86)%"
|
|
architecture = "amd64"
|
|
elif platform == "win32":
|
|
progvar = "%ProgramFiles%"
|
|
architecture = "x86"
|
|
else:
|
|
raise ValueError("Unsupported platform %r" % platform)
|
|
return os.path.expandvars(progvar), architecture
|
|
|
|
|
|
class MyInstallLib (install_lib, object):
|
|
"""Custom library installation."""
|
|
|
|
def install (self):
|
|
"""Install the generated config file."""
|
|
outs = super(MyInstallLib, self).install()
|
|
infile = self.create_conf_file()
|
|
outfile = os.path.join(self.install_dir, os.path.basename(infile))
|
|
self.copy_file(infile, outfile)
|
|
outs.append(outfile)
|
|
return outs
|
|
|
|
def create_conf_file (self):
|
|
"""Create configuration file."""
|
|
cmd_obj = self.distribution.get_command_obj("install")
|
|
cmd_obj.ensure_finalized()
|
|
# we have to write a configuration file because we need the
|
|
# <install_data> directory (and other stuff like author, url, ...)
|
|
# all paths are made absolute by cnormpath()
|
|
data = []
|
|
for d in ['purelib', 'platlib', 'lib', 'headers', 'scripts', 'data']:
|
|
attr = 'install_%s' % d
|
|
if cmd_obj.root:
|
|
# cut off root path prefix
|
|
cutoff = len(cmd_obj.root)
|
|
# don't strip the path separator
|
|
if cmd_obj.root.endswith(os.sep):
|
|
cutoff -= 1
|
|
val = getattr(cmd_obj, attr)[cutoff:]
|
|
else:
|
|
val = getattr(cmd_obj, attr)
|
|
if attr == 'install_data':
|
|
cdir = os.path.join(val, "share", AppName)
|
|
data.append('config_dir = %r' % cnormpath(cdir))
|
|
elif attr == 'install_lib':
|
|
if cmd_obj.root:
|
|
_drive, tail = os.path.splitdrive(val)
|
|
if tail.startswith(os.sep):
|
|
tail = tail[1:]
|
|
self.install_lib = os.path.join(cmd_obj.root, tail)
|
|
else:
|
|
self.install_lib = val
|
|
data.append("%s = %r" % (attr, cnormpath(val)))
|
|
self.distribution.create_conf_file(data, directory=self.install_lib)
|
|
return self.get_conf_output()
|
|
|
|
def get_conf_output (self):
|
|
"""Get filename for distribution configuration file."""
|
|
return self.distribution.get_conf_filename(self.install_lib)
|
|
|
|
def get_outputs (self):
|
|
"""Add the generated config file to the list of outputs."""
|
|
outs = super(MyInstallLib, self).get_outputs()
|
|
conf_output = self.get_conf_output()
|
|
outs.append(conf_output)
|
|
if self.compile:
|
|
outs.extend(self._bytecode_filenames([conf_output]))
|
|
return outs
|
|
|
|
|
|
class MyDistribution (Distribution, object):
|
|
"""Custom distribution class generating config file."""
|
|
|
|
def __init__ (self, attrs):
|
|
"""Set console and windows scripts."""
|
|
super(MyDistribution, self).__init__(attrs)
|
|
self.console = ['patool']
|
|
|
|
def run_commands (self):
|
|
"""Generate config file and run commands."""
|
|
cwd = os.getcwd()
|
|
data = []
|
|
data.append('config_dir = %r' % os.path.join(cwd, "config"))
|
|
data.append("install_data = %r" % cwd)
|
|
data.append("install_scripts = %r" % cwd)
|
|
self.create_conf_file(data)
|
|
super(MyDistribution, self).run_commands()
|
|
|
|
def get_conf_filename (self, directory):
|
|
"""Get name for config file."""
|
|
return os.path.join(directory, "_%s_configdata.py" % self.get_name())
|
|
|
|
def create_conf_file (self, data, directory=None):
|
|
"""Create local config file from given data (list of lines) in
|
|
the directory (or current directory if not given)."""
|
|
data.insert(0, "# this file is automatically created by setup.py")
|
|
data.insert(0, "# -*- coding: iso-8859-1 -*-")
|
|
if directory is None:
|
|
directory = os.getcwd()
|
|
filename = self.get_conf_filename(directory)
|
|
# add metadata
|
|
metanames = ("name", "version", "author", "author_email",
|
|
"maintainer", "maintainer_email", "url",
|
|
"license", "description", "long_description",
|
|
"keywords", "platforms", "fullname", "contact",
|
|
"contact_email")
|
|
for name in metanames:
|
|
method = "get_" + name
|
|
val = getattr(self.metadata, method)()
|
|
data.append("%s = %r" % (name, val))
|
|
data.append('release_date = "%s"' % get_release_date())
|
|
# write the config file
|
|
util.execute(write_file, (filename, data),
|
|
"creating %s" % filename, self.verbose >= 1, self.dry_run)
|
|
|
|
|
|
args = dict(
|
|
name = AppName,
|
|
version = AppVersion,
|
|
description = "portable archive file manager",
|
|
long_description = """Various archive formats can be created, extracted, tested, listed,
|
|
searched, compared and repacked by patool. The advantage of patool
|
|
is its simplicity in handling archive files without having to remember
|
|
a myriad of programs and options.
|
|
|
|
The archive format is determined by the file(1) program and as a
|
|
fallback by the archive file extension.
|
|
|
|
patool supports 7z (.7z), ACE (.ace), ADF (.adf), ALZIP (.alz), APE (.ape),
|
|
AR (.a), ARC (.arc), ARJ (.arj), BZIP2 (.bz2),
|
|
CAB (.cab), COMPRESS (.Z), CPIO (.cpio),
|
|
DEB (.deb), DMS (.dms), FLAC (.flac), GZIP (.gz), ISO (.iso), LRZIP (.lrz),
|
|
LZH (.lha, .lzh), LZIP (.lz), LZMA (.lzma), LZOP (.lzo), RPM (.rpm),
|
|
RAR (.rar), RZIP (.rz), SHN (.shn), TAR (.tar), XZ (.xz), ZIP (.zip, .jar),
|
|
ZOO (.zoo) and ZPAQ (.zpaq) formats.
|
|
It relies on helper applications to handle those archive formats
|
|
(for example bzip2 for BZIP2 archives).
|
|
|
|
The archive formats TAR, ZIP, BZIP2 and GZIP
|
|
are supported natively and do not require helper applications to be
|
|
installed.
|
|
""",
|
|
author = MyName,
|
|
author_email = MyEmail,
|
|
maintainer = MyName,
|
|
maintainer_email = MyEmail,
|
|
license = "GPL",
|
|
url = "http://wummel.github.io/patool/",
|
|
packages = ['patoolib', 'patoolib.programs'],
|
|
data_files = data_files,
|
|
scripts = ['patool'],
|
|
keywords = "archiver,archive,compression,commandline,manager",
|
|
classifiers = [
|
|
'Environment :: Console',
|
|
'Topic :: System :: Archiving',
|
|
'Development Status :: 5 - Production/Stable',
|
|
'License :: OSI Approved :: GNU General Public License (GPL)',
|
|
'Programming Language :: Python :: 2',
|
|
'Programming Language :: Python :: 2.7',
|
|
'Programming Language :: Python :: 3',
|
|
'Programming Language :: Python :: 3.3',
|
|
'Programming Language :: Python :: 3.4',
|
|
'Programming Language :: Python :: 3.5',
|
|
'Operating System :: OS Independent',
|
|
],
|
|
distclass = MyDistribution,
|
|
cmdclass = {
|
|
'install_lib': MyInstallLib,
|
|
},
|
|
)
|
|
setup(**args)
|