pip install --target=.lib --ignore-installed {req!r}
"""
raise ImportError(error.format(req=" ".join(setup_requires)))
import about
# This Package
sys.path.insert(1, local("audio"))
import about_shrink
#
# Setup
# ------------------------------------------------------------------------------
#
info = dict(
metadata = about.get_metadata(about_shrink),
code = dict(packages=setuptools.find_packages()),
data = {},
requirements = dict(install_requires =
["audio.bitstream",
"audio.coders" ,
"audio.frames" ,
"audio.wave" ,
"breakpoint" ,
"logfile" ]
),
scripts = dict(entry_points =
{"console_scripts": ["shrink=audio.shrink:main"]}
),
plugins = {},
tests = dict(test_suite="test.suite"),
setup_requires = ["about>=4.0.0"]
require = lambda *r: pkg_resources.WorkingSet().require(*r)
require(*setup_requires)
import about
except pkg_resources.DistributionNotFound:
error = """{req!r} not found; install it locally with:
pip install --target=.lib --ignore-installed {req!r}
"""
raise ImportError(error.format(req=" ".join(setup_requires)))
import about
# This Package
sys.path.insert(1, srcdir("audio"))
import about_fourier
info = dict(
metadata = about.get_metadata(about_fourier),
code = dict(packages=setuptools.find_packages()),
data = {},
requirements = {},
scripts = {},
plugins = {},
tests = dict(test_suite="test.suite"),
)
if __name__ == "__main__":
kwargs = {k:v for dct in info.values() for (k,v) in dct.items()}
setuptools.setup(**kwargs)
from Cython.Build import cythonize
return cythonize(pyx_file, **include)
else:
if os.path.exists(c_file):
return [setuptools.Extension(name,
sources=[c_file],
**include)]
else:
error = "file not found: {0!r}".format(c_file)
raise IOError(error)
#
# Setup
# ------------------------------------------------------------------------------
#
info = dict(
metadata = about.get_metadata(about_coders),
code = dict(packages=setuptools.find_packages(),
ext_modules=make_extension("audio.coders")),
data = {},
requirements = dict(install_requires="bitstream"),
scripts = {},
plugins = {},
tests = dict(test_suite="test.suite"),
)
if __name__ == "__main__":
kwargs = {k:v for dct in info.values() for (k,v) in dct.items()}
setuptools.setup(**kwargs)
# Pip Package Manager
try:
import pip
import setuptools
import pkg_resources
except ImportError:
error = "pip is not installed, refer to <{url}> for instructions."
raise ImportError(error.format(url="http://pip.readthedocs.org"))
sys.path.insert(0, os.getcwd())
import about
import about.about
info = dict(
metadata = about.get_metadata(about.about),
contents = {
"package_data": {"": ["*.txt"]},
"packages": setuptools.find_packages()
},
requirements = {"install_requires": ["setuptools"]},
scripts = {},
plugins = {},
tests = {},
)
if __name__ == "__main__":
kwargs = {k:v for dct in info.values() for (k,v) in dct.items()}
setuptools.setup(**kwargs)
setup_requires = ["about>=4.0.0"]
require = lambda *r: pkg_resources.WorkingSet().require(*r)
require(*setup_requires)
import about
except pkg_resources.DistributionNotFound:
error = """{req!r} not found; install it locally with:
pip install --target=.lib --ignore-installed {req!r}
"""
raise ImportError(error.format(req=" ".join(setup_requires)))
import about
# This Package
sys.path.insert(1, local("numtest"))
import about_numtest
info = dict(
metadata = about.get_metadata(about_numtest),
code = dict(packages=setuptools.find_packages()),
data = {},
requirements = {},
scripts = {},
plugins = {},
tests = dict(test_suite="test.suite"),
)
if __name__ == "__main__":
kwargs = {k:v for dct in info.values() for (k,v) in dct.items()}
setuptools.setup(**kwargs)
setup_requires = ["about>=5.2<6"]
require = lambda *r: pkg_resources.WorkingSet().require(*r)
require(*setup_requires)
import about
except pkg_resources.DistributionNotFound:
error = """{req!r} not found; install it locally with:
pip install --target=.lib --ignore-installed {req!r}
"""
raise ImportError(error.format(req=" ".join(setup_requires)))
# Setup
# ------------------------------------------------------------------------------
sys.path.insert(0, "docbench"); import __about__
metadata = about.get_metadata(__about__)
contents = dict(
packages = ["docbench"],
)
install_requires = ["lsprofcalltree>=0.0.92"]
if sys.version_info < (3, 0):
install_requires.append("pathlib2")
requirements = dict(
install_requires = install_requires,
)
info = {}
info.update(metadata)
setup_requires = ["about>=4.0.0"]
require = lambda *r: pkg_resources.WorkingSet().require(*r)
require(*setup_requires)
import about
except pkg_resources.DistributionNotFound:
error = """{req!r} not found; install it locally with:
pip install --target=.lib --ignore-installed {req!r}
"""
raise ImportError(error.format(req=" ".join(setup_requires)))
import about
# This Package
sys.path.insert(1, srcdir("audio"))
import about_lp
info = dict(
metadata = about.get_metadata(about_lp),
code = dict(packages=setuptools.find_packages()),
data = {},
requirements = dict(install_requires=["numtest", "logfile"]),
scripts = {},
plugins = {},
tests = dict(test_suite="test.suite"),
)
if __name__ == "__main__":
kwargs = {k:v for dct in info.values() for (k,v) in dct.items()}
setuptools.setup(**kwargs)
require = lambda *r: pkg_resources.WorkingSet().require(*r)
require(*setup_requires)
import about
except pkg_resources.DistributionNotFound:
error = """{req!r} not found; install it locally with:
pip install --target=.lib --ignore-installed {req!r}
"""
raise ImportError(error.format(req=" ".join(setup_requires)))
import about
# This package (no runtime dependencies)
import breakpoint
# ------------------------------------------------------------------------------
info = dict(
metadata = about.get_metadata(breakpoint),
code = dict(py_modules=["breakpoint"]),
data = {},
requirements = {},
scripts = {},
plugins = {},
tests = dict(test_suite="test.test_suite"),
)
if __name__ == "__main__":
kwargs = {k:v for dct in info.values() for (k,v) in dct.items()}
setuptools.setup(**kwargs)
require = lambda *r: pkg_resources.WorkingSet().require(*r)
require(*setup_requires)
import about
except pkg_resources.DistributionNotFound:
error = """{req!r} not found; install it locally with:
pip install --target=.lib --ignore-installed {req!r}
"""
raise ImportError(error.format(req=" ".join(setup_requires)))
import about
# This Package
sys.path.insert(1, local("audio"))
import about_filters
info = dict(
metadata = about.get_metadata(about_filters),
code = dict(packages=setuptools.find_packages()),
#ext_modules = cythonize("audio/filters.pyx")
data = {},
requirements = dict(install_requires="audio.fourier"),
scripts = {},
plugins = {},
tests = dict(test_suite="test.suite"),
)
if __name__ == "__main__":
kwargs = {k:v for dct in info.values() for (k,v) in dct.items()}
setuptools.setup(**kwargs)
sys.path.insert(0, "")
import about_pandoc
# Non-Python Runtime Dependencies
try:
pandoc = sh.pandoc
magic, version = sh.pandoc("--version").splitlines()[0].split()
assert magic == "pandoc"
assert version.startswith("1.12") or version.startswith("1.13")
except:
# if root runs the setup script, it's ok if pandoc is not available,
# as long as the users have it. Hence we cannot raise an exception here,
# we only produce a warning.
warnings.warn("cannot find pandoc 1.12 / 1.13")
# ------------------------------------------------------------------------------
contents = dict(py_modules=["pandoc", "about_pandoc"])
metadata = about.get_metadata(about_pandoc)
info = {}
info.update(contents)
info.update(metadata)
info.update(requirements)
# ------------------------------------------------------------------------------
if __name__ == "__main__":
setuptools.setup(**info)
# Python 2.7 Standard Library
import inspect
import os
import re
import sys
# Third-Party Libraries
import setuptools
# Local Libraries
sys.path.insert(0, "lib"); import about
sys.path.insert(0, "docbench"); import __about__ as about_docbench
lines = open("README.md").read().splitlines()
about_docbench.__doc__ = "\n".join([lines[0]] + lines[2:])
metadata = about.get_metadata(about_docbench)
contents = dict(
packages = ["docbench"],
)
requirements = dict(
install_requires = ["lsprofcalltree", "path.py"],
)
info = {}
info.update(metadata)
info.update(contents)
info.update(requirements)
if __name__ == "__main__":
setup_requires = ["about>=4.0.0"]
require = lambda *r: pkg_resources.WorkingSet().require(*r)
require(*setup_requires)
import about
except pkg_resources.DistributionNotFound:
error = """{req!r} not found; install it locally with:
pip install --target=.lib --ignore-installed {req!r}
"""
raise ImportError(error.format(req=" ".join(setup_requires)))
# Project Library
sys.path.insert(1, local(""))
import wish
info = dict(
metadata = about.get_metadata(wish),
code = dict(packages = setuptools.find_packages()),
data = dict(package_data={"logfile": ["README.md"]}),
requirements = dict(install_requires = ["pip"]),
commands = {},
plugins = {},
scripts = {},
tests = dict(test_suite = "wish.test.suite")
)
if __name__ == "__main__":
kwargs = {k:v for dct in info.values() for (k,v) in dct.items()}
setuptools.setup(**kwargs)
setup_requires = ["about>=4.0.0"]
require = lambda *r: pkg_resources.WorkingSet().require(*r)
require(*setup_requires)
import about
except pkg_resources.DistributionNotFound:
error = """{req!r} not found; install it locally with:
pip install --target=.lib --ignore-installed {req!r}
"""
raise ImportError(error.format(req=" ".join(setup_requires)))
import about
# This Package
sys.path.insert(1, local("audio"))
import about_frames
info = dict(
metadata = about.get_metadata(about_frames),
code = dict(packages=setuptools.find_packages()),
data = {},
requirements = {},
scripts = {},
plugins = {},
tests = dict(test_suite="test.suite"),
)
if __name__ == "__main__":
kwargs = {k:v for dct in info.values() for (k,v) in dct.items()}
setuptools.setup(**kwargs)
setup_requires = ["about>=4.0.0"]
require = lambda *r: pkg_resources.WorkingSet().require(*r)
require(*setup_requires)
import about
except pkg_resources.DistributionNotFound:
error = """{req!r} not found; install it locally with:
pip install --target=.lib --ignore-installed {req!r}
"""
raise ImportError(error.format(req=" ".join(setup_requires)))
import about
# This Package
sys.path.insert(1, srcdir("audio"))
import about_quantizers
info = dict(
metadata = about.get_metadata(about_quantizers),
code = dict(packages=setuptools.find_packages()),
data = {},
requirements = {},
scripts = {},
plugins = {},
tests = dict(test_suite="test.suite"),
)
if __name__ == "__main__":
kwargs = {k:v for dct in info.values() for (k,v) in dct.items()}
setuptools.setup(**kwargs)
setup_requires = ["about>=4.0.0"]
require = lambda *r: pkg_resources.WorkingSet().require(*r)
require(*setup_requires)
import about
except pkg_resources.DistributionNotFound:
error = """{req!r} not found; install it locally with:
pip install --target=.lib --ignore-installed {req!r}
"""
raise ImportError(error.format(req=" ".join(setup_requires)))
import about
# This Package
sys.path.insert(1, srcdir("audio"))
import about_io
info = dict(
metadata = about.get_metadata(about_io),
code = dict(packages=setuptools.find_packages()),
data = {},
requirements = {},
scripts = {},
plugins = {},
tests = {},
)
if __name__ == "__main__":
kwargs = {k:v for dct in info.values() for (k,v) in dct.items()}
setuptools.setup(**kwargs)
setup_requires = ["about>=4.0.0"]
require = lambda *r: pkg_resources.WorkingSet().require(*r)
require(*setup_requires)
import about
except pkg_resources.DistributionNotFound:
error = """{req!r} not found; install it locally with:
pip install --target=.lib --ignore-installed {req!r}
"""
raise ImportError(error.format(req=" ".join(setup_requires)))
import about
# This Package
sys.path.insert(1, srcdir("audio"))
import about_index
info = dict(
metadata = about.get_metadata(about_index),
code = dict(packages=setuptools.find_packages()),
data = {},
requirements = dict(install_requires=["audio.bitstream", "nltk"]),
scripts = {},
plugins = {},
tests = dict(test_suite="test.suite"),
)
if __name__ == "__main__":
kwargs = {k:v for dct in info.values() for (k,v) in dct.items()}
setuptools.setup(**kwargs)
try:
setup_requires = ["about>=4.0.0"]
require = lambda *r: pkg_resources.WorkingSet().require(*r)
require(*setup_requires)
import about
except pkg_resources.DistributionNotFound:
error = """{req!r} not found; install it locally with:
pip install --target=.lib --ignore-installed {req!r}
"""
raise ImportError(error.format(req=" ".join(setup_requires)))
import about
# This Package
sys.path.insert(1, local("audio"))
import about_psychoacoustics
info = dict(
metadata=about.get_metadata(about_psychoacoustics),
code=dict(packages=setuptools.find_packages()),
data=dict(package_data={"": ["*.txt"]}),
requirements={},
scripts={},
plugins={},
tests=dict(test_suite="test.suite"),
)
if __name__ == "__main__":
kwargs = {k: v for dct in info.values() for (k, v) in dct.items()}
setuptools.setup(**kwargs)
