mirror of
https://github.com/fergalmoran/picard.git
synced 2025-12-24 02:09:56 +00:00
2e275ca16b
Update po/README.md so the actual value isn't written, if we change the default value it will be only at once place.
606 lines
21 KiB
Python
Executable File
606 lines
21 KiB
Python
Executable File
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
import glob
|
|
import os
|
|
import re
|
|
import sys
|
|
import subprocess
|
|
from StringIO import StringIO
|
|
from ConfigParser import RawConfigParser
|
|
from picard import __version__
|
|
|
|
|
|
if sys.version_info < (2, 6):
|
|
print "*** You need Python 2.6 or higher to use Picard."
|
|
|
|
TXPULL_CMD = 'tx pull'
|
|
args = {}
|
|
|
|
|
|
try:
|
|
from py2app.build_app import py2app
|
|
do_py2app = True
|
|
args['app'] = ['tagger.py']
|
|
args['name'] = 'Picard'
|
|
args['options'] = { 'py2app' :
|
|
{
|
|
'optimize' : 2,
|
|
'argv_emulation' : True,
|
|
'iconfile' : 'picard.icns',
|
|
'frameworks' : ['libiconv.2.dylib', 'libdiscid.0.dylib'],
|
|
'resources' : ['locale'],
|
|
'includes' : ['json', 'sip', 'PyQt4', 'picard.util.astrcmp'],
|
|
'excludes' : ['pydoc', 'PyQt4.QtDeclarative', 'PyQt4.QtDesigner', 'PyQt4.QtHelp', 'PyQt4.QtMultimedia',
|
|
'PyQt4.QtOpenGL', 'PyQt4.QtScript', 'PyQt4.QtScriptTools', 'PyQt4.QtSql', 'PyQt4.QtSvg',
|
|
'PyQt4.QtTest', 'PyQt4.QtWebKit', 'PyQt4.QtXml', 'PyQt4.QtXmlPatterns', 'PyQt4.phonon'],
|
|
'plist' : { 'CFBundleName' : 'MusicBrainz Picard',
|
|
'CFBundleGetInfoString' : 'Picard, the next generation MusicBrainz tagger (see http://musicbrainz.org/doc/MusicBrainz_Picard)',
|
|
'CFBundleIdentifier':'org.musicbrainz.picard',
|
|
'CFBundleShortVersionString':__version__,
|
|
'CFBundleVersion': 'Picard ' + __version__,
|
|
'LSMinimumSystemVersion':'10.4.3',
|
|
'LSMultipleInstancesProhibited':'true',
|
|
# RAK: It biffed when I tried to include your accented characters, luks. :-(
|
|
'NSHumanReadableCopyright':'Copyright 2008 Lukas Lalinsky, Robert Kaye',
|
|
},
|
|
'qt_plugins': ['imageformats/libqgif.dylib',
|
|
'imageformats/libqjpeg.dylib',
|
|
'imageformats/libqtiff.dylib',
|
|
'accessible/libqtaccessiblewidgets.dylib']
|
|
},
|
|
}
|
|
|
|
except ImportError:
|
|
do_py2app = False
|
|
|
|
# this must be imported *after* py2app, because py2app imports setuptools
|
|
# which "patches" (read: screws up) the Extension class
|
|
from distutils import log
|
|
from distutils.command.build import build
|
|
from distutils.command.install import install as install
|
|
from distutils.core import setup, Command, Extension
|
|
from distutils.dep_util import newer
|
|
from distutils.dist import Distribution
|
|
|
|
|
|
ext_modules = [
|
|
Extension('picard.util.astrcmp', sources=['picard/util/astrcmp.c']),
|
|
]
|
|
|
|
def _exit_with_error(msg, code=1):
|
|
log.error("%s (code=%d)" % (msg, code))
|
|
raise SystemExit(code)
|
|
|
|
|
|
class picard_test(Command):
|
|
description = "run automated tests"
|
|
user_options = [
|
|
("tests=", None, "list of tests to run (default all)"),
|
|
("verbosity=", "v", "verbosity"),
|
|
]
|
|
|
|
def initialize_options(self):
|
|
self.tests = []
|
|
self.verbosity = 1
|
|
|
|
def finalize_options(self):
|
|
if self.tests:
|
|
self.tests = self.tests.split(",")
|
|
if self.verbosity:
|
|
self.verbosity = int(self.verbosity)
|
|
|
|
def run(self):
|
|
import unittest
|
|
|
|
names = []
|
|
for filename in glob.glob("test/test_*.py"):
|
|
name = os.path.splitext(os.path.basename(filename))[0]
|
|
if not self.tests or name in self.tests:
|
|
names.append("test." + name)
|
|
|
|
tests = unittest.defaultTestLoader.loadTestsFromNames(names)
|
|
t = unittest.TextTestRunner(verbosity=self.verbosity)
|
|
testresult = t.run(tests)
|
|
if not testresult.wasSuccessful():
|
|
raise SystemExit("At least one test failed.")
|
|
|
|
|
|
class picard_build_locales(Command):
|
|
description = 'build locale files'
|
|
user_options = [
|
|
('build-dir=', 'd', "directory to build to"),
|
|
('inplace', 'i', "ignore build-lib and put compiled locales into the 'locale' directory"),
|
|
]
|
|
|
|
def initialize_options(self):
|
|
self.build_dir = None
|
|
self.inplace = 0
|
|
|
|
def finalize_options(self):
|
|
self.set_undefined_options('build', ('build_locales', 'build_dir'))
|
|
self.locales = self.distribution.locales
|
|
|
|
def run(self):
|
|
for domain, locale, po in self.locales:
|
|
if self.inplace:
|
|
path = os.path.join('locale', locale, 'LC_MESSAGES')
|
|
else:
|
|
path = os.path.join(self.build_dir, locale, 'LC_MESSAGES')
|
|
mo = os.path.join(path, '%s.mo' % domain)
|
|
self.mkpath(path)
|
|
self.spawn(['msgfmt', '-o', mo, po])
|
|
|
|
Distribution.locales = None
|
|
|
|
|
|
class picard_install_locales(Command):
|
|
description = "install locale files"
|
|
user_options = [
|
|
('install-dir=', 'd', "directory to install locale files to"),
|
|
('build-dir=', 'b', "build directory (where to install from)"),
|
|
('force', 'f', "force installation (overwrite existing files)"),
|
|
('skip-build', None, "skip the build steps"),
|
|
]
|
|
boolean_options = ['force', 'skip-build']
|
|
|
|
def initialize_options(self):
|
|
self.install_dir = None
|
|
self.build_dir = None
|
|
self.force = 0
|
|
self.skip_build = None
|
|
self.outfiles = []
|
|
|
|
def finalize_options(self):
|
|
self.set_undefined_options('build', ('build_locales', 'build_dir'))
|
|
self.set_undefined_options('install',
|
|
('install_locales', 'install_dir'),
|
|
('force', 'force'),
|
|
('skip_build', 'skip_build'),
|
|
)
|
|
|
|
def run(self):
|
|
if not self.skip_build:
|
|
self.run_command('build_locales')
|
|
self.outfiles = self.copy_tree(self.build_dir, self.install_dir)
|
|
|
|
def get_inputs(self):
|
|
return self.locales or []
|
|
|
|
def get_outputs(self):
|
|
return self.outfiles
|
|
|
|
|
|
class picard_install(install):
|
|
|
|
user_options = install.user_options + [
|
|
('install-locales=', None,
|
|
"installation directory for locales"),
|
|
('localedir=', None, ''),
|
|
('disable-autoupdate', None, ''),
|
|
('disable-locales', None, ''),
|
|
]
|
|
|
|
sub_commands = install.sub_commands
|
|
|
|
def initialize_options(self):
|
|
install.initialize_options(self)
|
|
self.install_locales = None
|
|
self.localedir = None
|
|
self.disable_autoupdate = None
|
|
self.disable_locales = None
|
|
|
|
def finalize_options(self):
|
|
install.finalize_options(self)
|
|
if self.install_locales is None:
|
|
self.install_locales = '$base/share/locale'
|
|
self._expand_attrs(['install_locales'])
|
|
self.install_locales = os.path.normpath(self.install_locales)
|
|
self.localedir = self.install_locales
|
|
# can't use set_undefined_options :/
|
|
self.distribution.get_command_obj('build').localedir = self.localedir
|
|
self.distribution.get_command_obj('build').disable_autoupdate = self.disable_autoupdate
|
|
if self.root is not None:
|
|
self.change_roots('locales')
|
|
if self.disable_locales is None:
|
|
self.sub_commands.append(('install_locales', None))
|
|
|
|
def run(self):
|
|
install.run(self)
|
|
|
|
|
|
class picard_build(build):
|
|
|
|
user_options = build.user_options + [
|
|
('build-locales=', 'd', "build directory for locale files"),
|
|
('localedir=', None, ''),
|
|
('disable-autoupdate', None, ''),
|
|
('disable-locales', None, ''),
|
|
]
|
|
|
|
sub_commands = build.sub_commands
|
|
|
|
def initialize_options(self):
|
|
build.initialize_options(self)
|
|
self.build_locales = None
|
|
self.localedir = None
|
|
self.disable_autoupdate = None
|
|
self.disable_locales = None
|
|
|
|
def finalize_options(self):
|
|
build.finalize_options(self)
|
|
if self.build_locales is None:
|
|
self.build_locales = os.path.join(self.build_base, 'locale')
|
|
if self.localedir is None:
|
|
self.localedir = '/usr/share/locale'
|
|
if self.disable_autoupdate is None:
|
|
self.disable_autoupdate = False
|
|
if self.disable_locales is None:
|
|
self.sub_commands.append(('build_locales', None))
|
|
|
|
def run(self):
|
|
if 'bdist_nsis' not in sys.argv: # somebody shoot me please
|
|
log.info('generating scripts/picard from scripts/picard.in')
|
|
generate_file('scripts/picard.in', 'scripts/picard', {'localedir': self.localedir, 'autoupdate': not self.disable_autoupdate})
|
|
build.run(self)
|
|
|
|
|
|
class picard_build_ui(Command):
|
|
description = "build Qt UI files and resources"
|
|
user_options = []
|
|
|
|
def initialize_options(self):
|
|
pass
|
|
|
|
def finalize_options(self):
|
|
pass
|
|
|
|
def run(self):
|
|
from PyQt4 import uic
|
|
_translate_re = (
|
|
re.compile(
|
|
r'QtGui\.QApplication.translate\(.*?, (.*?), None, '
|
|
r'QtGui\.QApplication\.UnicodeUTF8\)'),
|
|
re.compile(
|
|
r'\b_translate\(.*?, (.*?), None\)')
|
|
)
|
|
|
|
for uifile in glob.glob("ui/*.ui"):
|
|
pyfile = "ui_%s.py" % os.path.splitext(os.path.basename(uifile))[0]
|
|
pyfile = os.path.join("picard", "ui", pyfile)
|
|
if newer(uifile, pyfile):
|
|
log.info("compiling %s -> %s", uifile, pyfile)
|
|
tmp = StringIO()
|
|
uic.compileUi(uifile, tmp)
|
|
source = tmp.getvalue()
|
|
for r in list(_translate_re):
|
|
source = r.sub(r'_(\1)', source)
|
|
f = open(pyfile, "w")
|
|
f.write(source)
|
|
f.close()
|
|
from resources import compile, makeqrc
|
|
makeqrc.main()
|
|
compile.main()
|
|
|
|
|
|
class picard_clean_ui(Command):
|
|
description = "clean up compiled Qt UI files and resources"
|
|
user_options = []
|
|
|
|
def initialize_options(self):
|
|
pass
|
|
|
|
def finalize_options(self):
|
|
pass
|
|
|
|
def run(self):
|
|
from PyQt4 import uic
|
|
for uifile in glob.glob("ui/*.ui"):
|
|
pyfile = "ui_%s.py" % os.path.splitext(os.path.basename(uifile))[0]
|
|
pyfile = os.path.join("picard", "ui", pyfile)
|
|
try:
|
|
os.unlink(pyfile)
|
|
log.info("removing %s", pyfile)
|
|
except OSError:
|
|
log.warn("'%s' does not exist -- can't clean it", pyfile)
|
|
pyfile = os.path.join("picard", "resources.py")
|
|
try:
|
|
os.unlink(pyfile)
|
|
log.info("removing %s", pyfile)
|
|
except OSError:
|
|
log.warn("'%s' does not exist -- can't clean it", pyfile)
|
|
|
|
|
|
class picard_get_po_files(Command):
|
|
description = "Retrieve po files from transifex"
|
|
minimum_perc_default = 5
|
|
user_options = [
|
|
('minimum-perc=', 'm',
|
|
"Specify the minimum acceptable percentage of a translation (default: %d)" % minimum_perc_default)
|
|
]
|
|
|
|
def initialize_options(self):
|
|
self.minimum_perc = self.minimum_perc_default
|
|
|
|
def finalize_options(self):
|
|
self.minimum_perc = int(self.minimum_perc)
|
|
|
|
def run(self):
|
|
txpull_cmd = " ".join([
|
|
TXPULL_CMD,
|
|
'--force',
|
|
'--all',
|
|
'--minimum-perc=%d' % self.minimum_perc
|
|
])
|
|
log.info("Running %s" % txpull_cmd)
|
|
retcode = subprocess.call(txpull_cmd, shell=True)
|
|
if retcode:
|
|
_exit_with_error("Failed to update po files", retcode)
|
|
|
|
|
|
_regen_pot_description = "Regenerate po/picard.pot, parsing source tree for new or updated strings"
|
|
try:
|
|
from babel.messages import frontend as babel
|
|
|
|
class picard_regen_pot_file(babel.extract_messages):
|
|
description = _regen_pot_description
|
|
|
|
def initialize_options(self):
|
|
# cannot use super() with old-style parent class
|
|
babel.extract_messages.initialize_options(self)
|
|
self.output_file = 'po/picard.pot'
|
|
self.input_dirs = 'contrib, picard'
|
|
|
|
except ImportError:
|
|
class picard_regen_pot_file(Command):
|
|
description = _regen_pot_description
|
|
user_options = []
|
|
|
|
def initialize_options(self):
|
|
pass
|
|
|
|
def finalize_options(self):
|
|
pass
|
|
|
|
def run(self):
|
|
_exit_with_error("Babel is required to use this command (see po/README.md)")
|
|
|
|
|
|
class picard_update_countries(Command):
|
|
description = "Regenerate countries.py and update related translations"
|
|
user_options = [
|
|
('skip-pull', None, "skip the tx pull steps"),
|
|
]
|
|
boolean_options = ['skip-pull']
|
|
|
|
def initialize_options(self):
|
|
self.skip_pull = None
|
|
|
|
def finalize_options(self):
|
|
self.locales = self.distribution.locales
|
|
|
|
def run(self):
|
|
from babel.messages import pofile
|
|
|
|
country_list = []
|
|
if not self.skip_pull:
|
|
txpull_cmd = " ".join([
|
|
TXPULL_CMD,
|
|
'--force',
|
|
'--resource=musicbrainz.countries',
|
|
'--source',
|
|
'--language=none',
|
|
])
|
|
log.info("Running %s" % txpull_cmd)
|
|
retcode = subprocess.call(txpull_cmd, shell=True)
|
|
if retcode:
|
|
log.error("Failed to update countries (retcode=%d)" % (retcode))
|
|
|
|
relpath = None
|
|
for domain, locale, po in self.locales:
|
|
if domain == 'picard-countries':
|
|
relpath = os.path.dirname(po)
|
|
break
|
|
if relpath is not None:
|
|
potfile = os.path.join(relpath, 'countries.pot')
|
|
isocode_comment = u'iso.code:'
|
|
if os.path.isfile(potfile):
|
|
log.info('Parsing %s' % potfile)
|
|
with open(potfile, 'rb') as f:
|
|
po = pofile.read_po(f)
|
|
for message in po:
|
|
if not message.id or not isinstance(message.id, unicode):
|
|
continue
|
|
for comment in message.auto_comments:
|
|
if comment.startswith(isocode_comment):
|
|
code = comment.replace(isocode_comment, u'')
|
|
country = message.id
|
|
country_list.append((code, country))
|
|
if country_list:
|
|
self.countries_py_file(sorted(country_list))
|
|
if not country_list:
|
|
log.warn("Failed to extract any country code/name !")
|
|
|
|
def countries_py_file(self, country_list, filename="picard/countries.py"):
|
|
header = (u"# -*- coding: utf-8 -*-\n"
|
|
u"# Automatically generated - don't edit.\n"
|
|
u"# Use `python setup.py update_countries` to update it.\n"
|
|
u"\n"
|
|
u"RELEASE_COUNTRIES = {\n")
|
|
line = u" u'{code}': u'{name}',\n"
|
|
footer = u"}\n"
|
|
with open(filename, 'w') as countries_py:
|
|
def write_utf8(s):
|
|
countries_py.write(s.encode('utf-8'))
|
|
write_utf8(header)
|
|
for code, name in country_list:
|
|
write_utf8(
|
|
line.format(
|
|
code=code,
|
|
name=name.replace("'", "\\'")
|
|
)
|
|
)
|
|
write_utf8(footer)
|
|
log.info("%s was rewritten (%d countries)" % (filename,
|
|
len(country_list)))
|
|
|
|
|
|
def cflags_to_include_dirs(cflags):
|
|
cflags = cflags.split()
|
|
include_dirs = []
|
|
for cflag in cflags:
|
|
if cflag.startswith('-I'):
|
|
include_dirs.append(cflag[2:])
|
|
return include_dirs
|
|
|
|
|
|
def _picard_get_locale_files():
|
|
locales = []
|
|
path_domain = {
|
|
'po': 'picard',
|
|
os.path.join('po', 'countries'): 'picard-countries',
|
|
}
|
|
for path, domain in path_domain.iteritems():
|
|
for filepath in glob.glob(os.path.join(path, '*.po')):
|
|
filename = os.path.basename(filepath)
|
|
locale = os.path.splitext(filename)[0]
|
|
locales.append((domain, locale, filepath))
|
|
return locales
|
|
|
|
|
|
args2 = {
|
|
'name': 'picard',
|
|
'version': __version__,
|
|
'description': 'The next generation MusicBrainz tagger',
|
|
'url': 'http://musicbrainz.org/doc/MusicBrainz_Picard',
|
|
'package_dir': {'picard': 'picard'},
|
|
'packages': ('picard', 'picard.browser',
|
|
'picard.plugins', 'picard.formats',
|
|
'picard.formats.mutagenext', 'picard.ui',
|
|
'picard.ui.options', 'picard.util'),
|
|
'locales': _picard_get_locale_files(),
|
|
'ext_modules': ext_modules,
|
|
'data_files': [],
|
|
'cmdclass': {
|
|
'test': picard_test,
|
|
'build': picard_build,
|
|
'build_locales': picard_build_locales,
|
|
'build_ui': picard_build_ui,
|
|
'clean_ui': picard_clean_ui,
|
|
'install': picard_install,
|
|
'install_locales': picard_install_locales,
|
|
'update_countries': picard_update_countries,
|
|
'get_po_files': picard_get_po_files,
|
|
'regen_pot_file': picard_regen_pot_file,
|
|
},
|
|
'scripts': ['scripts/picard'],
|
|
}
|
|
args.update(args2)
|
|
|
|
|
|
def generate_file(infilename, outfilename, variables):
|
|
f = file(infilename, "rt")
|
|
content = f.read()
|
|
f.close()
|
|
content = content % variables
|
|
f = file(outfilename, "wt")
|
|
f.write(content)
|
|
f.close()
|
|
|
|
|
|
try:
|
|
from py2exe.build_exe import py2exe
|
|
|
|
class bdist_nsis(py2exe):
|
|
|
|
def run(self):
|
|
generate_file('scripts/picard.py2exe.in', 'scripts/picard', {})
|
|
self.distribution.data_files.append(
|
|
("", ["discid.dll", "fpcalc.exe", "msvcr90.dll", "msvcp90.dll"]))
|
|
for locale in self.distribution.locales:
|
|
self.distribution.data_files.append(
|
|
("locale/" + locale[1] + "/LC_MESSAGES",
|
|
["build/locale/" + locale[1] + "/LC_MESSAGES/" + locale[0] + ".mo"]))
|
|
self.distribution.data_files.append(
|
|
("imageformats", [find_file_in_path("PyQt4/plugins/imageformats/qgif4.dll"),
|
|
find_file_in_path("PyQt4/plugins/imageformats/qjpeg4.dll"),
|
|
find_file_in_path("PyQt4/plugins/imageformats/qtiff4.dll")]))
|
|
self.distribution.data_files.append(
|
|
("accessible", [find_file_in_path("PyQt4/plugins/accessible/qtaccessiblewidgets4.dll")]))
|
|
self.distribution.data_files.append(
|
|
("plugins", ["contrib/plugins/discnumber.py",
|
|
"contrib/plugins/classicdiscnumber.py",
|
|
"contrib/plugins/titlecase.py",
|
|
"contrib/plugins/featartist.py"]))
|
|
|
|
py2exe.run(self)
|
|
print "*** creating the NSIS setup script ***"
|
|
pathname = "installer\picard-setup.nsi"
|
|
generate_file(pathname + ".in", pathname,
|
|
{'name': 'MusicBrainz Picard',
|
|
'version': __version__,
|
|
'description': 'The next generation MusicBrainz tagger.',
|
|
'url': 'http://musicbrainz.org/doc/MusicBrainz_Picard', })
|
|
print "*** compiling the NSIS setup script ***"
|
|
subprocess.call([self.find_nsis(), pathname])
|
|
|
|
def find_nsis(self):
|
|
import _winreg
|
|
with _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, "Software\\NSIS") as reg_key:
|
|
nsis_path = _winreg.QueryValueEx(reg_key, "")[0]
|
|
return os.path.join(nsis_path, "makensis.exe")
|
|
|
|
args['cmdclass']['bdist_nsis'] = bdist_nsis
|
|
args['windows'] = [{
|
|
'script': 'scripts/picard',
|
|
'icon_resources': [(1, 'picard.ico')],
|
|
}]
|
|
args['options'] = {
|
|
'bdist_nsis': {
|
|
'includes': ['json', 'sip'] + [e.name for e in ext_modules],
|
|
'excludes': ['ssl', 'socket', 'bz2'],
|
|
'optimize': 2,
|
|
},
|
|
}
|
|
except ImportError:
|
|
py2exe = None
|
|
|
|
|
|
def find_file_in_path(filename):
|
|
for include_path in sys.path:
|
|
file_path = os.path.join(include_path, filename)
|
|
if os.path.exists(file_path):
|
|
return file_path
|
|
|
|
if do_py2app:
|
|
from py2app.util import copy_file, find_app
|
|
from PyQt4 import QtCore
|
|
|
|
class BuildAPP(py2app):
|
|
|
|
def run(self):
|
|
py2app.run(self)
|
|
|
|
# XXX Find and bundle fpcalc, since py2app can't.
|
|
fpcalc = find_app("fpcalc")
|
|
if fpcalc:
|
|
dest_fpcalc = os.path.abspath("dist/MusicBrainz Picard.app/Contents/MacOS/fpcalc")
|
|
copy_file(fpcalc, dest_fpcalc)
|
|
os.chmod(dest_fpcalc, 0o755)
|
|
|
|
args['scripts'] = ['tagger.py']
|
|
args['cmdclass']['py2app'] = BuildAPP
|
|
|
|
# FIXME: this should check for the actual command ('install' vs. 'bdist_nsis', 'py2app', ...), not installed libraries
|
|
if py2exe is None and do_py2app is False:
|
|
args['data_files'].append(('share/icons/hicolor/16x16/apps', ['resources/images/16x16/picard.png']))
|
|
args['data_files'].append(('share/icons/hicolor/24x24/apps', ['resources/images/24x24/picard.png']))
|
|
args['data_files'].append(('share/icons/hicolor/32x32/apps', ['resources/images/32x32/picard.png']))
|
|
args['data_files'].append(('share/icons/hicolor/48x48/apps', ['resources/images/48x48/picard.png']))
|
|
args['data_files'].append(('share/icons/hicolor/128x128/apps', ['resources/images/128x128/picard.png']))
|
|
args['data_files'].append(('share/icons/hicolor/256x256/apps', ['resources/images/256x256/picard.png']))
|
|
args['data_files'].append(('share/applications', ('picard.desktop',)))
|
|
|
|
|
|
setup(**args)
|