357 lines
12 KiB
Python
357 lines
12 KiB
Python
from __future__ import annotations
|
|
|
|
|
|
NAME = "PyYAML"
|
|
VERSION = "3.13"
|
|
DESCRIPTION = "YAML parser and emitter for Python"
|
|
LONG_DESCRIPTION = """\
|
|
YAML is a data serialization format designed for human readability
|
|
and interaction with scripting languages. PyYAML is a YAML parser
|
|
and emitter for Python.
|
|
|
|
PyYAML features a complete YAML 1.1 parser, Unicode support, pickle
|
|
support, capable extension API, and sensible error messages. PyYAML
|
|
supports standard YAML tags and provides Python-specific tags that
|
|
allow to represent an arbitrary Python object.
|
|
|
|
PyYAML is applicable for a broad range of tasks from complex
|
|
configuration files to object serialization and persistence."""
|
|
AUTHOR = "Kirill Simonov"
|
|
AUTHOR_EMAIL = "xi@resolvent.net"
|
|
LICENSE = "MIT"
|
|
PLATFORMS = "Any"
|
|
URL = "http://pyyaml.org/wiki/PyYAML"
|
|
DOWNLOAD_URL = f"http://pyyaml.org/download/pyyaml/{NAME}-{VERSION}.tar.gz"
|
|
CLASSIFIERS = [
|
|
"Development Status :: 5 - Production/Stable",
|
|
"Intended Audience :: Developers",
|
|
"License :: OSI Approved :: MIT License",
|
|
"Operating System :: OS Independent",
|
|
"Programming Language :: Python",
|
|
"Programming Language :: Python :: 2",
|
|
"Programming Language :: Python :: 2.7",
|
|
"Programming Language :: Python :: 3",
|
|
"Programming Language :: Python :: 3.4",
|
|
"Programming Language :: Python :: 3.5",
|
|
"Topic :: Software Development :: Libraries :: Python Modules",
|
|
"Topic :: Text Processing :: Markup",
|
|
]
|
|
|
|
|
|
LIBYAML_CHECK = """
|
|
#include <yaml.h>
|
|
|
|
int main(void) {
|
|
yaml_parser_t parser;
|
|
yaml_emitter_t emitter;
|
|
|
|
yaml_parser_initialize(&parser);
|
|
yaml_parser_delete(&parser);
|
|
|
|
yaml_emitter_initialize(&emitter);
|
|
yaml_emitter_delete(&emitter);
|
|
|
|
return 0;
|
|
}
|
|
"""
|
|
|
|
|
|
import os.path
|
|
import platform
|
|
import sys
|
|
|
|
from distutils import log
|
|
from distutils.command.bdist_rpm import bdist_rpm as _bdist_rpm
|
|
from distutils.command.build_ext import build_ext as _build_ext
|
|
from distutils.core import Command
|
|
from distutils.core import Distribution as _Distribution
|
|
from distutils.core import Extension as _Extension
|
|
from distutils.core import setup
|
|
from distutils.dir_util import mkpath
|
|
from distutils.errors import CompileError
|
|
from distutils.errors import DistutilsError
|
|
from distutils.errors import DistutilsPlatformError
|
|
from distutils.errors import LinkError
|
|
|
|
|
|
if "setuptools.extension" in sys.modules:
|
|
_Extension = sys.modules["setuptools.extension"]._Extension
|
|
sys.modules["distutils.core"].Extension = _Extension
|
|
sys.modules["distutils.extension"].Extension = _Extension
|
|
sys.modules["distutils.command.build_ext"].Extension = _Extension
|
|
|
|
with_cython = False
|
|
try:
|
|
from Cython.Distutils import build_ext as _build_ext
|
|
from Cython.Distutils.extension import Extension as _Extension
|
|
|
|
with_cython = True
|
|
except ImportError:
|
|
pass
|
|
|
|
try:
|
|
from wheel.bdist_wheel import bdist_wheel
|
|
except ImportError:
|
|
bdist_wheel = None
|
|
|
|
|
|
class Distribution(_Distribution):
|
|
def __init__(self, attrs=None):
|
|
_Distribution.__init__(self, attrs)
|
|
if not self.ext_modules:
|
|
return
|
|
for idx in range(len(self.ext_modules) - 1, -1, -1):
|
|
ext = self.ext_modules[idx]
|
|
if not isinstance(ext, Extension):
|
|
continue
|
|
setattr(self, ext.attr_name, None)
|
|
self.global_options = [
|
|
(
|
|
ext.option_name,
|
|
None,
|
|
"include %s (default if %s is available)"
|
|
% (ext.feature_description, ext.feature_name),
|
|
),
|
|
(ext.neg_option_name, None, "exclude %s" % ext.feature_description),
|
|
] + self.global_options
|
|
self.negative_opt = self.negative_opt.copy()
|
|
self.negative_opt[ext.neg_option_name] = ext.option_name
|
|
|
|
def has_ext_modules(self):
|
|
if not self.ext_modules:
|
|
return False
|
|
for ext in self.ext_modules:
|
|
with_ext = self.ext_status(ext)
|
|
if with_ext is None or with_ext:
|
|
return True
|
|
return False
|
|
|
|
def ext_status(self, ext):
|
|
implementation = platform.python_implementation()
|
|
if implementation != "CPython":
|
|
return False
|
|
if isinstance(ext, Extension):
|
|
with_ext = getattr(self, ext.attr_name)
|
|
return with_ext
|
|
else:
|
|
return True
|
|
|
|
|
|
class Extension(_Extension):
|
|
def __init__(
|
|
self, name, sources, feature_name, feature_description, feature_check, **kwds
|
|
):
|
|
if not with_cython:
|
|
for filename in sources[:]:
|
|
base, ext = os.path.splitext(filename)
|
|
if ext == ".pyx":
|
|
sources.remove(filename)
|
|
sources.append("%s.c" % base)
|
|
_Extension.__init__(self, name, sources, **kwds)
|
|
self.feature_name = feature_name
|
|
self.feature_description = feature_description
|
|
self.feature_check = feature_check
|
|
self.attr_name = "with_" + feature_name.replace("-", "_")
|
|
self.option_name = "with-" + feature_name
|
|
self.neg_option_name = "without-" + feature_name
|
|
|
|
|
|
class build_ext(_build_ext):
|
|
def run(self):
|
|
optional = True
|
|
disabled = True
|
|
for ext in self.extensions:
|
|
with_ext = self.distribution.ext_status(ext)
|
|
if with_ext is None:
|
|
disabled = False
|
|
elif with_ext:
|
|
optional = False
|
|
disabled = False
|
|
break
|
|
if disabled:
|
|
return
|
|
try:
|
|
_build_ext.run(self)
|
|
except DistutilsPlatformError:
|
|
exc = sys.exc_info()[1]
|
|
if optional:
|
|
log.warn(str(exc))
|
|
log.warn("skipping build_ext")
|
|
else:
|
|
raise
|
|
|
|
def get_source_files(self):
|
|
self.check_extensions_list(self.extensions)
|
|
filenames = []
|
|
for ext in self.extensions:
|
|
if with_cython:
|
|
self.cython_sources(ext.sources, ext)
|
|
for filename in ext.sources:
|
|
filenames.append(filename)
|
|
base = os.path.splitext(filename)[0]
|
|
for ext in ["c", "h", "pyx", "pxd"]:
|
|
filename = f"{base}.{ext}"
|
|
if filename not in filenames and os.path.isfile(filename):
|
|
filenames.append(filename)
|
|
return filenames
|
|
|
|
def get_outputs(self):
|
|
self.check_extensions_list(self.extensions)
|
|
outputs = []
|
|
for ext in self.extensions:
|
|
fullname = self.get_ext_fullname(ext.name)
|
|
filename = os.path.join(self.build_lib, self.get_ext_filename(fullname))
|
|
if os.path.isfile(filename):
|
|
outputs.append(filename)
|
|
return outputs
|
|
|
|
def build_extensions(self):
|
|
self.check_extensions_list(self.extensions)
|
|
for ext in self.extensions:
|
|
with_ext = self.distribution.ext_status(ext)
|
|
if with_ext is None:
|
|
with_ext = self.check_extension_availability(ext)
|
|
if not with_ext:
|
|
continue
|
|
if with_cython:
|
|
ext.sources = self.cython_sources(ext.sources, ext)
|
|
self.build_extension(ext)
|
|
|
|
def check_extension_availability(self, ext):
|
|
cache = os.path.join(self.build_temp, "check_%s.out" % ext.feature_name)
|
|
if not self.force and os.path.isfile(cache):
|
|
data = open(cache).read().strip()
|
|
if data == "1":
|
|
return True
|
|
elif data == "0":
|
|
return False
|
|
mkpath(self.build_temp)
|
|
src = os.path.join(self.build_temp, "check_%s.c" % ext.feature_name)
|
|
open(src, "w").write(ext.feature_check)
|
|
log.info("checking if %s is compilable" % ext.feature_name)
|
|
try:
|
|
[obj] = self.compiler.compile(
|
|
[src],
|
|
macros=ext.define_macros + [(undef,) for undef in ext.undef_macros],
|
|
include_dirs=ext.include_dirs,
|
|
extra_postargs=(ext.extra_compile_args or []),
|
|
depends=ext.depends,
|
|
)
|
|
except CompileError:
|
|
log.warn("")
|
|
log.warn(
|
|
"%s is not found or a compiler error: forcing --%s"
|
|
% (ext.feature_name, ext.neg_option_name)
|
|
)
|
|
log.warn(
|
|
"(if %s is installed correctly, you may need to" % ext.feature_name
|
|
)
|
|
log.warn(" specify the option --include-dirs or uncomment and")
|
|
log.warn(" modify the parameter include_dirs in setup.cfg)")
|
|
open(cache, "w").write("0\n")
|
|
return False
|
|
prog = "check_%s" % ext.feature_name
|
|
log.info("checking if %s is linkable" % ext.feature_name)
|
|
try:
|
|
self.compiler.link_executable(
|
|
[obj],
|
|
prog,
|
|
output_dir=self.build_temp,
|
|
libraries=ext.libraries,
|
|
library_dirs=ext.library_dirs,
|
|
runtime_library_dirs=ext.runtime_library_dirs,
|
|
extra_postargs=(ext.extra_link_args or []),
|
|
)
|
|
except LinkError:
|
|
log.warn("")
|
|
log.warn(
|
|
"%s is not found or a linker error: forcing --%s"
|
|
% (ext.feature_name, ext.neg_option_name)
|
|
)
|
|
log.warn(
|
|
"(if %s is installed correctly, you may need to" % ext.feature_name
|
|
)
|
|
log.warn(" specify the option --library-dirs or uncomment and")
|
|
log.warn(" modify the parameter library_dirs in setup.cfg)")
|
|
open(cache, "w").write("0\n")
|
|
return False
|
|
open(cache, "w").write("1\n")
|
|
return True
|
|
|
|
|
|
class bdist_rpm(_bdist_rpm):
|
|
def _make_spec_file(self):
|
|
argv0 = sys.argv[0]
|
|
features = []
|
|
for ext in self.distribution.ext_modules:
|
|
if not isinstance(ext, Extension):
|
|
continue
|
|
with_ext = getattr(self.distribution, ext.attr_name)
|
|
if with_ext is None:
|
|
continue
|
|
if with_ext:
|
|
features.append("--" + ext.option_name)
|
|
else:
|
|
features.append("--" + ext.neg_option_name)
|
|
sys.argv[0] = " ".join([argv0] + features)
|
|
spec_file = _bdist_rpm._make_spec_file(self)
|
|
sys.argv[0] = argv0
|
|
return spec_file
|
|
|
|
|
|
class test(Command):
|
|
|
|
user_options = []
|
|
|
|
def initialize_options(self):
|
|
pass
|
|
|
|
def finalize_options(self):
|
|
pass
|
|
|
|
def run(self):
|
|
build_cmd = self.get_finalized_command("build")
|
|
build_cmd.run()
|
|
sys.path.insert(0, build_cmd.build_lib)
|
|
sys.path.insert(0, "tests/lib3")
|
|
import test_all
|
|
|
|
if not test_all.main([]):
|
|
raise DistutilsError("Tests failed")
|
|
|
|
|
|
cmdclass = {"build_ext": build_ext, "bdist_rpm": bdist_rpm, "test": test}
|
|
if bdist_wheel:
|
|
cmdclass["bdist_wheel"] = bdist_wheel
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
setup(
|
|
name=NAME,
|
|
version=VERSION,
|
|
description=DESCRIPTION,
|
|
long_description=LONG_DESCRIPTION,
|
|
author=AUTHOR,
|
|
author_email=AUTHOR_EMAIL,
|
|
license=LICENSE,
|
|
platforms=PLATFORMS,
|
|
url=URL,
|
|
download_url=DOWNLOAD_URL,
|
|
classifiers=CLASSIFIERS,
|
|
package_dir={"": "lib3"},
|
|
packages=["yaml"],
|
|
ext_modules=[
|
|
Extension(
|
|
"_yaml",
|
|
["ext/_yaml.pyx"],
|
|
"libyaml",
|
|
"LibYAML bindings",
|
|
LIBYAML_CHECK,
|
|
libraries=["yaml"],
|
|
)
|
|
],
|
|
distclass=Distribution,
|
|
cmdclass=cmdclass,
|
|
)
|