def build(setup_kwargs): """ This function is mandatory in order to build the extensions. """ distribution = Distribution( { "name": "src/cupcake", "ext_modules": cythonize( extensions, compiler_directives={"language_level": "3"} ), } ) distribution.package_dir = "cupcake" cmd = ExtBuilder(distribution) cmd.ensure_finalized() cmd.run() # Copy built extensions back to the project for output in cmd.get_outputs(): output = Path(output) relative_extension = Path("src").joinpath(output.relative_to(cmd.build_lib)) if not output.exists(): continue shutil.copyfile(output, relative_extension) mode = relative_extension.stat().st_mode mode |= (mode & 0o444) >> 2 relative_extension.chmod(mode) return setup_kwargs
def _try_compile_deployment_target(self, operator, target): orig_environ = os.environ os.environ = orig_environ.copy() self.addCleanup(setattr, os, 'environ', orig_environ) if target is None: if os.environ.get('MACOSX_DEPLOYMENT_TARGET'): del os.environ['MACOSX_DEPLOYMENT_TARGET'] else: os.environ['MACOSX_DEPLOYMENT_TARGET'] = target deptarget_c = os.path.join(self.tmp_dir, 'deptargetmodule.c') with open(deptarget_c, 'w') as fp: fp.write(textwrap.dedent(' #include <AvailabilityMacros.h>\n\n int dummy;\n\n #if TARGET %s MAC_OS_X_VERSION_MIN_REQUIRED\n #else\n #error "Unexpected target"\n #endif\n\n ' % operator)) target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET') target = tuple(map(int, target.split('.'))) target = '%02d%01d0' % target deptarget_ext = Extension('deptarget', [deptarget_c], extra_compile_args=['-DTARGET=%s' % (target,)]) dist = Distribution({'name': 'deptarget', 'ext_modules': [deptarget_ext]}) dist.package_dir = self.tmp_dir cmd = build_ext(dist) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir try: cmd.ensure_finalized() cmd.run() except CompileError: self.fail('Wrong deployment target during compilation') return
def build(): cython_sources = [] cython_sources.extend(Path("aiotone").glob("*.pyx")) extensions = [ Extension( "aiotone." + path.with_suffix("").name, [str(path)], extra_compile_args=compile_args, extra_link_args=link_args, include_dirs=include_dirs, libraries=libraries, ) for path in cython_sources ] ext_modules = cythonize( extensions, include_path=include_dirs, compiler_directives={"binding": True, "language_level": 3}, ) distribution = Distribution({"name": "extended", "ext_modules": ext_modules}) distribution.package_dir = "extended" cmd = build_ext(distribution) cmd.ensure_finalized() cmd.run() # Copy built extensions back to the project for output in cmd.get_outputs(): relative_extension = os.path.relpath(output, cmd.build_lib) shutil.copyfile(output, relative_extension) mode = os.stat(relative_extension).st_mode mode |= (mode & 0o444) >> 2 os.chmod(relative_extension, mode)
def test_build_ext(self): xx_c = os.path.join(self.tmp_dir, 'xxmodule.c') xx_ext = Extension('xx', [xx_c]) dist = Distribution({'name': 'xx', 'ext_modules': [xx_ext]}) dist.package_dir = self.tmp_dir cmd = build_ext(dist) if os.name == "nt": # On Windows, we must build a debug version iff running # a debug build of Python cmd.debug = sys.executable.endswith("_d.exe") cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir old_stdout = sys.stdout if not test_support.verbose: # silence compiler output sys.stdout = StringIO() try: cmd.ensure_finalized() cmd.run() finally: sys.stdout = old_stdout import xx for attr in ('error', 'foo', 'new', 'roj'): self.assert_(hasattr(xx, attr)) self.assertEquals(xx.foo(2, 5), 7) self.assertEquals(xx.foo(13, 15), 28) self.assertEquals(xx.new().demo(), None) doc = 'This is a template module just for instruction.' self.assertEquals(xx.__doc__, doc) self.assert_(isinstance(xx.Null(), xx.Null)) self.assert_(isinstance(xx.Str(), xx.Str))
def test_build_ext(self): xx_c = os.path.join(self.tmp_dir, 'xxmodule.c') xx_ext = Extension('xx', [xx_c]) dist = Distribution({'name': 'xx', 'ext_modules': [xx_ext]}) dist.package_dir = self.tmp_dir cmd = build_ext(dist) if os.name == "nt": # On Windows, we must build a debug version iff running # a debug build of Python cmd.debug = sys.executable.endswith("_d.exe") cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir old_stdout = sys.stdout if not test_support.verbose: # silence compiler output sys.stdout = StringIO() try: cmd.ensure_finalized() cmd.run() finally: sys.stdout = old_stdout import xx for attr in ('error', 'foo', 'new', 'roj'): self.assert_(hasattr(xx, attr)) self.assertEquals(xx.foo(2, 5), 7) self.assertEquals(xx.foo(13,15), 28) self.assertEquals(xx.new().demo(), None) doc = 'This is a template module just for instruction.' self.assertEquals(xx.__doc__, doc) self.assert_(isinstance(xx.Null(), xx.Null)) self.assert_(isinstance(xx.Str(), xx.Str))
def _try_compile_deployment_target(self, operator, target): orig_environ = os.environ os.environ = orig_environ.copy() self.addCleanup(setattr, os, 'environ', orig_environ) if target is None: if os.environ.get('MACOSX_DEPLOYMENT_TARGET'): del os.environ['MACOSX_DEPLOYMENT_TARGET'] else: os.environ['MACOSX_DEPLOYMENT_TARGET'] = target deptarget_c = os.path.join(self.tmp_dir, 'deptargetmodule.c') with open(deptarget_c, 'w') as fp: fp.write( textwrap.dedent('''\ #include <AvailabilityMacros.h> int dummy; #if TARGET %s MAC_OS_X_VERSION_MIN_REQUIRED #else #error "Unexpected target" #endif ''' % operator)) # get the deployment target that the interpreter was built with target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET') target = tuple(map(int, target.split('.')[0:2])) # format the target value as defined in the Apple # Availability Macros. We can't use the macro names since # at least one value we test with will not exist yet. if target[1] < 10: # for 10.1 through 10.9.x -> "10n0" target = ('%02d%02d00' if target[1] >= 10 else '%02d%01d0') % target else: # for 10.10 and beyond -> "10nn00" target = '%02d%02d00' % target deptarget_ext = Extension( 'deptarget', [deptarget_c], extra_compile_args=['-DTARGET=%s' % (target, )], ) dist = Distribution({ 'name': 'deptarget', 'ext_modules': [deptarget_ext] }) dist.package_dir = self.tmp_dir cmd = build_ext(dist) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir try: cmd.ensure_finalized() cmd.run() except CompileError: self.fail("Wrong deployment target during compilation")
def _try_compile_deployment_target(self, operator, target): orig_environ = os.environ os.environ = orig_environ.copy() self.addCleanup(setattr, os, 'environ', orig_environ) if target is None: if os.environ.get('MACOSX_DEPLOYMENT_TARGET'): del os.environ['MACOSX_DEPLOYMENT_TARGET'] else: os.environ['MACOSX_DEPLOYMENT_TARGET'] = target deptarget_c = os.path.join(self.tmp_dir, 'deptargetmodule.c') with open(deptarget_c, 'w') as fp: fp.write( textwrap.dedent('''\ #include <AvailabilityMacros.h> int dummy; #if TARGET %s MAC_OS_X_VERSION_MIN_REQUIRED #else #error "Unexpected target" #endif ''' % operator)) # get the deployment target that the interpreter was built with target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET') target = tuple(map(int, target.split('.'))) target = '%02d%01d0' % target deptarget_ext = Extension( 'deptarget', [deptarget_c], extra_compile_args=['-DTARGET=%s' % (target, )], ) dist = Distribution({ 'name': 'deptarget', 'ext_modules': [deptarget_ext] }) dist.package_dir = self.tmp_dir cmd = build_ext(dist) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir try: old_stdout = sys.stdout if not support.verbose: # silence compiler output sys.stdout = StringIO() try: cmd.ensure_finalized() cmd.run() finally: sys.stdout = old_stdout except CompileError: self.fail("Wrong deployment target during compilation")
def test_build_ext(self): cmd = support.missing_compiler_executable() if cmd is not None: self.skipTest('The %r command is not found' % cmd) global ALREADY_TESTED copy_xxmodule_c(self.tmp_dir) xx_c = os.path.join(self.tmp_dir, 'xxmodule.c') xx_ext = Extension('xx', [xx_c]) dist = Distribution({'name': 'xx', 'ext_modules': [xx_ext]}) dist.package_dir = self.tmp_dir cmd = self.build_ext(dist) fixup_build_ext(cmd) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir old_stdout = sys.stdout if not support.verbose: # silence compiler output sys.stdout = StringIO() try: cmd.ensure_finalized() cmd.run() finally: sys.stdout = old_stdout if ALREADY_TESTED: self.skipTest('Already tested in %s' % ALREADY_TESTED) else: ALREADY_TESTED = type(self).__name__ code = textwrap.dedent(""" tmp_dir = {self.tmp_dir!r} import sys import unittest from test import support sys.path.insert(0, tmp_dir) import xx class Tests(unittest.TestCase): def test_xx(self): for attr in ('error', 'foo', 'new', 'roj'): self.assertTrue(hasattr(xx, attr)) self.assertEqual(xx.foo(2, 5), 7) self.assertEqual(xx.foo(13,15), 28) self.assertEqual(xx.new().demo(), None) if support.HAVE_DOCSTRINGS: doc = 'This is a template module just for instruction.' self.assertEqual(xx.__doc__, doc) self.assertIsInstance(xx.Null(), xx.Null) self.assertIsInstance(xx.Str(), xx.Str) unittest.main() """.format(**locals())) assert_python_ok('-c', code)
def _try_compile_deployment_target(self, operator, target): orig_environ = os.environ os.environ = orig_environ.copy() self.addCleanup(setattr, os, 'environ', orig_environ) if target is None: if os.environ.get('MACOSX_DEPLOYMENT_TARGET'): del os.environ['MACOSX_DEPLOYMENT_TARGET'] else: os.environ['MACOSX_DEPLOYMENT_TARGET'] = target deptarget_c = os.path.join(self.tmp_dir, 'deptargetmodule.c') with open(deptarget_c, 'w') as fp: fp.write(textwrap.dedent('''\ #include <AvailabilityMacros.h> int dummy; #if TARGET %s MAC_OS_X_VERSION_MIN_REQUIRED #else #error "Unexpected target" #endif ''' % operator)) # get the deployment target that the interpreter was built with target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET') target = tuple(map(int, target.split('.')[0:2])) # format the target value as defined in the Apple # Availability Macros. We can't use the macro names since # at least one value we test with will not exist yet. if target[1] < 10: # for 10.1 through 10.9.x -> "10n0" target = '%02d%01d0' % target else: # for 10.10 and beyond -> "10nn00" target = '%02d%02d00' % target deptarget_ext = Extension( 'deptarget', [deptarget_c], extra_compile_args=['-DTARGET=%s'%(target,)], ) dist = Distribution({ 'name': 'deptarget', 'ext_modules': [deptarget_ext] }) dist.package_dir = self.tmp_dir cmd = build_ext(dist) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir try: cmd.ensure_finalized() cmd.run() except CompileError: self.fail("Wrong deployment target during compilation")
def _try_compile_deployment_target(self, operator, target): orig_environ = os.environ os.environ = orig_environ.copy() self.addCleanup(setattr, os, 'environ', orig_environ) if target is None: if os.environ.get('MACOSX_DEPLOYMENT_TARGET'): del os.environ['MACOSX_DEPLOYMENT_TARGET'] else: os.environ['MACOSX_DEPLOYMENT_TARGET'] = target deptarget_c = os.path.join(self.tmp_dir, 'deptargetmodule.c') with open(deptarget_c, 'w') as fp: fp.write(textwrap.dedent('''\ #include <AvailabilityMacros.h> int dummy; #if TARGET %s MAC_OS_X_VERSION_MIN_REQUIRED #else #error "Unexpected target" #endif ''' % operator)) # get the deployment target that the interpreter was built with target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET') target = tuple(map(int, target.split('.'))) target = '%02d%01d0' % target deptarget_ext = Extension( 'deptarget', [deptarget_c], extra_compile_args=['-DTARGET=%s'%(target,)], ) dist = Distribution({ 'name': 'deptarget', 'ext_modules': [deptarget_ext] }) dist.package_dir = self.tmp_dir cmd = build_ext(dist) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir try: old_stdout = sys.stdout if not support.verbose: # silence compiler output sys.stdout = StringIO() try: cmd.ensure_finalized() cmd.run() finally: sys.stdout = old_stdout except CompileError: self.fail("Wrong deployment target during compilation")
def build(): include_dirs, extra_link_args = ocaml_config() compiler = sysconfig.get_config_var("CC") compiler = "" if compiler is None else compiler compileargs = sysconfig.get_config_var("CFLAGS") compileargs = "" if compileargs is None else compileargs if sys.platform != "win32": # Flag for array compileargs += " -Wno-unused-function" # Mute the ugly trick for value/value* compileargs += " -Wno-int-conversion" compileargs += " -Wno-incompatible-pointer-types" # assignment discards 'const' qualifier from pointer target type compileargs += " -Wno-discarded-qualifiers" extensions = [ Extension( "facile.core", ["facile/core.pyx", "interface/interface_c.c"], language="c", include_dirs=include_dirs, extra_compile_args=compileargs.split(), extra_link_args=extra_link_args, ) ] ext_modules = cythonize( extensions, compiler_directives={ "binding": True, "language_level": 3 }, ) distribution = Distribution({ "name": "extended", "ext_modules": ext_modules }) distribution.package_dir = "extended" cmd = build_ext.build_ext(distribution) cmd.verbose = True cmd.ensure_finalized() cmd.run() # Copy built extensions back to the project for output in cmd.get_outputs(): relative_extension = os.path.relpath(output, cmd.build_lib) shutil.copyfile(output, relative_extension) mode = os.stat(relative_extension).st_mode mode |= (mode & 0o444) >> 2 os.chmod(relative_extension, mode)
def test_package_data(self): sources = self.mkdtemp() f = open(os.path.join(sources, "__init__.py"), "w") try: f.write("# Pretend this is a package.") finally: f.close() f = open(os.path.join(sources, "README.txt"), "w") try: f.write("Info about this package") finally: f.close() destination = self.mkdtemp() dist = Distribution({ "packages": ["pkg"], "package_dir": { "pkg": sources } }) # script_name need not exist, it just need to be initialized dist.script_name = os.path.join(sources, "setup.py") dist.command_obj["build"] = support.DummyCommand(force=0, build_lib=destination) dist.packages = ["pkg"] dist.package_data = {"pkg": ["README.txt"]} dist.package_dir = {"pkg": sources} cmd = build_py(dist) cmd.compile = 1 cmd.ensure_finalized() self.assertEqual(cmd.package_data, dist.package_data) cmd.run() # This makes sure the list of outputs includes byte-compiled # files for Python modules but not for package data files # (there shouldn't *be* byte-code files for those!). self.assertEqual(len(cmd.get_outputs()), 3) pkgdest = os.path.join(destination, "pkg") files = os.listdir(pkgdest) pycache_dir = os.path.join(pkgdest, "__pycache__") self.assertIn("__init__.py", files) self.assertIn("README.txt", files) if sys.dont_write_bytecode: self.assertFalse(os.path.exists(pycache_dir)) else: pyc_files = os.listdir(pycache_dir) self.assertIn("__init__.%s.pyc" % sys.implementation.cache_tag, pyc_files)
def build(): cython_sources = [] cython_sources.extend(Path("aiotone").glob("*.pyx")) cpu_arch = platform.machine().lower() if "arm" in cpu_arch: compile_args = compile_args_arm elif "x86" in cpu_arch or "amd64" in cpu_arch: compile_args = compile_args_x86 else: print(f"warning: unknown machine arch {cpu_arch}; assuming Intel") compile_args = compile_args_x86 extensions = [ Extension( "aiotone." + path.with_suffix("").name, [str(path)], extra_compile_args=compile_args, extra_link_args=link_args, include_dirs=include_dirs, libraries=libraries, ) for path in cython_sources ] ext_modules = cythonize( extensions, include_path=include_dirs, compiler_directives={ "binding": True, "language_level": 3 }, ) distribution = Distribution({ "name": "extended", "ext_modules": ext_modules }) distribution.package_dir = "extended" cmd = build_ext(distribution) cmd.ensure_finalized() cmd.run() # Copy built extensions back to the project for output in cmd.get_outputs(): relative_extension = os.path.relpath(output, cmd.build_lib) shutil.copyfile(output, relative_extension) mode = os.stat(relative_extension).st_mode mode |= (mode & 0o444) >> 2 os.chmod(relative_extension, mode)
def build() -> None: distribution = Distribution({"name": "extended", "ext_modules": extensions}) distribution.package_dir = "extended" cmd = build_ext(distribution) cmd.ensure_finalized() cmd.run() # Copy built extensions back to the project for output in cmd.get_outputs(): relative_extension = os.path.relpath(output, cmd.build_lib) shutil.copyfile(output, relative_extension) mode = os.stat(relative_extension).st_mode mode |= (mode & 0o444) >> 2 os.chmod(relative_extension, mode)
def test_package_data(self): sources = self.mkdtemp() f = open(os.path.join(sources, "__init__.py"), "w") try: f.write("# Pretend this is a package.") finally: f.close() f = open(os.path.join(sources, "README.txt"), "w") try: f.write("Info about this package") finally: f.close() destination = self.mkdtemp() dist = Distribution({"packages": ["pkg"], "package_dir": {"pkg": sources}}) # script_name need not exist, it just need to be initialized dist.script_name = os.path.join(sources, "setup.py") dist.command_obj["build"] = support.DummyCommand( force=0, build_lib=destination) dist.packages = ["pkg"] dist.package_data = {"pkg": ["README.txt"]} dist.package_dir = {"pkg": sources} cmd = build_py(dist) cmd.compile = 1 cmd.ensure_finalized() self.assertEqual(cmd.package_data, dist.package_data) cmd.run() # This makes sure the list of outputs includes byte-compiled # files for Python modules but not for package data files # (there shouldn't *be* byte-code files for those!). self.assertEqual(len(cmd.get_outputs()), 3) pkgdest = os.path.join(destination, "pkg") files = os.listdir(pkgdest) pycache_dir = os.path.join(pkgdest, "__pycache__") self.assertIn("__init__.py", files) self.assertIn("README.txt", files) if sys.dont_write_bytecode: self.assertFalse(os.path.exists(pycache_dir)) else: pyc_files = os.listdir(pycache_dir) self.assertIn("__init__.%s.pyc" % sys.implementation.cache_tag, pyc_files)
def test_build_ext(self): global ALREADY_TESTED support.copy_xxmodule_c(self.tmp_dir) self.xx_created = True xx_c = os.path.join(self.tmp_dir, 'xxmodule.c') xx_ext = Extension('xx', [xx_c]) dist = Distribution({'name': 'xx', 'ext_modules': [xx_ext]}) dist.package_dir = self.tmp_dir cmd = build_ext(dist) support.fixup_build_ext(cmd) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir old_stdout = sys.stdout if not test_support.verbose: # silence compiler output sys.stdout = StringIO() try: cmd.ensure_finalized() #Broken after issue 7712(r78136) : add a temp_cwd context manager to test_support ... #Without current working dir: "...cannot find -lpython27" #NOTE: [py3k svn r85559] First (uncontroversial) part of issue 9807, barry.warsaw, 2010-10-16 : # new _fixup_command is bogus, so we will use own work-around cmd.library_dirs.insert(0, test_support.SAVEDCWD) cmd.run() finally: sys.stdout = old_stdout if ALREADY_TESTED: return else: ALREADY_TESTED = True import xx for attr in ('error', 'foo', 'new', 'roj'): self.assertTrue(hasattr(xx, attr)) self.assertEqual(xx.foo(2, 5), 7) self.assertEqual(xx.foo(13,15), 28) self.assertEqual(xx.new().demo(), None) if test_support.HAVE_DOCSTRINGS: doc = 'This is a template module just for instruction.' self.assertEqual(xx.__doc__, doc) self.assertTrue(isinstance(xx.Null(), xx.Null)) self.assertTrue(isinstance(xx.Str(), xx.Str))
def test_build_ext(self): global ALREADY_TESTED support.copy_xxmodule_c(self.tmp_dir) self.xx_created = True xx_c = os.path.join(self.tmp_dir, 'xxmodule.c') xx_ext = Extension('xx', [xx_c]) dist = Distribution({'name': 'xx', 'ext_modules': [xx_ext]}) dist.package_dir = self.tmp_dir cmd = build_ext(dist) support.fixup_build_ext(cmd) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir old_stdout = sys.stdout if not test_support.verbose: # silence compiler output sys.stdout = StringIO() try: cmd.ensure_finalized() #Broken after issue 7712(r78136) : add a temp_cwd context manager to test_support ... #Without current working dir: "...cannot find -lpython27" #NOTE: [py3k svn r85559] First (uncontroversial) part of issue 9807, barry.warsaw, 2010-10-16 : # new _fixup_command is bogus, so we will use own work-around cmd.library_dirs.insert(0, test_support.SAVEDCWD) cmd.run() finally: sys.stdout = old_stdout if ALREADY_TESTED: return else: ALREADY_TESTED = True import xx for attr in ('error', 'foo', 'new', 'roj'): self.assertTrue(hasattr(xx, attr)) self.assertEqual(xx.foo(2, 5), 7) self.assertEqual(xx.foo(13, 15), 28) self.assertEqual(xx.new().demo(), None) if test_support.HAVE_DOCSTRINGS: doc = 'This is a template module just for instruction.' self.assertEqual(xx.__doc__, doc) self.assertTrue(isinstance(xx.Null(), xx.Null)) self.assertTrue(isinstance(xx.Str(), xx.Str))
def build(): extensions = [ Extension( "cassiopeia.preprocess.collapse_cython", ["cassiopeia/preprocess/collapse_cython.pyx"], ), Extension( "cassiopeia.solver.ilp_solver_utilities", ["cassiopeia/solver/ilp_solver_utilities.pyx"], include_dirs=[numpy.get_include()], ), Extension( "cassiopeia.tools.branch_length_estimator._iid_exponential_bayesian", sources=[ "cassiopeia/tools/branch_length_estimator/_iid_exponential_bayesian.pyx", "cassiopeia/tools/branch_length_estimator/_iid_exponential_bayesian_cpp.cpp", ], extra_compile_args=[ "-std=c++17", "-Wall", "-Wextra", "-pedantic", "-O3", ], language="c++", ), ] ext_modules = cythonize( extensions, compiler_directives={"language_level": 3}, ) distribution = Distribution({"name": "extended", "ext_modules": ext_modules}) distribution.package_dir = "extended" cmd = build_ext(distribution) cmd.ensure_finalized() cmd.run() # Copy built extensions back to the project for output in cmd.get_outputs(): relative_extension = os.path.relpath(output, cmd.build_lib) shutil.copyfile(output, relative_extension) mode = os.stat(relative_extension).st_mode mode |= (mode & 0o444) >> 2 os.chmod(relative_extension, mode)
def test_package_data(self): sources = self.mkdtemp() f = open(os.path.join(sources, "__init__.py"), "w") f.write("# Pretend this is a package.") f.close() f = open(os.path.join(sources, "README.txt"), "w") f.write("Info about this package") f.close() destination = self.mkdtemp() dist = Distribution({ "packages": ["pkg"], "package_dir": { "pkg": sources } }) # script_name need not exist, it just need to be initialized dist.script_name = os.path.join(sources, "setup.py") dist.command_obj["build"] = support.DummyCommand(force=0, build_lib=destination) dist.packages = ["pkg"] dist.package_data = {"pkg": ["README.txt"]} dist.package_dir = {"pkg": sources} cmd = build_py(dist) cmd.compile = 1 cmd.ensure_finalized() self.assertEqual(cmd.package_data, dist.package_data) cmd.run() # This makes sure the list of outputs includes byte-compiled # files for Python modules but not for package data files # (there shouldn't *be* byte-code files for those!). # self.assertEqual(len(cmd.get_outputs()), 3) pkgdest = os.path.join(destination, "pkg") files = os.listdir(pkgdest) self.assert_("__init__.py" in files) if sys.platform.startswith('java'): self.assert_("__init__$py.class" in files, files) else: self.assert_("__init__.pyc" in files) self.assert_("README.txt" in files)
def build(): extensions = [ Extension('ffm2', ['fastfm2/core/ffm2.pyx'], libraries=['fastfm', 'solvers'], library_dirs=[ffm2_library_dir, ffm2_library_solvers_dir], include_dirs=[ 'fastfm2/core', ffm2_include_dir, ffm2_solvers_include_dir, numpy.get_include() ], extra_compile_args=['-std=c++11', '-Wall'], extra_link_args=['-std=c++11', '-mstackrealign'], language="c++") ] ext_modules = cythonize( extensions, compile_time_env=dict(EXTERNAL_RELEASE=True), compiler_directives={ 'binding': True, 'language_level': 3 }, ) distribution = Distribution({ 'name': 'fastfm2', 'ext_modules': ext_modules, 'package_data': { 'fastfm2': ['fastfm2/core/*.pxd'] }, 'version': get_version_from_pyproject(), }) distribution.package_dir = 'fastfm2' cmd = build_ext(distribution) cmd.ensure_finalized() cmd.run() # Copy built lib to project root for output in cmd.get_outputs(): relative_extension = os.path.relpath(output, cmd.build_lib) shutil.copyfile(output, relative_extension) mode = os.stat(relative_extension).st_mode mode |= (mode & 0o444) >> 2 os.chmod(relative_extension, mode)
def get_build_ext(name="zoot"): """ Naughty Zoot """ tmp_dir = "/tmp/enscons" # from distutils.test.test_build_ext.py : xx_c = os.path.join(tmp_dir, "xxmodule.c") xy_cpp = os.path.join(tmp_dir, "xymodule.cc") xx_ext = Extension("xx", [xx_c, xy_cpp]) dist = Distribution({"name": name, "ext_modules": [xx_ext]}) dist.package_dir = tmp_dir cmd = no_build_ext(dist) cmd.build_lib = tmp_dir cmd.build_temp = tmp_dir cmd.ensure_finalized() cmd.run() return cmd
def test_build_ext(self): cmd = support.missing_compiler_executable() if cmd is not None: self.skipTest('The %r command is not found' % cmd) global ALREADY_TESTED copy_xxmodule_c(self.tmp_dir) xx_c = os.path.join(self.tmp_dir, 'xxmodule.c') xx_ext = Extension('xx', [xx_c]) dist = Distribution({'name': 'xx', 'ext_modules': [xx_ext]}) dist.package_dir = self.tmp_dir cmd = self.build_ext(dist) fixup_build_ext(cmd) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir old_stdout = sys.stdout if not support.verbose: # silence compiler output sys.stdout = StringIO() try: cmd.ensure_finalized() cmd.run() finally: sys.stdout = old_stdout if ALREADY_TESTED: self.skipTest('Already tested in %s' % ALREADY_TESTED) else: ALREADY_TESTED = type(self).__name__ import xx for attr in ('error', 'foo', 'new', 'roj'): self.assertTrue(hasattr(xx, attr)) self.assertEqual(xx.foo(2, 5), 7) self.assertEqual(xx.foo(13,15), 28) self.assertEqual(xx.new().demo(), None) if support.HAVE_DOCSTRINGS: doc = 'This is a template module just for instruction.' self.assertEqual(xx.__doc__, doc) self.assertIsInstance(xx.Null(), xx.Null) self.assertIsInstance(xx.Str(), xx.Str)
def test_package_data(self): sources = self.mkdtemp() f = open(os.path.join(sources, '__init__.py'), 'w') try: f.write('# Pretend this is a package.') finally: f.close() f = open(os.path.join(sources, 'README.txt'), 'w') try: f.write('Info about this package') finally: f.close() destination = self.mkdtemp() dist = Distribution({ 'packages': ['pkg'], 'package_dir': { 'pkg': sources } }) dist.script_name = os.path.join(sources, 'setup.py') dist.command_obj['build'] = support.DummyCommand(force=0, build_lib=destination) dist.packages = ['pkg'] dist.package_data = {'pkg': ['README.txt']} dist.package_dir = {'pkg': sources} cmd = build_py(dist) cmd.compile = 1 cmd.ensure_finalized() self.assertEqual(cmd.package_data, dist.package_data) cmd.run() self.assertEqual(len(cmd.get_outputs()), 3) pkgdest = os.path.join(destination, 'pkg') files = os.listdir(pkgdest) pycache_dir = os.path.join(pkgdest, '__pycache__') self.assertIn('__init__.py', files) self.assertIn('README.txt', files) if sys.dont_write_bytecode: self.assertFalse(os.path.exists(pycache_dir)) else: pyc_files = os.listdir(pycache_dir) self.assertIn('__init__.%s.pyc' % sys.implementation.cache_tag, pyc_files)
def test_package_data(self): sources = self.mkdtemp() f = open(os.path.join(sources, "__init__.py"), "w") f.write("# Pretend this is a package.") f.close() f = open(os.path.join(sources, "README.txt"), "w") f.write("Info about this package") f.close() destination = self.mkdtemp() dist = Distribution({"packages": ["pkg"], "package_dir": {"pkg": sources}}) # script_name need not exist, it just need to be initialized dist.script_name = os.path.join(sources, "setup.py") dist.command_obj["build"] = support.DummyCommand( force=0, build_lib=destination) dist.packages = ["pkg"] dist.package_data = {"pkg": ["README.txt"]} dist.package_dir = {"pkg": sources} cmd = build_py(dist) cmd.compile = 1 cmd.ensure_finalized() self.assertEqual(cmd.package_data, dist.package_data) cmd.run() # This makes sure the list of outputs includes byte-compiled # files for Python modules but not for package data files # (there shouldn't *be* byte-code files for those!). # self.assertEqual(len(cmd.get_outputs()), 3) pkgdest = os.path.join(destination, "pkg") files = os.listdir(pkgdest) self.assert_("__init__.py" in files) if sys.platform.startswith('java'): self.assert_("__init__$py.class" in files, files) else: self.assert_("__init__.pyc" in files) self.assert_("README.txt" in files)
def test_build_ext(self): global ALREADY_TESTED support.copy_xxmodule_c(self.tmp_dir) self.xx_created = True xx_c = os.path.join(self.tmp_dir, 'xxmodule.c') xx_ext = Extension('xx', [xx_c]) dist = Distribution({'name': 'xx', 'ext_modules': [xx_ext]}) dist.package_dir = self.tmp_dir cmd = build_ext(dist) support.fixup_build_ext(cmd) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir old_stdout = sys.stdout if not test_support.verbose: # silence compiler output sys.stdout = StringIO() try: cmd.ensure_finalized() cmd.run() finally: sys.stdout = old_stdout if ALREADY_TESTED: self.skipTest('Already tested in %s' % ALREADY_TESTED) else: ALREADY_TESTED = type(self).__name__ import xx for attr in ('error', 'foo', 'new', 'roj'): self.assertTrue(hasattr(xx, attr)) self.assertEqual(xx.foo(2, 5), 7) self.assertEqual(xx.foo(13, 15), 28) self.assertEqual(xx.new().demo(), None) if test_support.HAVE_DOCSTRINGS: doc = 'This is a template module just for instruction.' self.assertEqual(xx.__doc__, doc) self.assertIsInstance(xx.Null(), xx.Null) self.assertIsInstance(xx.Str(), xx.Str)
def test_build_ext(self): global ALREADY_TESTED support.copy_xxmodule_c(self.tmp_dir) self.xx_created = True xx_c = os.path.join(self.tmp_dir, 'xxmodule.c') xx_ext = Extension('xx', [xx_c]) dist = Distribution({'name': 'xx', 'ext_modules': [xx_ext]}) dist.package_dir = self.tmp_dir cmd = build_ext(dist) support.fixup_build_ext(cmd) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir old_stdout = sys.stdout if not test_support.verbose: # silence compiler output sys.stdout = StringIO() try: cmd.ensure_finalized() cmd.run() finally: sys.stdout = old_stdout if ALREADY_TESTED: return else: ALREADY_TESTED = True import xx for attr in ('error', 'foo', 'new', 'roj'): self.assertTrue(hasattr(xx, attr)) self.assertEqual(xx.foo(2, 5), 7) self.assertEqual(xx.foo(13,15), 28) self.assertEqual(xx.new().demo(), None) if test_support.HAVE_DOCSTRINGS: doc = 'This is a template module just for instruction.' self.assertEqual(xx.__doc__, doc) self.assertTrue(isinstance(xx.Null(), xx.Null)) self.assertTrue(isinstance(xx.Str(), xx.Str))
def test_build_ext(self): global ALREADY_TESTED xx_c = os.path.join(self.tmp_dir, "xxmodule.c") xx_ext = Extension("xx", [xx_c]) dist = Distribution({"name": "xx", "ext_modules": [xx_ext]}) dist.package_dir = self.tmp_dir cmd = build_ext(dist) if os.name == "nt": # On Windows, we must build a debug version iff running # a debug build of Python cmd.debug = sys.executable.endswith("_d.exe") cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir old_stdout = sys.stdout if not test_support.verbose: # silence compiler output sys.stdout = StringIO() try: cmd.ensure_finalized() cmd.run() finally: sys.stdout = old_stdout if ALREADY_TESTED: return else: ALREADY_TESTED = True import xx for attr in ("error", "foo", "new", "roj"): self.assert_(hasattr(xx, attr)) self.assertEquals(xx.foo(2, 5), 7) self.assertEquals(xx.foo(13, 15), 28) self.assertEquals(xx.new().demo(), None) doc = "This is a template module just for instruction." self.assertEquals(xx.__doc__, doc) self.assert_(isinstance(xx.Null(), xx.Null)) self.assert_(isinstance(xx.Str(), xx.Str))
def _try_compile_deployment_target(self): deptarget_c = os.path.join(self.tmp_dir, 'deptargetmodule.c') with open(deptarget_c, 'w') as fp: fp.write( textwrap.dedent('''\ #include <AvailabilityMacros.h> int dummy; #if TARGET != MAC_OS_X_VERSION_MIN_REQUIRED #error "Unexpected target" #endif ''')) target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET') target = tuple(map(int, target.split('.'))) target = '%02d%01d0' % target deptarget_ext = Extension( 'deptarget', [deptarget_c], extra_compile_args=['-DTARGET=%s' % (target, )], ) dist = Distribution({ 'name': 'deptarget', 'ext_modules': [deptarget_ext] }) dist.package_dir = self.tmp_dir cmd = build_ext(dist) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir try: old_stdout = sys.stdout cmd.ensure_finalized() cmd.run() except CompileError: self.fail("Wrong deployment target during compilation")
def test_build_ext(self): global ALREADY_TESTED copy_xxmodule_c(self.tmp_dir) xx_c = os.path.join(self.tmp_dir, "xxmodule.c") xx_ext = Extension("xx", [xx_c]) dist = Distribution({"name": "xx", "ext_modules": [xx_ext]}) dist.package_dir = self.tmp_dir cmd = self.build_ext(dist) fixup_build_ext(cmd) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir old_stdout = sys.stdout if not support.verbose: # silence compiler output sys.stdout = StringIO() try: cmd.ensure_finalized() cmd.run() finally: sys.stdout = old_stdout if ALREADY_TESTED: self.skipTest("Already tested in %s" % ALREADY_TESTED) else: ALREADY_TESTED = type(self).__name__ import xx for attr in ("error", "foo", "new", "roj"): self.assertTrue(hasattr(xx, attr)) self.assertEqual(xx.foo(2, 5), 7) self.assertEqual(xx.foo(13, 15), 28) self.assertEqual(xx.new().demo(), None) if support.HAVE_DOCSTRINGS: doc = "This is a template module just for instruction." self.assertEqual(xx.__doc__, doc) self.assertIsInstance(xx.Null(), xx.Null) self.assertIsInstance(xx.Str(), xx.Str)
def _try_compile_deployment_target(self): deptarget_c = os.path.join(self.tmp_dir, 'deptargetmodule.c') with open(deptarget_c, 'w') as fp: fp.write(textwrap.dedent('''\ #include <AvailabilityMacros.h> int dummy; #if TARGET != MAC_OS_X_VERSION_MIN_REQUIRED #error "Unexpected target" #endif ''')) target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET') target = tuple(map(int, target.split('.'))) target = '%02d%01d0' % target deptarget_ext = Extension( 'deptarget', [deptarget_c], extra_compile_args=['-DTARGET=%s'%(target,)], ) dist = Distribution({ 'name': 'deptarget', 'ext_modules': [deptarget_ext] }) dist.package_dir = self.tmp_dir cmd = build_ext(dist) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir try: old_stdout = sys.stdout cmd.ensure_finalized() cmd.run() except CompileError: self.fail("Wrong deployment target during compilation")
def build(setup_kwargs: Dict[str, Any]) -> None: #cmake_modules = [CMakeExtension("project.package.pybind11_extension", sourcedir="project/package/pybind11_extension")] # 29 September 2020: Apparently setting the sourcedir, even if it's in a subdirectory, will breaks things. So don't set it! # 2 October 2020 TODO: Update fully to new poetry build system with: # - https://github.com/sdispater/pendulum/pull/488/files # - https://github.com/python-poetry/poetry/issues/2740 cmake_modules = [CMakeExtension("pyfastjet._src")] ext_modules = cmake_modules #setup_kwargs.update({ # "packages": find_packages(), # "ext_modules": ext_modules, # "cmdclass": dict(build_ext=ExtensionBuilder), # "zip_safe": False, #}) distribution = Distribution({ "name": "pyfastjet", "ext_modules": ext_modules }) distribution.package_dir = "pyfastjet" # More or less directly from https://github.com/python-poetry/poetry/issues/2740 cmd = ExtensionBuilder(distribution) cmd.ensure_finalized() cmd.run() # Copy built extensions back to the project for output in cmd.get_outputs(): relative_extension = os.path.relpath(output, cmd.build_lib) print(f"Copying {output} to {relative_extension}") shutil.copyfile(output, relative_extension) mode = os.stat(relative_extension).st_mode mode |= (mode & 0o444) >> 2 os.chmod(relative_extension, mode) #sys.exit(1) return setup_kwargs
def build(setup_kwargs): """ This function is mandatory in order to build the extensions. """ distribution = Distribution({"name": "pendulum", "ext_modules": extensions}) distribution.package_dir = "pendulum" cmd = ExtBuilder(distribution) cmd.ensure_finalized() cmd.run() # Copy built extensions back to the project for output in cmd.get_outputs(): relative_extension = os.path.relpath(output, cmd.build_lib) if not os.path.exists(output): continue shutil.copyfile(output, relative_extension) mode = os.stat(relative_extension).st_mode mode |= (mode & 0o444) >> 2 os.chmod(relative_extension, mode) return setup_kwargs
def build(): extensions = [ Extension( "*", ["poetry_cython_example/*.pyx"], extra_compile_args=compile_args, extra_link_args=link_args, include_dirs=include_dirs, libraries=libraries, ) ] ext_modules = cythonize( extensions, include_path=include_dirs, compiler_directives={ "binding": True, "language_level": 3 }, ) distribution = Distribution({ "name": "extended", "ext_modules": ext_modules }) distribution.package_dir = "extended" cmd = build_ext(distribution) cmd.ensure_finalized() cmd.run() # Copy built extensions back to the project for output in cmd.get_outputs(): relative_extension = os.path.relpath(output, cmd.build_lib) shutil.copyfile(output, relative_extension) mode = os.stat(relative_extension).st_mode mode |= (mode & 0o444) >> 2 os.chmod(relative_extension, mode)
def test_package_data(self): sources = self.mkdtemp() f = open(os.path.join(sources, '__init__.py'), 'w') try: f.write('# Pretend this is a package.') finally: f.close() f = open(os.path.join(sources, 'README.txt'), 'w') try: f.write('Info about this package') finally: f.close() destination = self.mkdtemp() dist = Distribution({'packages': ['pkg'], 'package_dir': {'pkg': sources}}) dist.script_name = os.path.join(sources, 'setup.py') dist.command_obj['build'] = support.DummyCommand(force=0, build_lib=destination) dist.packages = ['pkg'] dist.package_data = {'pkg': ['README.txt']} dist.package_dir = {'pkg': sources} cmd = build_py(dist) cmd.compile = 1 cmd.ensure_finalized() self.assertEqual(cmd.package_data, dist.package_data) cmd.run() self.assertEqual(len(cmd.get_outputs()), 3) pkgdest = os.path.join(destination, 'pkg') files = os.listdir(pkgdest) self.assertIn('__init__.py', files) self.assertIn('README.txt', files) if sys.dont_write_bytecode: self.assertNotIn('__init__.pyc', files) else: self.assertIn('__init__.pyc', files)
def _try_compile_deployment_target(self, operator, target): orig_environ = os.environ os.environ = orig_environ.copy() self.addCleanup(setattr, os, "environ", orig_environ) if target is None: if os.environ.get("MACOSX_DEPLOYMENT_TARGET"): del os.environ["MACOSX_DEPLOYMENT_TARGET"] else: os.environ["MACOSX_DEPLOYMENT_TARGET"] = target deptarget_c = os.path.join(self.tmp_dir, "deptargetmodule.c") with open(deptarget_c, "w") as fp: fp.write( textwrap.dedent( """\ #include <AvailabilityMacros.h> int dummy; #if TARGET %s MAC_OS_X_VERSION_MIN_REQUIRED #else #error "Unexpected target" #endif """ % operator ) ) # get the deployment target that the interpreter was built with target = sysconfig.get_config_var("MACOSX_DEPLOYMENT_TARGET") target = tuple(map(int, target.split(".")[0:2])) # format the target value as defined in the Apple # Availability Macros. We can't use the macro names since # at least one value we test with will not exist yet. if target[1] < 10: # for 10.1 through 10.9.x -> "10n0" target = "%02d%01d0" % target else: # for 10.10 and beyond -> "10nn00" target = "%02d%02d00" % target deptarget_ext = Extension("deptarget", [deptarget_c], extra_compile_args=["-DTARGET=%s" % (target,)]) dist = Distribution({"name": "deptarget", "ext_modules": [deptarget_ext]}) dist.package_dir = self.tmp_dir cmd = self.build_ext(dist) cmd.build_lib = self.tmp_dir cmd.build_temp = self.tmp_dir try: old_stdout = sys.stdout if not support.verbose: # silence compiler output sys.stdout = StringIO() try: cmd.ensure_finalized() cmd.run() finally: sys.stdout = old_stdout except CompileError: self.fail("Wrong deployment target during compilation")