#!/usr/bin/python # Audio Tools, a module and set of tools for manipulating audio data # Copyright (C) 2007-2015 Brian Langenberger # 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 2 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, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA from __future__ import print_function import sys if sys.version_info[0] == 3: if sys.version_info[1] < 3: print("*** Python 3.3 or better required") sys.exit(1) elif sys.version_info[0] == 2: if sys.version_info[1] < 7: print("*** Python 2.7 or better required") sys.exit(1) import os import os.path import re import subprocess from distutils.core import setup, Extension from distutils.command.build_ext import build_ext as _build_ext try: from configparser import (RawConfigParser, NoSectionError, NoOptionError) except ImportError: from ConfigParser import (RawConfigParser, NoSectionError, NoOptionError) configfile = RawConfigParser() configfile.read(["setup.cfg"]) VERSION = re.search(r'VERSION\s*=\s"(.+?)"', open(os.path.join( os.path.dirname(sys.argv[0]), "audiotools/__init__.py")).read()).group(1) LIBRARY_URLS = {"libcdio_paranoia": "http://www.gnu.org/software/libcdio/", "libcdio": "http://www.gnu.org/software/libcdio/", "libdvd-audio": "http://libdvd-audio.sourceforge.net", "libmpg123": "http://www.mpg123.org", "vorbisfile": "http://xiph.org", "opusfile": "http://www.opus-codec.org", "opus": "http://www.opus-codec.org", "mp3lame": "http://lame.sourceforge.net", "twolame": "http://twolame.sourceforge.net", "vorbisenc": "http://www.xiph.org", "alsa": "http://www.alsa-project.org", "libasound2": "http://www.alsa-project.org", "libpulse": "http://www.freedesktop.org", "wavpack": "http://www.wavpack.com"} class SystemLibraries(object): def __init__(self, configfile): self.configfile = configfile def guaranteed_present(self, library): """given library name string returns True if library is guaranteed present, False if library is not present, None if one should probe for the library default is None""" try: if self.configfile.get("Libraries", library) == "probe": return None else: try: return self.configfile.getboolean("Libraries", library) except ValueError: return None except NoSectionError: return None except NoOptionError: return None def present(self, library): """returns True if the given library is present on the system, returns False if it cannot be found""" present = self.guaranteed_present(library) if present is None: # probe for library using pkg-config, if available try: pkg_config = subprocess.Popen( ["pkg-config", "--exists", library], stdout=open(os.devnull, "wb"), stderr=open(os.devnull, "wb")) return (pkg_config.wait() == 0) except OSError: # pkg-config not found, so assume library isn't found return False else: return present def extra_compile_args(self, library): """returns a list of compile argument strings for populating an extension's 'extra_compile_args' argument the list may be empty""" try: pkg_config = subprocess.Popen( ["pkg-config", "--cflags", library], stdout=subprocess.PIPE, stderr=open(os.devnull, "wb"), universal_newlines=True) pkg_config_stdout = pkg_config.stdout.read().strip() if pkg_config.wait() == 0: # libraries found return pkg_config_stdout.split() else: # library not found return [] except OSError: # pkg-config not found return [] def extra_link_args(self, library): """returns a list of link argument strings for populating an extension's 'extra_link_args' argument the list may be empty""" try: pkg_config = subprocess.Popen( ["pkg-config", "--libs", library], stdout=subprocess.PIPE, stderr=open(os.devnull, "wb"), universal_newlines=True) pkg_config_stdout = pkg_config.stdout.read().strip() if pkg_config.wait() == 0: # libraries found return pkg_config_stdout.split() else: # library not found return [] except OSError: # pkg-config not found return [] def executable_present(self, executable, *args): """returns True if the given executable and any arguments execute with a 0 return status""" try: sub = subprocess.Popen([executable] + list(args), stdout=open(os.devnull, "wb"), stderr=open(os.devnull, "wb")) return (sub.wait() == 0) except OSError: return False def lib_version(self, library): """returns the library's version as a tuple""" try: pkg_config = subprocess.Popen( ["pkg-config", "--modversion", library], stdout=subprocess.PIPE, stderr=open(os.devnull, "wb"), universal_newlines=True) pkg_config_stdout = pkg_config.stdout.read().strip() if pkg_config.wait() == 0: try: return tuple(int(s) for s in pkg_config_stdout.split(".")) except ValueError: # version isn't all integers return tuple() else: # library not found return tuple() except OSError: # pkg-config not found return tuple() system_libraries = SystemLibraries(configfile) class output_table(object): def __init__(self): """a class for formatting rows for display""" self.__rows__ = [] def row(self): """returns a output_table_row object which columns can be added to""" row = output_table_row() self.__rows__.append(row) return row def blank_row(self): """inserts a blank table row with no output""" self.__rows__.append(output_table_blank()) def divider_row(self, dividers): """adds a row of unicode divider characters there should be one character in dividers per output column""" self.__rows__.append(output_table_divider(dividers)) def total_width(self): return sum([ max([row.column_width(col) for row in self.__rows__]) for col in range(len(self.__rows__[0]))]) def format(self): """yields one formatted string per row""" if len(self.__rows__) == 0: # no rows, so do nothing return if (len(set([len(r) for r in self.__rows__ if not isinstance(r, output_table_blank)])) != 1): raise ValueError("all rows must have same number of columns") column_widths = [ max([row.column_width(col) for row in self.__rows__]) for col in range(len(self.__rows__[0]))] for row in self.__rows__: yield row.format(column_widths) class output_table_row(object): def __init__(self): """a class for formatting columns for display""" self.__columns__ = [] def __len__(self): return len(self.__columns__) def add_column(self, text, alignment="left"): """adds text which is a plain string and an optional alignment alignment may be 'left', 'center', 'right'""" if alignment not in ("left", "center", "right"): raise ValueError("alignment must be 'left', 'center', or 'right'") self.__columns__.append((text, alignment)) def column_width(self, column): return len(self.__columns__[column][0]) def format(self, column_widths): """returns formatted row as a string""" def align_left(text, width): spaces = width - len(text) if spaces > 0: return text + " " * spaces else: return text def align_right(text, width): spaces = width - len(text) if spaces > 0: return " " * spaces + text else: return text def align_center(text, width): left_spaces = (width - len(text)) // 2 right_spaces = width - (left_spaces + len(text)) if (left_spaces + right_spaces) > 0: return (" " * left_spaces + text + " " * right_spaces) else: return text # attribute to method mapping align_meth = {"left": align_left, "right": align_right, "center": align_center} assert(len(column_widths) == len(self.__columns__)) return "".join([align_meth[alignment](text, width) for ((text, alignment), width) in zip(self.__columns__, column_widths)]).rstrip() class output_table_divider(object): """a class for formatting a row of divider characters""" def __init__(self, dividers): self.__dividers__ = dividers[:] def __len__(self): return len(self.__dividers__) def column_width(self, column): return 0 def format(self, column_widths): """returns formatted row as a string""" assert(len(column_widths) == len(self.__dividers__)) return "".join([divider * width for (divider, width) in zip(self.__dividers__, column_widths)]).rstrip() class output_table_blank(object): """a class for an empty table row""" def __init__(self): pass def column_width(self, column): return 0 def format(self, column_widths): """returns formatted row as a string""" return "" class build_ext(_build_ext): def build_extensions(self): _build_ext.build_extensions(self) # lib_name -> ([used for, ...], is present) libraries = {} for extension in self.extensions: if ((hasattr(extension, "library_manifest") and callable(extension.library_manifest))): for (library, used_for, is_present) in extension.library_manifest(): if library in libraries: libraries[library] = ( libraries[library][0] + [used_for], libraries[library][1] and is_present) else: libraries[library] = ([used_for], is_present) if ext_audiotools_cdio not in self.extensions: libraries["libcdio"] = (["CDDA data extraction"], False) if ext_audiotools_dvdaudio not in self.extensions: libraries["libdvd-audio"] = (["DVD-Audio extraction"], False) all_libraries_present = (set([l[1] for l in libraries.values()]) == set([True])) table = output_table() header = table.row() header.add_column("library", "right") header.add_column(" ") header.add_column("present?") header.add_column(" ") header.add_column("used for") if not all_libraries_present: header.add_column(" ") header.add_column("download URL") if not all_libraries_present: table.divider_row(["-", " ", "-", " ", "-", " ", "-"]) else: table.divider_row(["-", " ", "-", " ", "-"]) for library in sorted(libraries.keys()): row = table.row() row.add_column(library, "right") row.add_column(" ") row.add_column("yes" if libraries[library][1] else "no") row.add_column(" ") row.add_column(", ".join(libraries[library][0])) if not all_libraries_present: row.add_column(" ") if not libraries[library][1]: row.add_column(LIBRARY_URLS[library]) else: row.add_column("") try: pkg_config = subprocess.Popen( ["pkg-config", "--version"], stdout=open(os.devnull, "wb"), stderr=open(os.devnull, "wb")) pkg_config_found = (pkg_config.wait() == 0) except OSError: pkg_config_found = False print("=" * table.total_width()) print("Python Audio Tools %s Setup" % (VERSION)) print("=" * table.total_width()) if not pkg_config_found: def add_row(table, text, alignment="left"): row = table.row() row.add_column("*") row.add_column(text, alignment) row.add_column("*") table2 = output_table() row = table2.row() row.add_column("*") row.add_column("*" * 60) row.add_column("*") add_row(table2, "pkg-config not found", "center") add_row(table2, "some libraries may not be located automatically", "center") add_row(table2, "") add_row(table2, " download pkg-config from:") add_row(table2, " http://www.freedesktop.org/wiki/Software/pkg-config/") add_row(table2, "") add_row(table2, " or specify which libraries are available " + "in \"setup.cfg\"") row = table2.row() row.add_column("*") row.add_column("*" * 60) row.add_column("*") for row in table2.format(): print(row) for row in table.format(): print(row) print() class audiotools_cdio(Extension): def __init__(self, system_libraries): """extra_link_args is a list of argument strings from pkg-config, or None if we're to use the standard libcdio libraries""" self.__library_manifest__ = [] sources = [] libraries = set() extra_compile_args = [] extra_link_args = [] if system_libraries.present("libcdio_paranoia"): if system_libraries.guaranteed_present("libcdio_paranoia"): libraries.update(set(["libcdio", "libcdio_cdda", "libcdio_paranoia"])) try: if tuple(int(s) for s in system_libraries.configfile.get( "Libraries", "libcdio_paranoia_version")) < (0, 90): paranoia_version = [("OLD_PARANOIA", None)] else: paranoia_version = [] except (KeyError, ValueError): paranoia_version = [] else: extra_compile_args.extend( system_libraries.extra_compile_args("libcdio_paranoia")) extra_link_args.extend( system_libraries.extra_link_args("libcdio_paranoia")) if system_libraries.lib_version("libcdio_paranoia") < (0, 90): paranoia_version = [("OLD_PARANOIA", None)] else: paranoia_version = [] sources.extend(["src/cdiomodule.c", "src/framelist.c", "src/pcm_conv.c"]) self.__library_manifest__.append(("libcdio", "CDDA data extraction", True)) else: self.__library_manifest__.append(("libcdio", "CDDA data extraction", False)) paranoia_version = [] Extension.__init__( self, "audiotools.cdio", sources=sources, libraries=list(libraries), extra_compile_args=extra_compile_args, extra_link_args=extra_link_args, define_macros=paranoia_version) def library_manifest(self): for values in self.__library_manifest__: yield values def libraries_present(self): for (library, used_for, is_present) in self.library_manifest(): if not is_present: return False else: return True class audiotools_dvdaudio(Extension): def __init__(self, system_libraries): self.__library_manifest__ = [] sources = [] libraries = set() extra_compile_args = [] extra_link_args = [] if system_libraries.present("libdvd-audio"): if system_libraries.guaranteed_present("libdvd-audio"): libraries.update(set(["libdvd-audio"])) else: extra_compile_args.extend( system_libraries.extra_compile_args("libdvd-audio")) extra_link_args.extend( system_libraries.extra_link_args("libdvd-audio")) sources.extend(["src/dvdamodule.c", "src/framelist.c", "src/pcm_conv.c"]) self.__library_manifest__.append(("libdvd-audio", "DVD-Audio data extraction", True)) else: self.__library_manifest__.append(("libdvd-audio", "DVD-Audio data extraction", False)) Extension.__init__( self, "audiotools.dvda", sources=sources, libraries=list(libraries), extra_compile_args=extra_compile_args, extra_link_args=extra_link_args) def library_manifest(self): for values in self.__library_manifest__: yield values def libraries_present(self): for (library, used_for, is_present) in self.library_manifest(): if not is_present: return False else: return True class audiotools_pcm(Extension): def __init__(self): Extension.__init__(self, "audiotools.pcm", sources=["src/pcm.c", "src/pcm_conv.c"], define_macros=[("PCM_MODULE", None)]) class audiotools_pcmconverter(Extension): def __init__(self): Extension.__init__(self, "audiotools.pcmconverter", sources=["src/pcmconverter.c", "src/framelist.c", "src/pcmreader.c", "src/pcm_conv.c", "src/bitstream.c", "src/buffer.c", "src/func_io.c", "src/mini-gmp.c", "src/samplerate/samplerate.c", "src/samplerate/src_sinc.c", "src/samplerate/src_zoh.c", "src/samplerate/src_linear.c"], define_macros=[("HAS_PYTHON", None)]) class audiotools_replaygain(Extension): def __init__(self): Extension.__init__(self, "audiotools.replaygain", sources=["src/replaygain.c", "src/framelist.c", "src/pcmreader.c", "src/bitstream.c", "src/buffer.c", "src/func_io.c", "src/mini-gmp.c"], define_macros=[("HAS_PYTHON", None)]) class audiotools_decoders(Extension): def __init__(self, system_libraries): self.__library_manifest__ = [] defines = [("VERSION", VERSION), ("HAS_PYTHON", None)] sources = ["src/pcm_conv.c", "src/framelist.c", "src/bitstream.c", "src/buffer.c", "src/func_io.c", "src/mini-gmp.c", "src/huffman.c", "src/decoders/flac.c", "src/ogg.c", "src/ogg_crc.c", "src/common/flac_crc.c", "src/common/tta_crc.c", "src/common/m4a_atoms.c", "src/common/md5.c", "src/decoders/alac.c", "src/decoders/tta.c", "src/decoders/sine.c", "src/decoders.c"] libraries = set() extra_link_args = [] extra_compile_args = [] if system_libraries.present("libmpg123"): if system_libraries.guaranteed_present("libmpg123"): libraries.add("mpg123") else: extra_compile_args.extend( system_libraries.extra_compile_args("libmpg123")) extra_link_args.extend( system_libraries.extra_link_args("libmpg123")) defines.append(("HAS_MP3", None)) sources.append("src/decoders/mp3.c") self.__library_manifest__.append(("libmpg123", "MP3/MP2 decoding", True)) else: self.__library_manifest__.append(("libmpg123", "MP3/MP2 decoding", False)) if system_libraries.present("vorbisfile"): if system_libraries.guaranteed_present("vorbisfile"): libraries.update(set(["vorbisfile", "vorbis", "ogg"])) else: extra_compile_args.extend( system_libraries.extra_compile_args("vorbisfile")) extra_link_args.extend( system_libraries.extra_link_args("vorbisfile")) defines.append(("HAS_VORBIS", None)) sources.append("src/decoders/vorbis.c") self.__library_manifest__.append(("vorbisfile", "Ogg Vorbis decoding", True)) else: self.__library_manifest__.append(("vorbisfile", "Ogg Vorbis decoding", False)) if system_libraries.present("opusfile"): if system_libraries.guaranteed_present("opusfile"): libraries.add("opusfile") else: extra_compile_args.extend( system_libraries.extra_compile_args("opusfile")) extra_link_args.extend( system_libraries.extra_link_args("opusfile")) defines.append(("HAS_OPUS", None)) sources.append("src/decoders/opus.c") self.__library_manifest__.append(("opusfile", "Opus decoding", True)) else: self.__library_manifest__.append(("opusfile", "Opus decoding", False)) if system_libraries.present("wavpack"): if system_libraries.guaranteed_present("wavpack"): libraries.add("wavpack") else: extra_compile_args.extend( system_libraries.extra_compile_args("wavpack")) extra_link_args.extend( system_libraries.extra_link_args("wavpack")) defines.append(("HAS_WAVPACK", None)) sources.append("src/decoders/wavpack.c") self.__library_manifest__.append(("wavpack", "Wavpack decoding", True)) else: self.__library_manifest__.append(("wavpack", "Wavpack decoding", False)) Extension.__init__(self, "audiotools.decoders", sources=sources, define_macros=defines, libraries=list(libraries), extra_compile_args=extra_compile_args, extra_link_args=extra_link_args) def library_manifest(self): for values in self.__library_manifest__: yield values class audiotools_encoders(Extension): def __init__(self, system_libraries): self.__library_manifest__ = [] defines = [("VERSION", VERSION), ("HAS_PYTHON", None)] sources = ["src/pcmreader.c", "src/framelist.c", "src/pcm_conv.c", "src/bitstream.c", "src/buffer.c", "src/func_io.c", "src/mini-gmp.c", "src/common/md5.c", "src/encoders/flac.c", "src/common/flac_crc.c", "src/common/tta_crc.c", "src/encoders/alac.c", "src/common/m4a_atoms.c", "src/encoders/tta.c", "src/encoders.c"] libraries = set() extra_link_args = [] extra_compile_args = [] # Since mp3lame doesn't show up in pkg-config, # assume it's present if the user guarantees it is # or if the lame executable is present. # This may fail if the user has installed the binary # with a lame-dev package of some kind. mp3lame_present = system_libraries.guaranteed_present("mp3lame") if mp3lame_present is None: mp3lame_present = system_libraries.executable_present( "lame", "--version") if mp3lame_present: libraries.add("mp3lame") defines.append(("HAS_MP3", None)) sources.append("src/encoders/mp3.c") self.__library_manifest__.append(("mp3lame", "MP3 encoding", True)) else: self.__library_manifest__.append(("mp3lame", "MP3 encoding", False)) if system_libraries.present("twolame"): if system_libraries.guaranteed_present("twolame"): libraries.add("twolame") else: extra_compile_args.extend( system_libraries.extra_compile_args("twolame")) extra_link_args.extend( system_libraries.extra_link_args("twolame")) defines.append(("HAS_MP2", None)) sources.append("src/encoders/mp2.c") self.__library_manifest__.append(("twolame", "MP2 encoding", True)) else: self.__library_manifest__.append(("twolame", "MP2 encoding", False)) if system_libraries.present("vorbisenc"): if system_libraries.guaranteed_present("vorbisenc"): libraries.update(set(["vorbisenc", "vorbis", "ogg"])) else: extra_compile_args.extend( system_libraries.extra_compile_args("vorbisenc")) extra_link_args.extend( system_libraries.extra_link_args("vorbisenc")) defines.append(("HAS_VORBIS", None)) sources.append("src/encoders/vorbis.c") self.__library_manifest__.append(("vorbisenc", "Ogg Vorbis encoding", True)) else: self.__library_manifest__.append(("vorbisenc", "Ogg Vorbis encoding", False)) if system_libraries.present("opus"): if system_libraries.guaranteed_present("opus"): libraries.add("opus") else: extra_compile_args.extend( system_libraries.extra_compile_args("opus")) extra_link_args.extend( system_libraries.extra_link_args("opus")) defines.append(("HAS_OPUS", None)) sources.append("src/encoders/opus.c") self.__library_manifest__.append(("opus", "Opus encoding", True)) else: self.__library_manifest__.append(("opus", "Opus encoding", False)) if system_libraries.present("wavpack"): if system_libraries.guaranteed_present("wavpack"): libraries.add("wavpack") else: extra_compile_args.extend( system_libraries.extra_compile_args("wavpack")) extra_link_args.extend( system_libraries.extra_link_args("wavpack")) defines.append(("HAS_WAVPACK", None)) sources.append("src/encoders/wavpack.c") self.__library_manifest__.append(("wavpack", "Wavpack encoding", True)) else: self.__library_manifest__.append(("wavpack", "Wavpack encoding", False)) Extension.__init__(self, "audiotools.encoders", sources=sources, define_macros=defines, libraries=list(libraries), extra_compile_args=extra_compile_args, extra_link_args=extra_link_args) def library_manifest(self): for values in self.__library_manifest__: yield values class audiotools_bitstream(Extension): def __init__(self): Extension.__init__(self, "audiotools.bitstream", sources=["src/mod_bitstream.c", "src/bitstream.c", "src/buffer.c", "src/func_io.c", "src/mini-gmp.c", "src/huffman.c"], define_macros=[("HAS_PYTHON", None)]) class audiotools_ogg(Extension): def __init__(self): Extension.__init__(self, "audiotools._ogg", sources=["src/ogg.c", "src/ogg_crc.c", "src/mod_ogg.c", "src/bitstream.c", "src/func_io.c", "src/mini-gmp.c", "src/buffer.c"], define_macros=[("HAS_PYTHON", None)]) class audiotools_accuraterip(Extension): def __init__(self): Extension.__init__(self, "audiotools._accuraterip", sources=["src/accuraterip.c"]) class audiotools_output(Extension): def __init__(self, system_libraries): self.__library_manifest__ = [] sources = ["src/output.c"] defines = [] libraries = set() extra_compile_args = [] extra_link_args = [] # assume MacOS X always has CoreAudio if sys.platform == "darwin": sources.append("src/output/core_audio.c") defines.append(("CORE_AUDIO", "1")) extra_link_args.extend(["-framework", "AudioToolbox", "-framework", "AudioUnit", "-framework", "CoreServices"]) self.__library_manifest__.append(("CoreAudio", "Core Audio output", True)) elif sys.platform.startswith("linux"): # only check for ALSA on Linux if system_libraries.present("alsa"): if system_libraries.guaranteed_present("alsa"): libraries.add("asound") else: extra_compile_args.extend( system_libraries.extra_compile_args("alsa")) extra_link_args.extend( system_libraries.extra_link_args("alsa")) sources.append("src/output/alsa.c") sources.append("src/framelist.c") defines.append(("ALSA", "1")) self.__library_manifest__.append(("libasound2", "ALSA output", True)) else: self.__library_manifest__.append(("libasound2", "ALSA output", False)) if system_libraries.present("libpulse"): if system_libraries.guaranteed_present("libpulse"): libraries.add("pulse") else: extra_compile_args.extend( system_libraries.extra_compile_args("libpulse")) extra_link_args.extend( system_libraries.extra_link_args("libpulse")) sources.append("src/output/pulseaudio.c") # only include pcmconv once if "src/framelist.c" not in sources: sources.append("src/framelist.c") defines.append(("PULSEAUDIO", "1")) self.__library_manifest__.append(("libpulse", "PulseAudio output", True)) else: self.__library_manifest__.append(("libpulse", "PulseAudio output", False)) Extension.__init__(self, "audiotools.output", sources=sources, define_macros=defines, libraries=list(libraries), extra_compile_args=extra_compile_args, extra_link_args=extra_link_args) def library_manifest(self): for values in self.__library_manifest__: yield values ext_audiotools_cdio = audiotools_cdio(system_libraries) ext_audiotools_dvdaudio = audiotools_dvdaudio(system_libraries) ext_modules = [audiotools_pcm(), audiotools_pcmconverter(), audiotools_replaygain(), audiotools_decoders(system_libraries), audiotools_encoders(system_libraries), audiotools_bitstream(), audiotools_ogg(), audiotools_accuraterip(), audiotools_output(system_libraries)] scripts = ["audiotools-config", "coverdump", "covertag", "coverview", "track2cdda", "track2track", "trackcat", "trackcmp", "trackinfo", "tracklength", "tracklint", "trackplay", "trackrename", "tracksplit", "tracktag", "trackverify"] if ext_audiotools_cdio.libraries_present(): ext_modules.append(ext_audiotools_cdio) scripts.extend(["cdda2track", "cddainfo", "cddaplay"]) if ext_audiotools_dvdaudio.libraries_present(): ext_modules.append(ext_audiotools_dvdaudio) scripts.extend(["dvda2track", "dvdainfo"]) setup(name="audiotools", version=VERSION, author="Brian Langenberger", author_email="tuffy@users.sourceforge.net", url="http://audiotools.sourceforge.net", description="A collection of audio handling utilities", # long_description="""""", #FIXME download_url="http://sourceforge.net/projects/audiotools/files/", classifiers=[ "Development Status :: 5 - Production/Stable", "Environment :: Console", "Intended Audience :: Developers", "Intended Audience :: End Users/Desktop", "License :: OSI Approved :: " + "GNU General Public License v2 or later (GPLv2+)", "Operating System :: MacOS :: MacOS X", "Operating System :: POSIX", "Operating System :: POSIX :: Linux", "Programming Language :: C", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Topic :: Multimedia :: Sound/Audio", "Topic :: Multimedia :: Sound/Audio :: CD Audio", "Topic :: Multimedia :: Sound/Audio :: CD Audio :: CD Playing", "Topic :: Multimedia :: Sound/Audio :: CD Audio :: CD Ripping", "Topic :: Multimedia :: Sound/Audio :: CD Audio :: CD Writing", "Topic :: Multimedia :: Sound/Audio :: Conversion", "Topic :: Multimedia :: Sound/Audio :: Players", "Topic :: Software Development :: Libraries :: Python Modules"], platforms=["POSIX", "Linux", "OS X"], license="GPLv2+", packages=["audiotools", "audiotools.py_decoders", "audiotools.py_encoders", "audiotools.cue", "audiotools.toc", "audiotools.ply"], ext_modules=ext_modules, cmdclass={"build_ext": build_ext}, scripts=scripts)