<NME> setup.py
<BEF> #!/usr/bin/env python
import sys
import distutils.util
from distutils.command.build_ext import build_ext
from distutils.sysconfig import get_python_inc
from setuptools import Extension, setup, find_packages
from pathlib import Path
import numpy
from Cython.Build import cythonize
from Cython.Compiler import Options


# Preserve `__doc__` on functions and classes
# http://docs.cython.org/en/latest/src/userguide/source_files_and_compilation.html#compiler-options
Options.docstrings = True


PACKAGES = find_packages()
MOD_NAMES = [
    "thinc.backends.cblas",
    "thinc.backends.linalg",
    "thinc.backends.numpy_ops",
    "thinc.extra.search",
    "thinc.layers.sparselinear",
]
COMPILE_OPTIONS = {
    "msvc": ["/Ox", "/EHsc"],
    "other": ["-O3", "-Wno-strict-prototypes", "-Wno-unused-function", "-std=c++11"],
}
COMPILER_DIRECTIVES = {
    "language_level": -3,
    "embedsignature": True,
    "annotation_typing": False,
}
LINK_OPTIONS = {"msvc": [], "other": []}


def is_new_osx():
    """Check whether we're on OSX >= 10.10"""
    name = distutils.util.get_platform()
    if sys.platform != "darwin":
        return False
    elif name.startswith("macosx-10"):
        minor_version = int(name.split("-")[1].split(".")[1])
        if minor_version >= 7:
            return True
        else:
            return False
    else:
        return False


if is_new_osx():
    # On Mac, use libc++ because Apple deprecated use of libstdc
    COMPILE_OPTIONS["other"].append("-stdlib=libc++")
    LINK_OPTIONS["other"].append("-lc++")
    # g++ (used by unix compiler on mac) links to libstdc++ as a default lib.
    # See: https://stackoverflow.com/questions/1653047/avoid-linking-to-libstdc
    LINK_OPTIONS["other"].append("-nodefaultlibs")


# By subclassing build_extensions we have the actual compiler that will be used
# which is really known only after finalize_options
# http://stackoverflow.com/questions/724664/python-distutils-how-to-get-a-compiler-that-is-going-to-be-used
class build_ext_options:
    def build_options(self):
        if hasattr(self.compiler, "initialize"):
            self.compiler.initialize()
        self.compiler.platform = sys.platform[:6]
        for e in self.extensions:
            e.extra_compile_args = COMPILE_OPTIONS.get(
                self.compiler.compiler_type, COMPILE_OPTIONS["other"]
            )
            e.extra_link_args = LINK_OPTIONS.get(
                self.compiler.compiler_type, LINK_OPTIONS["other"]
            )


class build_ext_subclass(build_ext, build_ext_options):
    def build_extensions(self):
        build_ext_options.build_options(self)
        build_ext.build_extensions(self)


def clean(path):
    for path in path.glob("**/*"):
        if path.is_file() and path.suffix in (".so", ".cpp"):
            print(f"Deleting {path.name}")
            path.unlink()


def setup_package():
    root = Path(__file__).parent

    if len(sys.argv) > 1 and sys.argv[1] == "clean":
        return clean(root / "thinc")

    with (root / "thinc" / "about.py").open("r") as f:
        about = {}
        exec(f.read(), about)

    include_dirs = [numpy.get_include(), get_python_inc(plat_specific=True)]
    ext_modules = []
    for name in MOD_NAMES:
        mod_path = name.replace(".", "/") + ".pyx"
        ext = Extension(name, [mod_path], language="c++", include_dirs=include_dirs)
        ext_modules.append(ext)
    print("Cythonizing sources")
    ext_modules = cythonize(ext_modules, compiler_directives=COMPILER_DIRECTIVES, language_level=2)

    setup(
        name="thinc",
        packages=PACKAGES,
        version=about["__version__"],
        ext_modules=ext_modules,
        cmdclass={"build_ext": build_ext_subclass},
        package_data={"": ["*.pyx", "*.pxd", "*.pxi", "*.cu", "*.hh"]},
    )


if __name__ == "__main__":
    setup_package()
        macros.append(('CHAR_NAME', "%s_" % name))
        macros.append(('CHAR_CNAME', "%s_" % name))
        src = os.path.join(src_dir, src_name)
        exe = compiler.cc
        if src.endswith('.S') and compiler.compiler_type == 'msvc':
            compiler.cc = exe.replace('cl.exe', 'ml64.exe')
            args.append('/Ta%s' % src)
        obj = compiler.compile([src], output_dir=src_dir,
                    macros=macros, include_dirs=self.include_dirs,
                    extra_postargs=args)
        compiler.cc = exe
        output = os.path.join(src_dir, name+'.' + obj[0].split('.')[-1])
        if os.path.exists(output):
            os.unlink(output)

<MSG> Unbreak compilation for linux

<DFF> @@ -160,14 +160,16 @@ class Openblas(Extension):
         macros.append(('CHAR_NAME', "%s_" % name))
         macros.append(('CHAR_CNAME', "%s_" % name))
         src = os.path.join(src_dir, src_name)
-        exe = compiler.cc
-        if src.endswith('.S') and compiler.compiler_type == 'msvc':
-            compiler.cc = exe.replace('cl.exe', 'ml64.exe')
-            args.append('/Ta%s' % src)
+        if compiler.compiler_tuple == 'msvc':
+            exe = compiler.cc
+            if src.endswith('.S') and compiler.compiler_type == 'msvc':
+                compiler.cc = exe.replace('cl.exe', 'ml64.exe')
+                args.append('/Ta%s' % src)
         obj = compiler.compile([src], output_dir=src_dir,
                     macros=macros, include_dirs=self.include_dirs,
                     extra_postargs=args)
-        compiler.cc = exe
+        if compiler.compiler_tuple == 'msvc':
+            compiler.cc = exe
         output = os.path.join(src_dir, name+'.' + obj[0].split('.')[-1])
         if os.path.exists(output):
             os.unlink(output)

{'addition_count': 7, 'commit_subject': 'Unbreak compilation for linux', 'deletion_count': 5, 'file_extension': '.py', 'lang': 'py', 'license': 'mit', 'repo_name': 'explosion/thinc'}