Hello community, here is the log from the commit of package python-llvmlite for openSUSE:Factory checked in at 2017-11-08 15:10:58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-llvmlite (Old) and /work/SRC/openSUSE:Factory/.python-llvmlite.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-llvmlite" Wed Nov 8 15:10:58 2017 rev:2 rq:539613 version:0.20.0 Changes: -------- --- /work/SRC/openSUSE:Factory/python-llvmlite/python-llvmlite.changes 2017-05-03 15:54:57.099186877 +0200 +++ /work/SRC/openSUSE:Factory/.python-llvmlite.new/python-llvmlite.changes 2017-11-08 15:13:53.097831447 +0100 @@ -1,0 +2,22 @@ +Mon Nov 6 15:44:28 UTC 2017 - [email protected] + +- Update to 0.20.0 + * Beginning with this minor release, we support wheels for Linux, OSX and Windows. + Pull requests related to enabling wheels are #294, #295, #296 and #297. + * There are also fixes to the documentation (#283 and #289). +- Update to 0.19.0 + * PR #281, Issue #280: Fix GEP addrspace issue + * PR #279: Fix #274 addrspace in gep + * PR #278: add Readthedocs badge + * PR #275: Add variables to pass through when doing conda-build + * PR #273: Fix the behavior of module.get_global + * PR #272: cmpop contains comparison type, not lhs + * PR #268, Fix #267: Support packed struct + * PR #277: Add pass through gcc flags for llvmdev + * PR #276: Remove jenkins build scripts +- Update to 0.18.0 + * This is a minor release that fixes several issues (#263, #262, #258, #237) with + the wheel build. In addition, we have minor fixes for running on PPC64LE + platforms (#261). And, we added CI testing against PyPy (#253). + +------------------------------------------------------------------- Old: ---- llvmlite-0.17.1.tar.gz New: ---- llvmlite-0.20.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-llvmlite.spec ++++++ --- /var/tmp/diff_new_pack.AQVH86/_old 2017-11-08 15:13:53.653811152 +0100 +++ /var/tmp/diff_new_pack.AQVH86/_new 2017-11-08 15:13:53.657811007 +0100 @@ -16,16 +16,11 @@ # -# There is a spurious error on ppc processors -%ifarch x86_64 %{ix86} -%bcond_without tests -%else -%bcond_with tests -%endif - %{?!python_module:%define python_module() python-%{**} python3-%{**}} +%bcond_without tests +ExcludeArch: armv7l Name: python-llvmlite -Version: 0.17.1 +Version: 0.20.0 Release: 0 Summary: Lightweight wrapper around basic LLVM functionality License: BSD-2-Clause @@ -48,7 +43,6 @@ %ifpython2 Requires: python-enum34 %endif -BuildRoot: %{_tmppath}/%{name}-%{version}-build %python_subpackages %description ++++++ llvmlite-0.17.1.tar.gz -> llvmlite-0.20.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llvmlite-0.17.1/PKG-INFO new/llvmlite-0.20.0/PKG-INFO --- old/llvmlite-0.17.1/PKG-INFO 2017-04-12 20:34:38.000000000 +0200 +++ new/llvmlite-0.20.0/PKG-INFO 2017-09-08 20:50:42.000000000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: llvmlite -Version: 0.17.1 +Version: 0.20.0 Summary: lightweight wrapper around basic LLVM functionality Home-page: http://llvmlite.pydata.org Author: Continuum Analytics, Inc. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llvmlite-0.17.1/README.rst new/llvmlite-0.20.0/README.rst --- old/llvmlite-0.17.1/README.rst 2017-03-28 20:16:54.000000000 +0200 +++ new/llvmlite-0.20.0/README.rst 2017-06-23 17:04:16.000000000 +0200 @@ -10,6 +10,9 @@ .. image:: https://coveralls.io/repos/github/numba/llvmlite/badge.svg :target: https://coveralls.io/github/numba/llvmlite :alt: Coveralls.io +.. image:: https://readthedocs.org/projects/llvmlite/badge/ + :target: https://llvmlite.readthedocs.io + :alt: Readthedocs.io A lightweight LLVM python binding for writing JIT compilers diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llvmlite-0.17.1/llvmlite/_version.py new/llvmlite-0.20.0/llvmlite/_version.py --- old/llvmlite-0.17.1/llvmlite/_version.py 2017-04-12 20:34:38.000000000 +0200 +++ new/llvmlite-0.20.0/llvmlite/_version.py 2017-09-08 20:50:42.000000000 +0200 @@ -4,8 +4,8 @@ # unpacked source archive. Distribution tarballs contain a pre-generated copy # of this file. -version_version = '0.17.1' -version_full = 'fab15866441e15a3e1a5249c089ff967bbdd9012' +version_version = '0.20.0' +version_full = '9ee27e85786ac3b23d32c0e5d844f1157e69df37' def get_versions(default={}, verbose=False): return {'version': version_version, 'full': version_full} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llvmlite-0.17.1/llvmlite/binding/_stub.c new/llvmlite-0.20.0/llvmlite/binding/_stub.c --- old/llvmlite-0.17.1/llvmlite/binding/_stub.c 2017-04-07 17:26:03.000000000 +0200 +++ new/llvmlite-0.20.0/llvmlite/binding/_stub.c 1970-01-01 01:00:00.000000000 +0100 @@ -1,32 +0,0 @@ -/* -An empty C-extension module to make bdist_wheel build an arch dependent build -*/ - -#include <Python.h> - -#if PY_MAJOR_VERSION >= 3 - #define MOD_ERROR_VAL NULL - #define MOD_SUCCESS_VAL(val) val - #define MOD_INIT(name) PyMODINIT_FUNC PyInit_##name(void) - #define MOD_DEF(ob, name, doc, methods) { \ - static struct PyModuleDef moduledef = { \ - PyModuleDef_HEAD_INIT, name, doc, -1, methods, }; \ - ob = PyModule_Create(&moduledef); } - #define MOD_INIT_EXEC(name) PyInit_##name(); -#else - #define MOD_ERROR_VAL - #define MOD_SUCCESS_VAL(val) - #define MOD_INIT(name) PyMODINIT_FUNC init##name(void) - #define MOD_DEF(ob, name, doc, methods) \ - ob = Py_InitModule3(name, methods, doc); - #define MOD_INIT_EXEC(name) init##name(); -#endif - - -MOD_INIT(_stub) { - PyObject *m; - MOD_DEF(m, "_stub", "No docs", NULL) - if (m == NULL) - return MOD_ERROR_VAL; - return MOD_SUCCESS_VAL(m); -} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llvmlite-0.17.1/llvmlite/ir/builder.py new/llvmlite-0.20.0/llvmlite/ir/builder.py --- old/llvmlite-0.17.1/llvmlite/ir/builder.py 2017-03-21 21:28:35.000000000 +0100 +++ new/llvmlite-0.20.0/llvmlite/ir/builder.py 2017-06-01 18:59:51.000000000 +0200 @@ -459,7 +459,7 @@ Signed integer comparison: name = lhs <cmpop> rhs - where lhs can be '==', '!=', '<', '<=', '>', '>=' + where cmpop can be '==', '!=', '<', '<=', '>', '>=' """ return self._icmp('s', cmpop, lhs, rhs, name) @@ -468,7 +468,7 @@ Unsigned integer (or pointer) comparison: name = lhs <cmpop> rhs - where lhs can be '==', '!=', '<', '<=', '>', '>=' + where cmpop can be '==', '!=', '<', '<=', '>', '>=' """ return self._icmp('u', cmpop, lhs, rhs, name) @@ -477,7 +477,7 @@ Floating-point ordered comparison: name = lhs <cmpop> rhs - where lhs can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno' + where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno' """ if cmpop in _CMP_MAP: op = 'o' + _CMP_MAP[cmpop] @@ -492,7 +492,7 @@ Floating-point unordered comparison: name = lhs <cmpop> rhs - where lhs can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno' + where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno' """ if cmpop in _CMP_MAP: op = 'u' + _CMP_MAP[cmpop] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llvmlite-0.17.1/llvmlite/ir/instructions.py new/llvmlite-0.20.0/llvmlite/ir/instructions.py --- old/llvmlite-0.17.1/llvmlite/ir/instructions.py 2017-03-21 21:28:35.000000000 +0100 +++ new/llvmlite-0.20.0/llvmlite/ir/instructions.py 2017-07-06 18:29:07.000000000 +0200 @@ -446,14 +446,18 @@ def __init__(self, parent, ptr, indices, inbounds, name): typ = ptr.type lasttyp = None + lastaddrspace = 0 for i in indices: lasttyp, typ = typ, typ.gep(i) + # inherit the addrspace from the last seen pointer + if isinstance(lasttyp, types.PointerType): + lastaddrspace = lasttyp.addrspace if (not isinstance(typ, types.PointerType) and isinstance(lasttyp, types.PointerType)): typ = lasttyp else: - typ = typ.as_pointer() + typ = typ.as_pointer(lastaddrspace) super(GEPInstr, self).__init__(parent, typ, "getelementptr", [ptr] + list(indices), name=name) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llvmlite-0.17.1/llvmlite/ir/module.py new/llvmlite-0.20.0/llvmlite/ir/module.py --- old/llvmlite-0.17.1/llvmlite/ir/module.py 2017-03-02 22:50:47.000000000 +0100 +++ new/llvmlite-0.20.0/llvmlite/ir/module.py 2017-06-01 18:59:51.000000000 +0200 @@ -135,7 +135,7 @@ """ Get a global value by name. """ - return self.globals.get(name) + return self.globals[name] def add_global(self, globalvalue): """ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llvmlite-0.17.1/llvmlite/ir/types.py new/llvmlite-0.20.0/llvmlite/ir/types.py --- old/llvmlite-0.17.1/llvmlite/ir/types.py 2017-03-21 21:28:35.000000000 +0100 +++ new/llvmlite-0.20.0/llvmlite/ir/types.py 2017-06-26 17:09:20.000000000 +0200 @@ -122,7 +122,7 @@ def _to_string(self): if self.addrspace != 0: - return "{0} addrspace({1})* ".format(self.pointee, self.addrspace) + return "{0} addrspace({1})*".format(self.pointee, self.addrspace) else: return "{0}*".format(self.pointee) @@ -395,6 +395,19 @@ """ The base type for heterogenous struct types. """ + _packed = False + + @property + def packed(self): + """ + A boolean attribute that indicates whether the structure uses + packed layout. + """ + return self._packed + + @packed.setter + def packed(self, val): + self._packed = bool(val) def __len__(self): assert self.elements is not None @@ -412,12 +425,14 @@ """ Return the LLVM IR for the structure representation """ - return '{%s}' % ', '.join([str(x) for x in self.elements]) + ret = '{%s}' % ', '.join([str(x) for x in self.elements]) + return self._wrap_packed(ret) def format_constant(self, value): itemstring = ", " .join(["{0} {1}".format(x.type, x.get_reference()) for x in value]) - return "{{{0}}}".format(itemstring) + ret = "{{{0}}}".format(itemstring) + return self._wrap_packed(ret) def gep(self, i): """ @@ -430,6 +445,15 @@ raise TypeError(i.type) return self.elements[i.constant] + def _wrap_packed(self, textrepr): + """ + Internal helper to wrap textual repr of struct type into packed struct + """ + if self.packed: + return '<{}>'.format(textrepr) + else: + return textrepr + class LiteralStructType(BaseStructType): """ @@ -439,8 +463,13 @@ null = 'zeroinitializer' - def __init__(self, elems): + def __init__(self, elems, packed=False): + """ + *elems* is a sequence of types to be used as members. + *packed* controls the use of packed layout. + """ self.elements = tuple(elems) + self.packed = packed def _to_string(self): return self.structure_repr() @@ -463,11 +492,17 @@ """ null = 'zeroinitializer' - def __init__(self, context, name): + def __init__(self, context, name, packed=False): + """ + *context* is a llvmlite.ir.Context. + *name* is the identifier for the new struct type. + *packed* controls the use of packed layout. + """ assert name self.context = context self.name = name self.elements = None + self.packed = packed def _to_string(self): return "%{name}".format(name=_wrapname(self.name)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llvmlite-0.17.1/llvmlite/ir/values.py new/llvmlite-0.20.0/llvmlite/ir/values.py --- old/llvmlite-0.17.1/llvmlite/ir/values.py 2017-03-21 21:28:35.000000000 +0100 +++ new/llvmlite-0.20.0/llvmlite/ir/values.py 2017-06-26 17:09:20.000000000 +0200 @@ -87,7 +87,7 @@ op = "getelementptr ({0}, {1} {2}, {3})".format( self.type.pointee, self.type, self.get_reference(), ', '.join(strindices)) - return FormattedConstant(outtype.as_pointer(), op) + return FormattedConstant(outtype.as_pointer(self.addrspace), op) class Value(object): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llvmlite-0.17.1/llvmlite/tests/test_binding.py new/llvmlite-0.20.0/llvmlite/tests/test_binding.py --- old/llvmlite-0.17.1/llvmlite/tests/test_binding.py 2017-03-28 20:16:54.000000000 +0200 +++ new/llvmlite-0.20.0/llvmlite/tests/test_binding.py 2017-05-26 19:59:45.000000000 +0200 @@ -11,6 +11,7 @@ import subprocess import sys import unittest +from contextlib import contextmanager from llvmlite import six, ir from llvmlite import binding as llvm @@ -188,7 +189,10 @@ self.fail("failed parsing dependencies? got %r" % (deps,)) # Ensure all dependencies are expected allowed = set(['librt', 'libdl', 'libpthread', 'libz', 'libm', - 'libgcc_s', 'libc', 'ld-linux']) + 'libgcc_s', 'libc', 'ld-linux', 'ld64']) + if platform.python_implementation() == 'PyPy': + allowed.add('libtinfo') + for dep in deps: if not dep.startswith('ld-linux-') and dep not in allowed: self.fail("unexpected dependency %r in %r" % (dep, deps)) @@ -890,6 +894,20 @@ pmb.disable_unroll_loops = b self.assertEqual(pmb.disable_unroll_loops, b) + def test_loop_vectorize(self): + pmb = self.pmb() + self.assertIsInstance(pmb.loop_vectorize, bool) + for b in (True, False): + pmb.loop_vectorize = b + self.assertEqual(pmb.loop_vectorize, b) + + def test_slp_vectorize(self): + pmb = self.pmb() + self.assertIsInstance(pmb.slp_vectorize, bool) + for b in (True, False): + pmb.slp_vectorize = b + self.assertEqual(pmb.slp_vectorize, b) + def test_populate_module_pass_manager(self): pmb = self.pmb() pm = llvm.create_module_pass_manager() @@ -1043,6 +1061,34 @@ self.assertNotIn(inst, dot_without_inst) +class TestTypeParsing(BaseTest): + @contextmanager + def check_parsing(self): + mod = ir.Module() + # Yield to caller and provide the module for adding + # new GV. + yield mod + # Caller yield back and continue with testing + asm = str(mod) + llvm.parse_assembly(asm) + + def test_literal_struct(self): + # Natural layout + with self.check_parsing() as mod: + typ = ir.LiteralStructType([ir.IntType(32)]) + gv = ir.GlobalVariable(mod, typ, "foo") + # Also test constant text repr + gv.initializer = ir.Constant(typ, [1]) + + # Packed layout + with self.check_parsing() as mod: + typ = ir.LiteralStructType([ir.IntType(32)], + packed=True) + gv = ir.GlobalVariable(mod, typ, "foo") + # Also test constant text repr + gv.initializer = ir.Constant(typ, [1]) + + class TestGlobalVariables(BaseTest): def check_global_variable_linkage(self, linkage, has_undef=True): # This test default initializer on global variables with different diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llvmlite-0.17.1/llvmlite/tests/test_ir.py new/llvmlite-0.20.0/llvmlite/tests/test_ir.py --- old/llvmlite-0.17.1/llvmlite/tests/test_ir.py 2017-03-21 21:28:35.000000000 +0100 +++ new/llvmlite-0.20.0/llvmlite/tests/test_ir.py 2017-07-06 18:29:07.000000000 +0200 @@ -412,7 +412,8 @@ globdouble = ir.GlobalVariable(mod, ir.DoubleType(), 'globdouble') self.assertEqual(mod.get_global('foo'), foo) self.assertEqual(mod.get_global('globdouble'), globdouble) - self.assertIsNone(mod.get_global('kkk')) + with self.assertRaises(KeyError): + mod.get_global('kkk') # Globals should have a useful repr() self.assertEqual(repr(globdouble), "<ir.GlobalVariable 'globdouble' of type 'double*'>") @@ -799,6 +800,61 @@ """) # XXX test with more complex types + def test_gep_castinstr(self): + # similar to: + # numba::runtime::nrtdynmod.py_define_nrt_meminfo_data() + block = self.block(name='my_block') + builder = ir.IRBuilder(block) + a, b = builder.function.args[:2] + int8ptr = int8.as_pointer() + ls = ir.LiteralStructType([int64, int8ptr, int8ptr, int8ptr, int64]) + d = builder.bitcast(a, ls.as_pointer(), name='d') + e = builder.gep(d, [ir.Constant(int32, x) for x in [0, 3]], name='e') + self.assertEqual(e.type, ir.PointerType(int8ptr)) + self.check_block(block, """\ + my_block: + %"d" = bitcast i32 %".1" to {i64, i8*, i8*, i8*, i64}* + %"e" = getelementptr {i64, i8*, i8*, i8*, i64}, {i64, i8*, i8*, i8*, i64}* %"d", i32 0, i32 3 + """) + + def test_gep_castinstr_addrspace(self): + # similar to: + # numba::runtime::nrtdynmod.py_define_nrt_meminfo_data() + block = self.block(name='my_block') + builder = ir.IRBuilder(block) + a, b = builder.function.args[:2] + addrspace = 4 + int8ptr = int8.as_pointer() + ls = ir.LiteralStructType([int64, int8ptr, int8ptr, int8ptr, int64]) + d = builder.bitcast(a, ls.as_pointer(addrspace=addrspace), name='d') + e = builder.gep(d, [ir.Constant(int32, x) for x in [0, 3]], name='e') + self.assertEqual(e.type.addrspace, addrspace) + self.assertEqual(e.type, ir.PointerType(int8ptr, addrspace=addrspace)) + self.check_block(block, """\ + my_block: + %"d" = bitcast i32 %".1" to {i64, i8*, i8*, i8*, i64} addrspace(4)* + %"e" = getelementptr {i64, i8*, i8*, i8*, i64}, {i64, i8*, i8*, i8*, i64} addrspace(4)* %"d", i32 0, i32 3 + """) + + def test_gep_addrspace(self): + block = self.block(name='my_block') + builder = ir.IRBuilder(block) + a, b = builder.function.args[:2] + addrspace = 4 + c = builder.alloca(ir.PointerType(int32, addrspace=addrspace), name='c') + self.assertEqual(str(c.type), 'i32 addrspace(4)**') + self.assertEqual(c.type.pointee.addrspace, addrspace) + d = builder.gep(c, [ir.Constant(int32, 5), a], name='d') + self.assertEqual(d.type.addrspace, addrspace) + e = builder.gep(d, [ir.Constant(int32, 10)], name='e') + self.assertEqual(e.type.addrspace, addrspace) + self.check_block(block, """\ + my_block: + %"c" = alloca i32 addrspace(4)* + %"d" = getelementptr i32 addrspace(4)*, i32 addrspace(4)** %"c", i32 5, i32 %".1" + %"e" = getelementptr i32, i32 addrspace(4)* %"d", i32 10 + """) + def test_extract_insert_value(self): block = self.block(name='my_block') builder = ir.IRBuilder(block) @@ -1434,6 +1490,10 @@ self.assertEqual(str(ir.LiteralStructType(( ir.PointerType(int1), ir.LiteralStructType((int32, int8))))), '{i1*, {i32, i8}}') + self.assertEqual(str(ir.LiteralStructType((int1,), packed=True)), + '<{i1}>') + self.assertEqual(str(ir.LiteralStructType((int1,flt), packed=True)), + '<{i1, float}>') # Avoid polluting the namespace context = ir.Context() @@ -1680,6 +1740,19 @@ 'getelementptr ({float, i1}, {float, i1}* @"myconstant", i32 0, i32 1)') self.assertEqual(c.type, ir.PointerType(int1)) + def test_gep_addrspace_globalvar(self): + m = self.module() + tp = ir.LiteralStructType((flt, int1)) + addrspace = 4 + + gv = ir.GlobalVariable(m, tp, "myconstant", addrspace=addrspace) + self.assertEqual(gv.addrspace, addrspace) + c = gv.gep([ir.Constant(int32, x) for x in (0, 1)]) + self.assertEqual(c.type.addrspace, addrspace) + self.assertEqual(str(c), + 'getelementptr ({float, i1}, {float, i1} addrspace(4)* @"myconstant", i32 0, i32 1)') + self.assertEqual(c.type, ir.PointerType(int1, addrspace=addrspace)) + def test_bitcast(self): m = self.module() gv = ir.GlobalVariable(m, int32, "myconstant") diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llvmlite-0.17.1/setup.py new/llvmlite-0.20.0/setup.py --- old/llvmlite-0.17.1/setup.py 2017-04-12 19:59:36.000000000 +0200 +++ new/llvmlite-0.20.0/setup.py 2017-08-31 21:36:57.000000000 +0200 @@ -41,6 +41,12 @@ build = cmdclass.get('build', build) build_ext = cmdclass.get('build_ext', build_ext) + +def build_library_files(dry_run): + cmd = [sys.executable, os.path.join(here_dir, 'ffi', 'build.py')] + spawn(cmd, dry_run=dry_run) + + class LlvmliteBuild(build): def finalize_options(self): @@ -62,8 +68,7 @@ def run(self): build_ext.run(self) - cmd = [sys.executable, os.path.join(here_dir, 'ffi', 'build.py')] - spawn(cmd, dry_run=self.dry_run) + build_library_files(self.dry_run) # HACK: this makes sure the library file (which is large) is only # included in binary builds, not source builds. from llvmlite.utils import get_library_files @@ -82,6 +87,12 @@ } install.run(self) + def finalize_options(self): + install.finalize_options(self) + # Force use of "platlib" dir for auditwheel to recognize this + # is a non-pure build + self.install_libbase = self.install_platlib + self.install_lib = self.install_platlib class LlvmliteClean(clean): """Custom clean command to tidy up the project root.""" @@ -111,18 +122,20 @@ if bdist_wheel: class LLvmliteBDistWheel(bdist_wheel): def run(self): + # Ensure the binding file exist when running wheel build from llvmlite.utils import get_library_files - # Hack to ensure the binding file exist when running wheel build - for fn in get_library_files(): - path = os.path.join('llvmlite', 'binding', fn) - if not os.path.isfile(path): - raise RuntimeError("missing {}".format(path)) + build_library_files(self.dry_run) self.distribution.package_data.update({ "llvmlite.binding": get_library_files(), }) # Run wheel build command bdist_wheel.run(self) + def finalize_options(self): + bdist_wheel.finalize_options(self) + # The build isn't platform-independent + self.root_is_pure = False + cmdclass.update({'build': LlvmliteBuild, 'build_ext': LlvmliteBuildExt, @@ -172,5 +185,4 @@ install_requires=install_requires, license="BSD", cmdclass=cmdclass, - ext_modules=[ext_stub] if not sys.platform.startswith('win32') else [], )
