def __enter__(self): self.save_path = os.environ.get('PATH', None) self.save_pythonpath = os.environ.get('PYTHONPATH', None) self.save_nousersite = os.environ.get('PYTHONNOUSERSITE', None) install_scheme = 'nt' if (os.name == 'nt') else 'posix_prefix' install_dirs = get_paths(install_scheme, vars={ 'base': self.path, 'platbase': self.path, }) scripts = install_dirs['scripts'] if self.save_path: os.environ['PATH'] = scripts + os.pathsep + self.save_path else: os.environ['PATH'] = scripts + os.pathsep + os.defpath # Note: prefer distutils' sysconfig to get the # library paths so PyPy is correctly supported. purelib = get_python_lib(plat_specific=0, prefix=self.path) platlib = get_python_lib(plat_specific=1, prefix=self.path) if purelib == platlib: lib_dirs = purelib else: lib_dirs = purelib + os.pathsep + platlib if self.save_pythonpath: os.environ['PYTHONPATH'] = lib_dirs + os.pathsep + \ self.save_pythonpath else: os.environ['PYTHONPATH'] = lib_dirs os.environ['PYTHONNOUSERSITE'] = '1' return self.path
def __init__(self): self.os = platform.system() self.check_permission() self.cwd = os.getcwd() if self.os == 'Windows': self.cwd = os.getcwd().replace('\\', '/') self.needed_execs = ('pyuic4', 'pylupdate4', 'lrelease-qt4') self.vars = { 'Linux': { 'data': '/usr/share/qt-project-creator', 'bin': '/usr/bin', 'docs': '/usr/share/doc/qt-project-creator', 'package': os.path.join(get_python_lib(), 'qtprojectcreator'), 'lib': get_python_lib(), 'exec': '/usr/bin/qt-project-creator.py' }, 'Windows': { 'data': 'C:/Program Files/qt-project-creator/data', 'docs': 'C:/Program Files/qt-project-creator/docs', 'bin': 'C:/Program Files/qt-project-creator/bin', 'exec': 'C:/Program Files/qt-project-creator/bin/qt-project-creator.py', 'package': os.path.join(get_python_lib(), 'qtprojectcreator').replace('\\', '/'), 'lib': get_python_lib().replace('\\', '/'), } } self.all_paths = (self.vars[self.os]['data'], self.vars[self.os]['docs'], \ self.vars[self.os]['package'], self.vars[self.os]['exec'] )
def main(): if sys.platform == 'win32': shutil.rmtree('%s\\pacparser' % sysconfig.get_python_lib(), ignore_errors=True) shutil.copytree('pacparser', '%s\\pacparser' % sysconfig.get_python_lib()) else: print('This script should be used only on Win32 systems.')
def main(): here = path.abspath(path.dirname(__file__)) print("Copying 'emoji.pth' to %s" % get_python_lib()) copyfile( path.join(here, 'emoji.pth'), path.join(get_python_lib(), 'emoji.pth') )
def minimum_path(cls): """ Return as a tuple the emulated sys.path and sys.path_importer_cache of a bare python installation, a la python -S. """ from site import USER_SITE from twitter.common.collections import OrderedSet from pkg_resources import find_distributions from distutils.sysconfig import get_python_lib site_libs = set([get_python_lib(plat_specific=False), get_python_lib(plat_specific=True)]) site_distributions = OrderedSet() for path_element in sys.path: if any(path_element.startswith(site_lib) for site_lib in site_libs): TRACER.log('Inspecting path element: %s' % path_element) site_distributions.update(dist.location for dist in find_distributions(path_element)) user_site_distributions = OrderedSet(dist.location for dist in find_distributions(USER_SITE)) for path in site_distributions: TRACER.log('Scrubbing from site-packages: %s' % path) for path in user_site_distributions: TRACER.log('Scrubbing from user site: %s' % path) scrub_paths = site_distributions | user_site_distributions scrubbed_sys_path = list(OrderedSet(sys.path) - scrub_paths) scrub_from_importer_cache = filter( lambda key: any(key.startswith(path) for path in scrub_paths), sys.path_importer_cache.keys()) scrubbed_importer_cache = dict((key, value) for (key, value) in sys.path_importer_cache.items() if key not in scrub_from_importer_cache) return scrubbed_sys_path, scrubbed_importer_cache
def run(self): install_system=platform.system(); path_to_charm2 = None; if install_system == 'Darwin': path_to_charm = get_python_lib(); elif install_system == 'Windows': path_to_charm = get_python_lib(); elif install_system == 'Linux': dist = platform.linux_distribution()[0]; if dist == 'Ubuntu' or dist == 'debian' or dist == 'LinuxMint': path_to_charm = get_python_lib(1, 1, '/usr/local') + '/dist-packages'; path_to_charm2 = get_python_lib(1, 1, '/usr/local') + '/site-packages'; elif dist == 'Fedora': path_to_charm = get_python_lib(1, 1, '/usr') + '/site-packages'; #print('python path =>', path_to_charm, _charm_version); shutil.rmtree(path_to_charm+'/__pycache__', True) shutil.rmtree(path_to_charm+'/compiler', True) shutil.rmtree(path_to_charm+'/schemes', True) shutil.rmtree(path_to_charm+'/toolbox', True) shutil.rmtree(path_to_charm+'/charm/engine', True) for files in os.listdir(path_to_charm): if not re.match('Charm_Crypto-'+_charm_version+'\.egg-info', files) and re.match('Charm_Crypto-.*\.egg-info', files): #print(path_to_charm+'/'+files) os.remove(path_to_charm+'/'+files) for files in os.listdir(path_to_charm+'/charm'): if re.match('.*\.so$', files): #print(path_to_charm+'/charm/'+files) os.remove(path_to_charm+'/charm/'+files)
def get_framework_python_dir_windows( vDictArgs ): dbg = utilsDebug.CDebugFnVerbose( "Python script get_framework_python_dir_windows()" ); bOk = True; strWkDir = ""; strErrMsg = ""; # We are being built by LLVM, so use the PYTHON_INSTALL_DIR argument, # and append the python version directory to the end of it. Depending # on the system other stuff may need to be put here as well. from distutils.sysconfig import get_python_lib; strPythonInstallDir = ""; bHaveArgPrefix = vDictArgs.has_key( "--prefix" ); if bHaveArgPrefix: strPythonInstallDir = vDictArgs[ "--prefix" ]; bHaveArgCmakeBuildConfiguration = vDictArgs.has_key( "--cmakeBuildConfiguration" ); if bHaveArgCmakeBuildConfiguration: strPythonInstallDir += '/' + vDictArgs[ "--cmakeBuildConfiguration" ]; if strPythonInstallDir.__len__() != 0: strWkDir = get_python_lib( True, False, strPythonInstallDir ); else: strWkDir = get_python_lib( True, False ); strWkDir += "/lldb"; strWkDir = os.path.normcase( strWkDir ); return (bOk, strWkDir, strErrMsg);
def set_platform_directories(): """Initialise the global variables relating to platform specific directories. """ global plat_py_site_dir, plat_py_inc_dir, plat_py_conf_inc_dir global plat_bin_dir, plat_py_lib_dir, plat_sip_dir # We trust distutils for some stuff. plat_py_site_dir = sysconfig.get_python_lib(plat_specific=1) plat_py_inc_dir = sysconfig.get_python_inc() plat_py_conf_inc_dir = os.path.dirname(sysconfig.get_config_h_filename()) if sys.platform == "win32": if sysconfig.python_build: try: plat_py_lib_dir = sysconfig.project_base + '\\PCBuild' except AttributeError: plat_py_lib_dir = sysconfig.get_python_inc() + '\\..\\pcbuild' else: plat_py_lib_dir = sys.prefix + "\\libs" plat_bin_dir = sys.exec_prefix plat_sip_dir = sys.prefix + "\\sip" else: lib_dir = sysconfig.get_python_lib(plat_specific=1, standard_lib=1) plat_py_lib_dir = lib_dir + "/config" plat_bin_dir = sys.exec_prefix + "/bin" plat_sip_dir = sys.prefix + "/share/sip"
def test_get_python_lib(self): lib_dir = sysconfig.get_python_lib() # XXX doesn't work on Linux when Python was never installed before #self.assertTrue(os.path.isdir(lib_dir), lib_dir) # test for pythonxx.lib? self.assertNotEqual(sysconfig.get_python_lib(), sysconfig.get_python_lib(prefix=TESTFN))
def get_framework_python_dir_windows(vDictArgs): dbg = utilsDebug.CDebugFnVerbose( "Python script get_framework_python_dir_windows()") bOk = True strWkDir = "" strErrMsg = "" # We are being built by LLVM, so use the PYTHON_INSTALL_DIR argument, # and append the python version directory to the end of it. Depending # on the system other stuff may need to be put here as well. from distutils.sysconfig import get_python_lib strPythonInstallDir = "" bHaveArgPrefix = "--prefix" in vDictArgs if bHaveArgPrefix: strPythonInstallDir = os.path.normpath(vDictArgs["--prefix"]) bHaveArgCmakeBuildConfiguration = "--cmakeBuildConfiguration" in vDictArgs if bHaveArgCmakeBuildConfiguration: strPythonInstallDir = os.path.join( strPythonInstallDir, vDictArgs["--cmakeBuildConfiguration"]) if strPythonInstallDir.__len__() != 0: strWkDir = get_python_lib(True, False, strPythonInstallDir) else: strWkDir = get_python_lib(True, False) strWkDir = os.path.normcase(os.path.join(strWkDir, "lldb")) return (bOk, strWkDir, strErrMsg)
def set_platform_directories(): """Initialise the global variables relating to platform specific directories. """ global plat_py_site_dir, plat_py_inc_dir, plat_py_conf_inc_dir global plat_bin_dir, plat_py_lib_dir, plat_sip_dir # We trust distutils for some stuff. if os.environ.get("CROSS_COMPILE") == "yes": ketlaer = os.environ.get("KETLAER") plat_py_site_dir = ketlaer + "/lib/python2.6/site-packages" plat_py_inc_dir = ketlaer + "/include/python2.6" plat_py_conf_inc_dir = ketlaer + "/include/python2.6" else: plat_py_site_dir = sysconfig.get_python_lib(plat_specific=1) plat_py_inc_dir = sysconfig.get_python_inc() plat_py_conf_inc_dir = os.path.dirname(sysconfig.get_config_h_filename()) if sys.platform == "win32": plat_py_lib_dir = sys.prefix + "\\libs" plat_bin_dir = sys.exec_prefix plat_sip_dir = sys.prefix + "\\sip" else: if os.environ.get("CROSS_COMPILE") == "yes": lib_dir = ketlaer + "/python/lib/python2.6" else: lib_dir = sysconfig.get_python_lib(plat_specific=1, standard_lib=1) plat_py_lib_dir = lib_dir + "/config" plat_bin_dir = sys.exec_prefix + "/bin" plat_sip_dir = sys.prefix + "/share/sip"
def get_python_module_path(options): """Returns the location where the lldb Python module should be placed. @param options dictionary of options parsed from the command line. @return the directory where the lldb module should be placed. """ if options.framework: # Caller wants to use the OS X framework packaging. # We are packaging in an OS X-style framework bundle. The # module dir will be within the # LLDB.framework/Resources/Python subdirectory. return os.path.join( options.target_dir, "LLDB.framework", "Resources", "Python", "lldb") else: from distutils.sysconfig import get_python_lib if options.prefix is not None: module_path = get_python_lib(True, False, options.prefix) else: module_path = get_python_lib(True, False) return os.path.normcase( os.path.join(module_path, "lldb"))
def get_existing_pip_installation(): """ returns current pip installation path """ if run("pip freeze|grep confine-controller", err_codes=[0,1]).return_code == 0: for lib_path in get_python_lib(), get_python_lib(prefix="/usr/local"): existing_path = os.path.abspath(os.path.join(lib_path, "controller")) if os.path.exists(existing_path): return existing_path return None
def site_libs(cls): site_libs = cls._get_site_packages() site_libs.update([sysconfig.get_python_lib(plat_specific=False), sysconfig.get_python_lib(plat_specific=True)]) # On windows getsitepackages() returns the python stdlib too. if sys.prefix in site_libs: site_libs.remove(sys.prefix) real_site_libs = set(os.path.realpath(path) for path in site_libs) return site_libs | real_site_libs
def get_existing_pip_installation(): """ returns current pip installation path """ if run("pip freeze|grep django-orchestra", valid_codes=(0,1)).exit_code == 0: for lib_path in get_python_lib(), get_python_lib(prefix="/usr/local"): existing_path = os.path.abspath(os.path.join(lib_path, "orchestra")) if os.path.exists(existing_path): return existing_path return None
def _site_libs(cls): try: from site import getsitepackages site_libs = set(getsitepackages()) except ImportError: site_libs = set() site_libs.update([sysconfig.get_python_lib(plat_specific=False), sysconfig.get_python_lib(plat_specific=True)]) return site_libs
def setup_variables(): add_path("LD_LIBRARY_PATH", config.lib_dir) add_path("PATH", config.bin_dir) add_path("XCURSOR_PATH", os.path.join(config.share_dir, "icons")) add_path("PKG_CONFIG_PATH", os.path.join(config.lib_dir, "pkgconfig")) add_path("PYTHONPATH", sysconfig.get_python_lib(prefix=config.install_dir)) add_path("PYTHONPATH", sysconfig.get_python_lib(prefix=config.install_dir, plat_specific=True)) add_path("PYTHONPATH", os.path.dirname(os.path.dirname(__file__))) add_path("ACLOCAL_PATH", "/usr/share/aclocal") add_path("ACLOCAL_FLAGS", "-I /usr/share/aclocal") add_path("XDG_DATA_DIRS", "/usr/share") add_path("XDG_DATA_DIRS", config.share_dir) add_path("XDG_CONFIG_DIRS", "/etc/xdg") add_path("XDG_CONFIG_DIRS", os.path.join(config.etc_dir, "xdg")) for system_lib_dir in config.system_lib_dirs: modules_path = os.path.join(system_lib_dir, "gio", "modules") if os.path.exists(modules_path): add_path("GIO_EXTRA_MODULES", modules_path) typelib_path = os.path.join(system_lib_dir, "girepository-1.0") if os.path.exists(typelib_path): add_path("GI_TYPELIB_PATH", typelib_path) add_path("GI_TYPELIB_PATH", os.path.join(config.lib_dir, "girepository-1.0")) os.environ["GTK_DATA_PREFIX"] = config.install_dir os.environ["GTK_PATH"] = os.path.join(config.lib_dir, "gtk-2.0") os.environ["CC"] = "ccache gcc" os.environ["CXX"] = "ccache g++" os.environ["GCONF_DEFAULT_SOURCE_PATH"] = _get_gconf_path() os.environ["GCONF_SCHEMA_INSTALL_SOURCE"] = \ "xml:merged:" + os.path.join(_get_gconf_dir(), "gconf.xml.defaults") cache_home_dir = os.path.join(config.home_dir, "cache") utils.ensure_dir(cache_home_dir) os.environ["XDG_CACHE_HOME"] = cache_home_dir data_home_dir = os.path.join(config.home_dir, "data") utils.ensure_dir(data_home_dir) os.environ["XDG_DATA_HOME"] = data_home_dir config_home_dir = os.path.join(config.home_dir, "config") utils.ensure_dir(config_home_dir) os.environ["XDG_CONFIG_HOME"] = config_home_dir
def test_get_python_lib(self): lib_dir = sysconfig.get_python_lib() # XXX doesn't work on Linux when Python was never installed before # self.assertTrue(os.path.isdir(lib_dir), lib_dir) # test for pythonxx.lib? self.assertNotEqual(sysconfig.get_python_lib(), sysconfig.get_python_lib(prefix=TESTFN)) _sysconfig = __import__("sysconfig") res = sysconfig.get_python_lib(True, True) self.assertEqual(_sysconfig.get_path("platstdlib"), res)
def configuration(parent_package='', top_path=None): from numpy.distutils.misc_util import Configuration config = Configuration('models', parent_package, top_path) include = os.path.join(get_python_lib(), 'compmech', 'include') lib = os.path.join(get_python_lib(), 'compmech', 'lib') if os.name == 'nt': runtime_library_dirs = None if os.environ.get('CONDA_DEFAULT_ENV') is not None: #NOTE removing openmp to compile in MiniConda args_linear = ['-O0'] args_nonlinear = ['-O0'] else: args_linear = ['/openmp'] args_nonlinear = ['/openmp', '/fp:fast'] else: runtime_library_dirs = [lib] if os.environ.get('CONDA_DEFAULT_ENV') is not None: #NOTE removing openmp to compile in MiniConda args_linear = ['-O0'] args_nonlinear = ['-O0'] else: args_linear = ['-fopenmp'] args_nonlinear = ['-fopenmp', '-ffast-math'] config.add_extension('bladestiff1d_clt_donnell_bardell', ['bladestiff1d_clt_donnell_bardell.pyx'], extra_compile_args=args_linear, runtime_library_dirs=runtime_library_dirs, include_dirs=[include], libraries=['bardell_functions', 'bardell'], library_dirs=[lib]) config.add_extension('bladestiff2d_clt_donnell_bardell', ['bladestiff2d_clt_donnell_bardell.pyx'], extra_compile_args=args_linear, runtime_library_dirs=runtime_library_dirs, include_dirs=[include], libraries=['bardell_functions', 'bardell'], library_dirs=[lib]) config.add_extension('tstiff2d_clt_donnell_bardell', ['tstiff2d_clt_donnell_bardell.pyx'], extra_compile_args=args_linear, runtime_library_dirs=runtime_library_dirs, include_dirs=[include], libraries=['bardell_functions', 'bardell', 'bardell_12', 'bardell_c0c1'], library_dirs=[lib]) cythonize(config.ext_modules) config.make_config_py() return config
def get_pth_path_for_module(module_name_full): """ Splits module name full into module name and version """ name, version = get_module_name_version(module_name_full) if not version: # Only module name is specified pth_file_name = os.path.join(get_python_lib(), name+".pth") else: # Module name and verion are specified pth_file_name = os.path.join(get_python_lib(), name+"-"+version+".pth") return pth_file_name
def getDataFiles(): import sys if sys.platform.startswith( "win" ): return [( get_python_lib(), [ "DUOLib.dll" ] )] elif sys.platform.startswith( "linux" ): return [( get_python_lib(), [ "libDUO.so" ] )] elif sys.platform.startswith( "dawrin" ): return [( get_python_lib(), [ "libDUO.dylib" ] )] else: return None
def __init__(self): # type: () -> None self._temp_dir = TempDirectory(kind="build-env") self._temp_dir.create() self._prefixes = OrderedDict(( (name, _Prefix(os.path.join(self._temp_dir.path, name))) for name in ('normal', 'overlay') )) self._bin_dirs = [] # type: List[str] self._lib_dirs = [] # type: List[str] for prefix in reversed(list(self._prefixes.values())): self._bin_dirs.append(prefix.bin_dir) self._lib_dirs.extend(prefix.lib_dirs) # Customize site to: # - ensure .pth files are honored # - prevent access to system site packages system_sites = { os.path.normcase(site) for site in ( get_python_lib(plat_specific=False), get_python_lib(plat_specific=True), ) } self._site_dir = os.path.join(self._temp_dir.path, 'site') if not os.path.exists(self._site_dir): os.mkdir(self._site_dir) with open(os.path.join(self._site_dir, 'sitecustomize.py'), 'w') as fp: fp.write(textwrap.dedent( ''' import os, site, sys # First, drop system-sites related paths. original_sys_path = sys.path[:] known_paths = set() for path in {system_sites!r}: site.addsitedir(path, known_paths=known_paths) system_paths = set( os.path.normcase(path) for path in sys.path[len(original_sys_path):] ) original_sys_path = [ path for path in original_sys_path if os.path.normcase(path) not in system_paths ] sys.path = original_sys_path # Second, add lib directories. # ensuring .pth file are processed. for path in {lib_dirs!r}: assert not path in sys.path site.addsitedir(path) ''' ).format(system_sites=system_sites, lib_dirs=self._lib_dirs))
def data_files(): """Build list of data files to be installed""" files = [] if os.name == "nt": os.chdir("bin") for (dp, dn, names) in os.walk("addons"): files.append((dp, map(lambda x: join("bin", dp, x), names))) os.chdir("..") # for root, _, names in os.walk(join('bin','addons')): # files.append((root, [join(root, name) for name in names])) for root, _, names in os.walk("doc"): files.append((root, [join(root, name) for name in names])) # for root, _, names in os.walk('pixmaps'): # files.append((root, [join(root, name) for name in names])) files.append((".", [join("bin", "import_xml.rng")])) else: man_directory = join("share", "man") files.append((join(man_directory, "man1"), ["man/openerp-server.1"])) files.append((join(man_directory, "man5"), ["man/openerp_serverrc.5"])) doc_directory = join("share", "doc", "openerp-server-%s" % version) files.append((doc_directory, filter(isfile, glob.glob("doc/*")))) files.append( (join(doc_directory, "migrate", "3.3.0-3.4.0"), filter(isfile, glob.glob("doc/migrate/3.3.0-3.4.0/*"))) ) files.append( (join(doc_directory, "migrate", "3.4.0-4.0.0"), filter(isfile, glob.glob("doc/migrate/3.4.0-4.0.0/*"))) ) openerp_site_packages = join(get_python_lib(prefix=""), "openerp-server") files.append((openerp_site_packages, [join("bin", "import_xml.rng")])) if sys.version_info[0:2] == (2, 5): files.append( ( openerp_site_packages, [ join("python25-compat", "BaseHTTPServer.py"), join("python25-compat", "SimpleXMLRPCServer.py"), join("python25-compat", "SocketServer.py"), ], ) ) for addonname, add_path in find_addons(): addon_path = join(get_python_lib(prefix=""), "openerp-server", "addons", addonname) for root, dirs, innerfiles in os.walk(add_path): innerfiles = filter(lambda fil: os.path.splitext(fil)[1] not in (".pyc", ".pyd", ".pyo"), innerfiles) if innerfiles: res = os.path.normpath(join(addon_path, root.replace(join(add_path), "."))) files.extend(((res, map(lambda fil: join(root, fil), innerfiles)),)) return files
def main(): server = config.Config().get_musicbrainz_server() musicbrainzngs.set_hostname(server) # Find whipper's plugins paths (local paths have higher priority) plugins_p = [directory.data_path('plugins')] # local path (in $HOME) if hasattr(sys, 'real_prefix'): # no getsitepackages() in virtualenv plugins_p.append( get_python_lib(plat_specific=False, standard_lib=False, prefix='/usr/local') + '/whipper/plugins') plugins_p.append(get_python_lib(plat_specific=False, standard_lib=False) + '/whipper/plugins') else: plugins_p += [x + '/whipper/plugins' for x in site.getsitepackages()] # register plugins with pkg_resources distributions, _ = pkg_resources.working_set.find_plugins( pkg_resources.Environment(plugins_p) ) list(map(pkg_resources.working_set.add, distributions)) try: cmd = Whipper(sys.argv[1:], os.path.basename(sys.argv[0]), None) ret = cmd.do() except SystemError as e: logger.critical("SystemError: %s", e) if (isinstance(e, common.EjectError) and cmd.options.eject in ('failure', 'always')): eject_device(e.device) return 255 except RuntimeError as e: print(e) return 1 except KeyboardInterrupt: return 2 except ImportError as e: raise except task.TaskException as e: if isinstance(e.exception, ImportError): raise ImportError(e.exception) elif isinstance(e.exception, common.MissingDependencyException): logger.critical('missing dependency "%s"', e.exception.dependency) return 255 if isinstance(e.exception, common.EmptyError): logger.debug("EmptyError: %s", e.exception) logger.critical('could not create encoded file') return 255 # in python3 we can instead do `raise e.exception` as that would show # the exception's original context logger.critical(e.exceptionMessage) return 255 return ret if ret else 0
def __init__(self, filename, guess_files=False): self.mainfile = os.path.abspath(filename) self.needed_files = [self.mainfile] self.mods = {} self.unknown_mods = [] self.guessed_mods = {} self.suggested_mods = {} self.list_installed() self.std_path = sysconfig.get_python_lib(standard_lib=True, prefix=os.path.realpath(sys.prefix)) self.std_path2 = sysconfig.get_python_lib(standard_lib=True) self.third_path = sysconfig.get_python_lib(standard_lib=False) self.guess_files = guess_files self.cal_deps(self.mainfile)
def _site_libs(cls): try: from site import getsitepackages site_libs = set(getsitepackages()) except ImportError: site_libs = set() site_libs.update([sysconfig.get_python_lib(plat_specific=False), sysconfig.get_python_lib(plat_specific=True)]) # On windows getsitepackages() returns the python stdlib too. if sys.prefix in site_libs: site_libs.remove(sys.prefix) real_site_libs = set(os.path.realpath(path) for path in site_libs) return site_libs | real_site_libs
def copy_system_selinux(force=True): try: print("Try import...") import selinux except ImportError as e: new_error = type(e)(e.message + ". Check that 'libselinux-python' is " "installed") import sys import shutil from distutils import sysconfig if hasattr(sys, 'real_prefix'): # check for venv VENV_SITE = sysconfig.get_python_lib() SELINUX_PATH = os.path.join( sysconfig.get_python_lib(plat_specific=True, prefix=sys.real_prefix), "selinux") dest = os.path.join(VENV_SITE, "selinux") if force: shutil.rmtree(dest, ignore_errors=True) elif os.path.exists(dest): raise new_error # filter precompiled files files = [os.path.join(SELINUX_PATH, f) for f in os.listdir(SELINUX_PATH) if not os.path.splitext(f)[1] in (".pyc", ".pyo")] # add extra file for (libselinux-python-2.5-9.fc24.x86_64) _selinux_file = os.path.join( sysconfig.get_python_lib(plat_specific=True, prefix=sys.real_prefix), "_selinux.so") if os.path.exists(_selinux_file): files.append(_selinux_file) os.makedirs(dest) for f in files: shutil.copy(f, dest) # add extra file for (libselinux-python-2.5-13.fc25.x86_64) _selinux_file = os.path.join( sysconfig.get_python_lib(plat_specific=True, prefix=sys.real_prefix), "_selinux.so") if os.path.exists(_selinux_file): shutil.copy(_selinux_file, os.path.dirname(dest)) else: raise new_error import selinux # noqa
def uninstall(): if is_system_wide_install(): prefix = None else: prefix = "/usr/local" for f in "iodef.py", "iodef.pyc", "_iodef.so": file = get_root() + "/" + get_python_lib(prefix=prefix) + "/" + f exists(file) and os.remove(file) file = get_root() + "/" + get_python_lib(plat_specific=True, prefix=prefix) + "/" + f exists(file) and os.remove(file) sys.exit(0)
def data_files(): '''Build list of data files to be installed''' files = [] if os.name == 'nt': files.append(('.', [join('bin', 'unifield-version.txt')])) os.chdir('bin') for (dp, dn, names) in os.walk('addons'): files.append((dp, map(lambda x: join('bin', dp, x), names))) os.chdir('..') #for root, _, names in os.walk(join('bin','addons')): # files.append((root, [join(root, name) for name in names])) for root, _, names in os.walk('doc'): files.append((root, [join(root, name) for name in names])) #for root, _, names in os.walk('pixmaps'): # files.append((root, [join(root, name) for name in names])) files.append(('.', [join('bin', 'import_xml.rng'),])) files.append(("Microsoft.VC90.CRT", glob.glob('C:\Microsoft.VC90.CRT\*.*'))) files.append((join('service','Microsoft.VC90.CRT'), glob.glob('C:\Microsoft.VC90.CRT\*.*'))) files.extend(fixup_data_pytz_zoneinfo()) else: man_directory = join('share', 'man') files.append((join(man_directory, 'man1'), ['man/openerp-server.1'])) files.append((join(man_directory, 'man5'), ['man/openerp_serverrc.5'])) doc_directory = join('share', 'doc', 'openerp-server-%s' % version) files.append((doc_directory, filter(isfile, glob.glob('doc/*')))) files.append((join(doc_directory, 'migrate', '3.3.0-3.4.0'), filter(isfile, glob.glob('doc/migrate/3.3.0-3.4.0/*')))) files.append((join(doc_directory, 'migrate', '3.4.0-4.0.0'), filter(isfile, glob.glob('doc/migrate/3.4.0-4.0.0/*')))) openerp_site_packages = join(get_python_lib(prefix=''), 'openerp-server') files.append((openerp_site_packages, [join('bin', 'import_xml.rng'),])) if sys.version_info[0:2] == (2,5): files.append((openerp_site_packages, [ join('python25-compat','BaseHTTPServer.py'), join('python25-compat','SimpleXMLRPCServer.py'), join('python25-compat','SocketServer.py')])) for addonname, add_path in find_addons(): addon_path = join(get_python_lib(prefix=''), 'openerp-server','addons', addonname) for root, dirs, innerfiles in os.walk(add_path): innerfiles = filter(lambda fil: os.path.splitext(fil)[1] not in ('.pyc', '.pyd', '.pyo'), innerfiles) if innerfiles: res = os.path.normpath(join(addon_path, root.replace(join(add_path), '.'))) files.extend(((res, map(lambda fil: join(root, fil), innerfiles)),)) return files
def setup_python_updates(): """Setup updates to Anaconda Python files.""" from distutils.sysconfig import get_python_lib import gi.overrides if "ANACONDA_WIDGETS_OVERRIDES" in os.environ: for p in os.environ["ANACONDA_WIDGETS_OVERRIDES"].split(":"): gi.overrides.__path__.insert(0, os.path.abspath(p)) # Temporary hack for F18 alpha to symlink updates and product directories # into tmpfs. To be removed after beta in order to directly use content # from /run/install/ -- JLK for dirname in ("updates", "product"): if os.path.exists("/run/install/%s" % dirname): if os.path.islink("/tmp/%s" % dirname): # Assume updates have already been setup return os.symlink("/run/install/%s" % dirname, "/tmp/%s" % dirname) if not os.path.exists("/tmp/updates"): return for pkg in os.listdir("/tmp/updates"): d = "/tmp/updates/%s" % pkg if not os.path.isdir(d): continue # See if the package exists in /usr/lib{64,}/python/?.?/site-packages. # If it does, we can set it up as an update. If not, the pkg is # likely a completely new directory and should not be looked at. dest = "%s/%s" % (get_python_lib(), pkg) if not os.access(dest, os.R_OK): dest = "%s/%s" % (get_python_lib(1), pkg) if not os.access(dest, os.R_OK): continue # Symlink over everything that's in the python libdir but not in # the updates directory. symlink_updates(dest, d) gi.overrides.__path__.insert(0, "/run/install/updates") import glob import shutil for rule in glob.glob("/tmp/updates/*.rules"): target = "/etc/udev/rules.d/" + rule.split('/')[-1] shutil.copyfile(rule, target)
def build_project(args): """ Build a dev version of the project. Returns ------- site_dir site-packages directory where it was installed """ import distutils.sysconfig root_ok = [ os.path.exists(os.path.join(ROOT_DIR, fn)) for fn in PROJECT_ROOT_FILES ] if not all(root_ok): print("To build the project, run runtests.py in " "git checkout or unpacked source") sys.exit(1) dst_dir = os.path.join(ROOT_DIR, 'build', 'testenv') env = dict(os.environ) cmd = [sys.executable, 'setup.py'] # Always use ccache, if installed env['PATH'] = os.pathsep.join(EXTRA_PATH + env.get('PATH', '').split(os.pathsep)) cvars = distutils.sysconfig.get_config_vars() compiler = env.get('CC') or cvars.get('CC', '') if 'gcc' in compiler: # Check that this isn't clang masquerading as gcc. if sys.platform != 'darwin' or 'gnu-gcc' in compiler: # add flags used as werrors warnings_as_errors = ' '.join([ # from tools/travis-test.sh '-Werror=vla', '-Werror=nonnull', '-Werror=pointer-arith', '-Wlogical-op', # from sysconfig '-Werror=unused-function', ]) env['CFLAGS'] = warnings_as_errors + ' ' + env.get('CFLAGS', '') if args.debug or args.gcov: # assume everyone uses gcc/gfortran env['OPT'] = '-O0 -ggdb' env['FOPT'] = '-O0 -ggdb' if args.gcov: env['OPT'] = '-O0 -ggdb' env['FOPT'] = '-O0 -ggdb' env['CC'] = cvars['CC'] + ' --coverage' env['CXX'] = cvars['CXX'] + ' --coverage' env['F77'] = 'gfortran --coverage ' env['F90'] = 'gfortran --coverage ' env['LDSHARED'] = cvars['LDSHARED'] + ' --coverage' env['LDFLAGS'] = " ".join( cvars['LDSHARED'].split()[1:]) + ' --coverage' cmd += ["build"] if args.parallel > 1: cmd += ["-j", str(args.parallel)] if args.debug_configure: cmd += ["build_src", "--verbose"] if args.warn_error: cmd += ["--warn-error"] # Install; avoid producing eggs so numpy can be imported from dst_dir. cmd += [ 'install', '--prefix=' + dst_dir, '--single-version-externally-managed', '--record=' + dst_dir + 'tmp_install_log.txt' ] from distutils.sysconfig import get_python_lib site_dir = get_python_lib(prefix=dst_dir, plat_specific=True) site_dir_noarch = get_python_lib(prefix=dst_dir, plat_specific=False) # easy_install won't install to a path that Python by default cannot see # and isn't on the PYTHONPATH. Plus, it has to exist. if not os.path.exists(site_dir): os.makedirs(site_dir) if not os.path.exists(site_dir_noarch): os.makedirs(site_dir_noarch) env['PYTHONPATH'] = site_dir + ':' + site_dir_noarch log_filename = os.path.join(ROOT_DIR, 'build.log') if args.show_build_log: ret = subprocess.call(cmd, env=env, cwd=ROOT_DIR) else: log_filename = os.path.join(ROOT_DIR, 'build.log') print("Building, see build.log...") with open(log_filename, 'w') as log: p = subprocess.Popen(cmd, env=env, stdout=log, stderr=log, cwd=ROOT_DIR) try: # Wait for it to finish, and print something to indicate the # process is alive, but only if the log file has grown (to # allow continuous integration environments kill a hanging # process accurately if it produces no output) last_blip = time.time() last_log_size = os.stat(log_filename).st_size while p.poll() is None: time.sleep(0.5) if time.time() - last_blip > 60: log_size = os.stat(log_filename).st_size if log_size > last_log_size: print(" ... build in progress") last_blip = time.time() last_log_size = log_size ret = p.wait() except: p.kill() p.wait() raise if ret == 0: print("Build OK") else: if not args.show_build_log: with open(log_filename, 'r') as f: print(f.read()) print("Build failed!") sys.exit(1) return site_dir, site_dir_noarch
def customize(self, dist=None): """Customize Fortran compiler. This method gets Fortran compiler specific information from (i) class definition, (ii) environment, (iii) distutils config files, and (iv) command line (later overrides earlier). This method should be always called after constructing a compiler instance. But not in __init__ because Distribution instance is needed for (iii) and (iv). """ log.info("customize %s" % (self.__class__.__name__)) self._is_customised = True self.distutils_vars.use_distribution(dist) self.command_vars.use_distribution(dist) self.flag_vars.use_distribution(dist) self.update_executables() # find_executables takes care of setting the compiler commands, # version_cmd, linker_so, linker_exe, ar, and ranlib self.find_executables() noopt = self.distutils_vars.get("noopt", False) noarch = self.distutils_vars.get("noarch", noopt) debug = self.distutils_vars.get("debug", False) f77 = self.command_vars.compiler_f77 f90 = self.command_vars.compiler_f90 f77flags = [] f90flags = [] freeflags = [] fixflags = [] if f77: f77 = _shell_utils.NativeParser.split(f77) f77flags = self.flag_vars.f77 if f90: f90 = _shell_utils.NativeParser.split(f90) f90flags = self.flag_vars.f90 freeflags = self.flag_vars.free # XXX Assuming that free format is default for f90 compiler. fix = self.command_vars.compiler_fix # NOTE: this and similar examples are probably just # excluding --coverage flag when F90 = gfortran --coverage # instead of putting that flag somewhere more appropriate # this and similar examples where a Fortran compiler # environment variable has been customized by CI or a user # should perhaps eventually be more thoroughly tested and more # robustly handled if fix: fix = _shell_utils.NativeParser.split(fix) fixflags = self.flag_vars.fix + f90flags oflags, aflags, dflags = [], [], [] # examine get_flags_<tag>_<compiler> for extra flags # only add them if the method is different from get_flags_<tag> def get_flags(tag, flags): # note that self.flag_vars.<tag> calls self.get_flags_<tag>() flags.extend(getattr(self.flag_vars, tag)) this_get = getattr(self, "get_flags_" + tag) for name, c, flagvar in [ ("f77", f77, f77flags), ("f90", f90, f90flags), ("f90", fix, fixflags), ]: t = "%s_%s" % (tag, name) if c and this_get is not getattr(self, "get_flags_" + t): flagvar.extend(getattr(self.flag_vars, t)) if not noopt: get_flags("opt", oflags) if not noarch: get_flags("arch", aflags) if debug: get_flags("debug", dflags) fflags = self.flag_vars.flags + dflags + oflags + aflags if f77: self.set_commands(compiler_f77=f77 + f77flags + fflags) if f90: self.set_commands(compiler_f90=f90 + freeflags + f90flags + fflags) if fix: self.set_commands(compiler_fix=fix + fixflags + fflags) # XXX: Do we need LDSHARED->SOSHARED, LDFLAGS->SOFLAGS linker_so = self.linker_so if linker_so: linker_so_flags = self.flag_vars.linker_so if sys.platform.startswith("aix"): python_lib = get_python_lib(standard_lib=1) ld_so_aix = os.path.join(python_lib, "config", "ld_so_aix") python_exp = os.path.join(python_lib, "config", "python.exp") linker_so = [ld_so_aix] + linker_so + ["-bI:" + python_exp] self.set_commands(linker_so=linker_so + linker_so_flags) linker_exe = self.linker_exe if linker_exe: linker_exe_flags = self.flag_vars.linker_exe self.set_commands(linker_exe=linker_exe + linker_exe_flags) ar = self.command_vars.archiver if ar: arflags = self.flag_vars.ar self.set_commands(archiver=[ar] + arflags) self.set_library_dirs(self.get_library_dirs()) self.set_libraries(self.get_libraries())
$ python -m pip install --upgrade pip setuptools $ python -m pip install django This will install the latest version of Django which works on your version of Python. If you can't upgrade your pip (or Python), request an older version of Django: $ python -m pip install "django<2" """.format(*(REQUIRED_PYTHON + CURRENT_PYTHON))) sys.exit(1) # Warn if we are installing over top of an existing installation. This can # cause issues where files that were deleted from a more recent Django are # still present in site-packages. See #18115. overlay_warning = False if "install" in sys.argv: lib_paths = [get_python_lib()] if lib_paths[0].startswith("/usr/lib/"): # We have to try also with an explicit prefix of /usr/local in order to # catch Debian's custom user site-packages directory. lib_paths.append(get_python_lib(prefix="/usr/local")) for lib_path in lib_paths: existing_path = os.path.abspath(os.path.join(lib_path, "Fall")) if os.path.exists(existing_path): # We note the need for the warning here, but present it after the # command is run, so it's more likely to be seen. overlay_warning = True break setup()
def _get_purelib(): return get_python_lib(False)
import distutils.sysconfig as sysconfig import os std_lib = sysconfig.get_python_lib(standard_lib=True) for top, dirs, files in os.walk(std_lib): for nm in sorted(files): if nm != '__init__.py' and nm[-3:] == '.py': print( os.path.join(top, nm)[len(std_lib) + 1:-3].replace('\\', '.'))
# populate search directories and lists of allowed file extensions # depending on the platform we're running on. if os.name == 'posix': additional_dirs.append('./') additional_dirs.append('/usr/lib/') additional_dirs.append('/usr/lib/x86_64-linux-gnu/') additional_dirs.append('/usr/local/lib/') if 'LD_LIBRARY_PATH' in os.environ: additional_dirs.extend( [item for item in os.environ['LD_LIBRARY_PATH'].split(':') if item]) # check if running from anaconda. if "conda" or "continuum" in sys.version.lower(): cur_path = get_python_lib() pattern = re.compile('.*\/lib\/') conda_lib = pattern.match(cur_path).group() logger.info("Adding Anaconda lib path:" + conda_lib) additional_dirs.append(conda_lib) # note - this won't catch libassimp.so.N.n, but # currently there's always a symlink called # libassimp.so in /usr/local/lib. ext_whitelist.append('.so') # libassimp.dylib in /usr/local/lib ext_whitelist.append('.dylib') elif os.name == 'nt': ext_whitelist.append('.dll') path_dirs = os.environ['PATH'].split(';')
def pg_version(): """Return the PostgreSQL version as a tuple of integers.""" match = re.search(r'(\d+)\.(\d+)', pg_config('version')) if match: return tuple(map(int, match.groups())) return (9, 0) pg_version = pg_version() libraries = ['pq'] # Make sure that the Python header files are searched before # those of PostgreSQL, because PostgreSQL can have its own Python.h include_dirs = [get_python_inc(), pg_config('includedir')] library_dirs = [get_python_lib(), pg_config('libdir')] define_macros = [('PYGRESQL_VERSION', version)] undef_macros = [] extra_compile_args = ['-O2', '-funsigned-char'] class build_pg_ext(build_ext): """Customized build_ext command for PyGreSQL.""" description = "build the PyGreSQL C extension" user_options = build_ext.user_options + [ ('direct-access', None, "enable direct access functions"), ('large-objects', None, "enable large object support"), ('default-vars', None, "enable default variables use"), ('escaping-funcs', None, "enable string escaping functions")
# FindSIP.py # # Copyright (c) 2007, Simon Edwards <*****@*****.**> # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. try: import sipbuild except ImportError: # Code for SIP v4 import sipconfig sipcfg = sipconfig.Configuration() print("sip_version:%06.0x" % sipcfg.sip_version) print("sip_version_str:%s" % sipcfg.sip_version_str) print("sip_bin:%s" % sipcfg.sip_bin) print("default_sip_dir:%s" % sipcfg.default_sip_dir) print("sip_inc_dir:%s" % sipcfg.sip_inc_dir) else: # Code for SIP v5 print("sip_version:%06.0x" % sipbuild.version.SIP_VERSION) print("sip_version_str:%s" % sipbuild.version.SIP_VERSION_STR) import shutil print("sip_bin:%s" % shutil.which("sip5")) from distutils.sysconfig import get_python_lib python_modules_dir = get_python_lib(plat_specific=1) print("default_sip_dir:%s" % python_modules_dir)
# # Main section # info("") info("Building PySlurm (%s)" % __version__) info("------------------------------") info("") if sys.version_info[:2] < (2, 6): fatal("PySlurm %s requires Python version 2.6 or later (%d.%d detected)." % (__version__, sys.version_info[:2])) compiler_dir = os.path.join(get_python_lib(prefix=''), 'src/pyslurm/') CyVersion_min = "0.21" try: from Cython.Distutils import build_ext from Cython.Compiler.Version import version as CyVersion info("Cython version %s installed\n" % CyVersion) if CyVersion < CyVersion_min: fatal("Please use Cython version >= %s" % CyVersion_min) except: fatal("Cython (www.cython.org) is required to build PySlurm") fatal("Please use Cython version >= %s" % CyVersion_min) #
from __future__ import print_function from ctypes import * from distutils.sysconfig import get_python_lib from os import path try: d = path.dirname(__file__) lib = cdll.LoadLibrary("%s/libpyZipHMM.so" % (d)) library_location = "%s/libpyZipHMM.so" % (d) except OSError: python_lib = get_python_lib() lib = cdll.LoadLibrary(python_lib + "/libpyZipHMM.so") library_location = python_lib + "/libpyZipHMM.so" except OSError as e: print("Error: pyZipHMM not found:") print("\t libpyZipHMM.so missing") print("Looked at:", python_lib, '/libpyZipHMM.so and ./libpyZipHMM.so') print("{0}: {1}".format(e.errno, e.strerror)) exit(-1) ## HMM IO def readHMMspec(filename): nStates = c_uint() nObservables = c_uint() lib.c_read_HMM_spec( byref(nStates), byref(nObservables), c_char_p(filename.encode('utf-8') if six.PY3 else filename)) return (nStates, nObservables)
def sitepackagesdir(envdir): from distutils.sysconfig import get_python_lib return dict(dir=get_python_lib(prefix=envdir))
Operating System :: Microsoft :: Windows Operating System :: POSIX Operating System :: MacOS Topic :: Office/Business """ if len(sys.argv) < 2: print "Syntax: setup.py command [options]" sys.exit(2) command = sys.argv[1] # create startup script if os.name != 'nt': start_script = "cd %s/Planta\nexec %s ./planta.py $@\n" % ( get_python_lib(), sys.executable) # write script f = open('planta.sh', 'w') f.write(start_script) f.close() script_files = ['planta.sh'] else: script_files = [] packages = [ 'NanScan', 'NanScan.Generics', 'NanScan.Backends', 'Planta',
"The folder you are executing pip from can no longer be found.") # under macOS + virtualenv sys.prefix is not properly resolved # it is something like /path/to/python/bin/.. # Note: using realpath due to tmp dirs on OSX being symlinks src_prefix = os.path.abspath(src_prefix) # FIXME doesn't account for venv linked to global site-packages site_packages = sysconfig.get_path("purelib") # type: Optional[str] # This is because of a bug in PyPy's sysconfig module, see # https://bitbucket.org/pypy/pypy/issues/2506/sysconfig-returns-incorrect-paths # for more information. if platform.python_implementation().lower() == "pypy": site_packages = distutils_sysconfig.get_python_lib() try: # Use getusersitepackages if this is present, as it ensures that the # value is initialised properly. user_site = site.getusersitepackages() except AttributeError: user_site = site.USER_SITE user_dir = expanduser('~') if WINDOWS: bin_py = os.path.join(sys.prefix, 'Scripts') bin_user = os.path.join(user_site, 'Scripts') # buildout uses 'bin' on Windows too? if not os.path.exists(bin_py): bin_py = os.path.join(sys.prefix, 'bin') bin_user = os.path.join(user_site, 'bin')
def customize(self, dist=None): """Customize Fortran compiler. This method gets Fortran compiler specific information from (i) class definition, (ii) environment, (iii) distutils config files, and (iv) command line (later overrides earlier). This method should be always called after constructing a compiler instance. But not in __init__ because Distribution instance is needed for (iii) and (iv). """ log.info('customize %s' % (self.__class__.__name__)) self._is_customised = True self.distutils_vars.use_distribution(dist) self.command_vars.use_distribution(dist) self.flag_vars.use_distribution(dist) self.update_executables() # find_executables takes care of setting the compiler commands, # version_cmd, linker_so, linker_exe, ar, and ranlib self.find_executables() noopt = self.distutils_vars.get('noopt', False) noarch = self.distutils_vars.get('noarch', noopt) debug = self.distutils_vars.get('debug', False) f77 = self.command_vars.compiler_f77 f90 = self.command_vars.compiler_f90 f77flags = [] f90flags = [] freeflags = [] fixflags = [] if f77: f77flags = self.flag_vars.f77 if f90: f90flags = self.flag_vars.f90 freeflags = self.flag_vars.free # XXX Assuming that free format is default for f90 compiler. fix = self.command_vars.compiler_fix if fix: fixflags = self.flag_vars.fix + f90flags oflags, aflags, dflags = [], [], [] # examine get_flags_<tag>_<compiler> for extra flags # only add them if the method is different from get_flags_<tag> def get_flags(tag, flags): # note that self.flag_vars.<tag> calls self.get_flags_<tag>() flags.extend(getattr(self.flag_vars, tag)) this_get = getattr(self, 'get_flags_' + tag) for name, c, flagvar in [('f77', f77, f77flags), ('f90', f90, f90flags), ('f90', fix, fixflags)]: t = '%s_%s' % (tag, name) if c and this_get is not getattr(self, 'get_flags_' + t): flagvar.extend(getattr(self.flag_vars, t)) if not noopt: get_flags('opt', oflags) if not noarch: get_flags('arch', aflags) if debug: get_flags('debug', dflags) fflags = self.flag_vars.flags + dflags + oflags + aflags if f77: self.set_commands(compiler_f77=[f77] + f77flags + fflags) if f90: self.set_commands(compiler_f90=[f90] + freeflags + f90flags + fflags) if fix: self.set_commands(compiler_fix=[fix] + fixflags + fflags) #XXX: Do we need LDSHARED->SOSHARED, LDFLAGS->SOFLAGS linker_so = self.linker_so if linker_so: linker_so_flags = self.flag_vars.linker_so if sys.platform.startswith('aix'): python_lib = get_python_lib(standard_lib=1) ld_so_aix = os.path.join(python_lib, 'config', 'ld_so_aix') python_exp = os.path.join(python_lib, 'config', 'python.exp') linker_so = [ld_so_aix] + linker_so + ['-bI:' + python_exp] self.set_commands(linker_so=linker_so + linker_so_flags) linker_exe = self.linker_exe if linker_exe: linker_exe_flags = self.flag_vars.linker_exe self.set_commands(linker_exe=linker_exe + linker_exe_flags) ar = self.command_vars.archiver if ar: arflags = self.flag_vars.ar self.set_commands(archiver=[ar] + arflags) self.set_library_dirs(self.get_library_dirs()) self.set_libraries(self.get_libraries())
except ImportError: cmdclass = {} from translate import __doc__, __version__ # Alias copied from six if sys.version_info[0] == 2: string_types = basestring, else: string_types = str, PRETTY_NAME = 'Translate Toolkit' translateversion = __version__.sver packagesdir = get_python_lib() sitepackages = packagesdir.replace(sys.prefix + os.sep, '') infofiles = [(join(sitepackages, 'translate'), [filename for filename in ('COPYING', 'README.rst')])] initfiles = [(join(sitepackages, 'translate'), [join('translate', '__init__.py')])] subpackages = [ "convert", "filters", "lang", "misc", join("misc", "wsgiserver"), "storage", join("storage", "placeables"), join("storage", "versioncontrol"),
summary= 'DeviceHive - the framework for interfacing applications and devices with the web cloud', license='MIT', description= 'A framework for interfacing applications and devices with the web cloud', long_description=open('README.md').read(), keywords="web cloud api embedded tutorial", packages=[ 'devicehive', 'devicehive.client', 'devicehive.device', 'devicehive.gateway' ], install_requires=['twisted', 'pyOpenSSL', 'service-identity'], requires=[ 'twisted (>=12.0)', 'pyOpenSSL (>=0.14)', 'service-identity (>=14.0.0)' ], data_files=[(path.join(get_python_lib(), 'devicehive'), ['LICENSE']), (path.join(get_python_lib(), 'devicehive', 'tests'), ['tests/test_binary.py']), (path.join(get_python_lib(), 'devicehive', 'tests'), ['tests/test_command.py']), (path.join(get_python_lib(), 'devicehive', 'tests'), ['tests/test_dhjson.py']), (path.join(get_python_lib(), 'devicehive', 'tests'), ['tests/test_proto.py']), (path.join(get_python_lib(), 'devicehive', 'tests'), ['tests/test_utils.py']), (path.join(get_python_lib(), 'devicehive', 'tests'), ['tests/test_wsdev.py']), (path.join(get_python_lib(), 'devicehive', 'tests'), ['tests/test_wsparser.py']), (path.join(get_python_lib(), 'devicehive',
# Notes about STD_LIB_DIR # Consider arch-specific installation for STD_LIB_DIR definition # :mod:`distutils.sysconfig` contains to much hardcoded values to rely on # # :see: `Problems with /usr/lib64 builds <http://bugs.python.org/issue1294959>`_ # :see: `FHS <http://www.pathname.com/fhs/pub/fhs-2.3.html#LIBLTQUALGTALTERNATEFORMATESSENTIAL>`_ if sys.platform.startswith('win'): PY_SOURCE_EXTS = ('py', 'pyw') PY_COMPILED_EXTS = ('dll', 'pyd') else: PY_SOURCE_EXTS = ('py', ) PY_COMPILED_EXTS = ('so', ) try: STD_LIB_DIR = get_python_lib(standard_lib=1) # get_python_lib(standard_lib=1) is not available on pypy, set STD_LIB_DIR to # non-valid path, see https://bugs.pypy.org/issue1164 except DistutilsPlatformError: STD_LIB_DIR = '//' EXT_LIB_DIR = get_python_lib() BUILTIN_MODULES = dict( zip(sys.builtin_module_names, [1] * len(sys.builtin_module_names))) class NoSourceFile(Exception): """exception raised when we are not able to get a python source file for a precompiled file """
""" WSGI config for homeapps project. It exposes the WSGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/1.6/howto/deployment/wsgi/ """ import os import sys os.environ.setdefault("DJANGO_SETTINGS_MODULE", "homeapps.settings") from distutils.sysconfig import get_python_lib os.environ['PYTHON_EGG_CACHE'] = get_python_lib() from django.core.wsgi import get_wsgi_application application = get_wsgi_application()
to the same location where the modules of phcpy are installed. This is accomplished via the data_files entry in the setup below. For the installation of the GPU accelerated path trackers in double, double double and quad double precision, instead of phcpy2c2.so, the shared objects that are needed are phcpy2cpath_d.so (double), phcpy2cpath_dd.so (double double), and phcpy2cpath_qd.so (quad double). """ from distutils.core import setup from distutils.sysconfig import get_python_lib setup( name = 'PHCpy' , author = 'Jan Verschelde' , author_email = '*****@*****.**' , description = 'a package for Polynomial Homotopy Continuation' , url = 'https://github.com/janverschelde/PHCpack' , version = '0.7.7' , packages = ['phcpy'] , py_modules = ['phcpy/interface', 'phcpy/solver', 'phcpy/solutions', \ 'phcpy/trackers', 'phcpy/sweepers', 'phcpy/tuning', \ 'phcpy/sets', 'phcpy/cascades', 'phcpy/factor', 'phcpy/diagonal', \ 'phcpy/polytopes', 'phcpy/tropisms', 'phcpy/maps', 'phcpy/series', \ 'phcpy/schubert', 'phcpy/examples', 'phcpy/families', \ 'phcpy/dashboard', 'phcpy/server' ] , license = 'GNU GENERAL PUBLIC LICENSE version 3' , data_files = [(get_python_lib()+'/phcpy', ['phcpy/phcpy2c2.so'])] , platforms = ['linux2'] , long_description=open('README.txt').read() )
def availableClasses(showHidden=0): global allClasses global allClasses_hidden def _ordering(first, second): ((name1, _), priority1) = first ((name2, _), priority2) = second if priority1 < priority2: return -1 elif priority1 > priority2: return 1 if name1 < name2: return -1 elif name1 > name2: return 1 return 0 if not showHidden: if allClasses: return allClasses else: if allClasses_hidden: return allClasses_hidden path = [] env_path = [] if "ANACONDA_INSTALL_CLASSES" in os.environ: env_path += os.environ["ANACONDA_INSTALL_CLASSES"].split(":") for d in env_path + [ "installclasses", "/tmp/updates/pyanaconda/installclasses", "/tmp/product/pyanaconda/installclasses", "%s/pyanaconda/installclasses" % get_python_lib(plat_specific=1) ]: if os.access(d, os.R_OK): path.append(d) # append the location of installclasses to the python path so we # can import them sys.path = path + sys.path files = [] for p in reversed(path): files += os.listdir(p) done = {} lst = [] for fileName in files: if fileName[0] == '.': continue if len(fileName) < 4: continue if fileName[-3:] != ".py" and fileName[-4:-1] != ".py": continue mainName = fileName.split(".")[0] if done.has_key(mainName): continue done[mainName] = 1 try: found = imputil.imp.find_module(mainName) except ImportError: log.warning("module import of %s failed: %s", mainName, sys.exc_type) continue try: loaded = imputil.imp.load_module(mainName, found[0], found[1], found[2]) obj = loaded.InstallClass if obj.__dict__.has_key('sortPriority'): sortOrder = obj.sortPriority else: sortOrder = 0 if obj.hidden == 0 or showHidden == 1: lst.append(((obj.name, obj), sortOrder)) except (ImportError, AttributeError): log.warning("module import of %s failed: %s", mainName, sys.exc_type) lst.sort(_ordering) for (item, _) in lst: if showHidden: allClasses_hidden += [item] else: allClasses += [item] if showHidden: return allClasses_hidden else: return allClasses
def write(self, s): self.fp.write(s) def writelines(self, lines): self.fp.writelines(lines) def flush(self): self.fp.flush() stdout_redirector = OutputRedirector(sys.stdout) stderr_redirector = OutputRedirector(sys.stderr) SYSSTR = platform.system() SITE_PAKAGE_PATH = get_python_lib() FIELDS = { "testPass": 0, "testResult": [], "testName": "", "testAll": 0, "testFail": 0, "beginTime": "", "totalTime": "", "testSkip": 0 } class PATH: """ all file PATH meta """
"libuna", "libcfile", "libcpath", "libbfio", "libewf", ], library_dirs = [ "..\\msvscpp\\Release", ], ) # TODO: what about license, description and platform in egg file setup( name = "pyewf", url = "http://code.google.com/p/libewf/", version = "20130416", description = "Python bindings module for libewf", author = "Joachim Metz", author_email = "*****@*****.**", ext_modules = [ module, ], data_files = [ (sysconfig.get_python_lib(), [ "..\\msvscpp\\Release\\libewf.dll", "..\\msvscpp\\Release\\zlib.dll", ]), ], )
#!/usr/bin/env python import os, os.path import sys import distutils.sysconfig as sysconfig # use this to install a shortcut on the desktop of the installer only #desktop = get_special_folder_path("CSIDL_DESKTOPDIRECTORY") # use this to install a shortcut on the desktop of all users desktop = get_special_folder_path("CSIDL_COMMON_DESKTOPDIRECTORY") shortcut = os.path.join(desktop, 'Pythics.lnk') examples = os.path.join(sysconfig.get_python_lib(True), 'pythics', 'start.py') if sys.argv[1] == '-install': create_shortcut(examples, 'Start Pythics', shortcut) print 'Created Pythics shortcut on desktop.' elif os.path.exists(shortcut): os.remove(shortcut)
from distutils.sysconfig import get_python_lib import logging import configparser import time logging.basicConfig(filename="/var/log/patching/patching_auto_email.log", filemode="a", format="%(asctime)s %(message)s", datefmt="%d/%m/%Y %H:%M:%S", level=logging.INFO) logging.info( "==================================================================") logging.info("Starting the script...") os.chdir(os.path.dirname(os.path.realpath(__file__))) sys.path.append(get_python_lib()) def get_settings(): '''parse the config file''' parse_conf = configparser.ConfigParser() parse_conf.read("./settings.cfg") return parse_conf['auto_e_mail_notifications'] def extract_needed_servers(): '''function for read csv files and extract servers which should be patched between now+13 min. and now+28 min.''' logging.info("Searching needed servers from csv-files...") servers_for_sending_email = {} csv_files = glob.glob('./*linux_*.csv') logging.info(
from distutils.sysconfig import get_python_lib from setuptools import setup, Extension, find_packages from os import path README_md = path.join(path.abspath(path.dirname(__file__)), 'README.md') with open(README_md, 'r') as f: long_description = f.read() vrpc_path = path.join(get_python_lib(), 'vrpc') vrpc_module_cpp = path.join(vrpc_path, 'module.cpp') module = Extension('vrpc_example_ext', include_dirs=[vrpc_path, './cpp'], define_macros=[('VRPC_COMPILE_AS_ADDON', '<binding.cpp>'), ('VRPC_MODULE_NAME', '"vrpc_example_ext"'), ('VRPC_MODULE_FUNC', 'PyInit_vrpc_example_ext')], extra_compile_args=['-std=c++14', '-fPIC'], sources=[vrpc_module_cpp, './cpp/Bar.cpp'], language='c++') setup(name='vrpc-python-example', version='1.0.0', license='MIT', description='Example project demonstrating the usage of vrpc', long_description=long_description, long_description_content_type='text/markdown', author='Burkhard C. Heisen', author_email='*****@*****.**', packages=find_packages(),
""" warnings.simplefilter("ignore", UserWarning) if sys.platform == "darwin": LIBNAME = "libxnd.dylib" LIBSONAME = "libxnd.0.dylib" LIBSHARED = "libxnd.0.2.0dev3.dylib" else: LIBNAME = "libxnd.so" LIBSONAME = "libxnd.so.0" LIBSHARED = "libxnd.so.0.2.0dev3" LIBNDTYPES = "libndtypes.so.0.2.0dev3" if "install" in sys.argv or "bdist_wheel" in sys.argv: CONFIGURE_INCLUDES = "%s/ndtypes" % get_python_lib() CONFIGURE_LIBS = CONFIGURE_INCLUDES INCLUDES = LIBS = [CONFIGURE_INCLUDES] LIBXNDDIR = "%s/xnd" % get_python_lib() INSTALL_LIBS = True elif "conda_install" in sys.argv: site = "%s/ndtypes" % get_python_lib() sys_includes = os.path.join(os.environ['PREFIX'], "include") libdir = "Library/bin" if sys.platform == "win32" else "lib" sys_libs = os.path.join(os.environ['PREFIX'], libdir) CONFIGURE_INCLUDES = INCLUDES = [sys_includes, site] LIBS = [sys_libs, site] LIBXNDDIR = "%s/xnd" % get_python_lib() INSTALL_LIBS = False else: CONFIGURE_INCLUDES = "../python/ndtypes"
# Create the setdir.sh and setdir.csh scripts; they will be recreated # each time setup.py is run, but it does not matter. scripttempdir = 'build/temp.' + get_platform( ) + '-%s.%s' % sys.version_info[0:2] mkpath(scripttempdir) setdir_sh = open(scripttempdir + '/synthlisa-setdir.sh', 'w') setdir_csh = open(scripttempdir + '/synthlisa-setdir.csh', 'w') recompile_sh = open(scripttempdir + '/synthlisa-recompile.sh', 'w') pythonpath = '' installpath = sys.exec_prefix if synthlisa_prefix: pythonpath = get_python_lib(prefix=synthlisa_prefix) installpath = synthlisa_prefix # not needed with numpy, which can find the module from site-packages # if numpy_prefix: # if pythonpath: # pythonpath = pythonpath + ':' # # pythonpath = pythonpath + get_python_lib(prefix=numpy_prefix) + '/numpy' mpi_prefix = numpy_prefix if mpi_prefix: if pythonpath: pythonpath = pythonpath + ':'
def main(_args=None): """ Command-line entry point """ global args args = _args or parser.parse_args() # If warnings not externally managed, show deprecation warnings if not sys.warnoptions: warnings.simplefilter("once", DeprecationWarning) if args.close_stdin: sys.stdin.close() if (args.html or args.http) and not args.output_dir: args.output_dir = 'html' if args.html_dir: _warn_deprecated('--html-dir', '--output-dir') args.output_dir = args.html_dir if args.overwrite: _warn_deprecated('--overwrite', '--force') args.force = args.overwrite template_config = {} for config_str in args.config: try: key, value = config_str.split('=', 1) value = ast.literal_eval(value) template_config[key] = value except Exception: raise ValueError( f'Error evaluating --config statement "{config_str}". ' 'Make sure string values are quoted?') if args.html_no_source: _warn_deprecated('--html-no-source', '-c show_source_code=False', True) template_config['show_source_code'] = False if args.link_prefix: _warn_deprecated('--link-prefix', '-c link_prefix="foo"', True) template_config['link_prefix'] = args.link_prefix if args.external_links: _warn_deprecated('--external-links') template_config['external_links'] = True if args.template_dir is not None: if not path.isdir(args.template_dir): print( f'Error: Template dir {args.template_dir!r} is not a directory', file=sys.stderr) sys.exit(1) pdoc.tpl_lookup.directories.insert(0, args.template_dir) # Support loading modules specified as python paths relative to cwd sys.path.append(os.getcwd()) # Virtual environment handling for pdoc script run from system site try: venv_dir = os.environ['VIRTUAL_ENV'] except KeyError: pass # pdoc was not invoked while in a virtual environment else: from glob import glob from distutils.sysconfig import get_python_lib libdir = get_python_lib(prefix=venv_dir) sys.path.append(libdir) # Resolve egg-links from `setup.py develop` or `pip install -e` # XXX: Welcome a more canonical approach for pth in glob(path.join(libdir, '*.egg-link')): try: with open(pth) as f: sys.path.append(path.join(libdir, f.readline().rstrip())) except IOError: warn(f'Invalid egg-link in venv: {pth!r}') if args.http: template_config['link_prefix'] = "/" # Run the HTTP server. _WebDoc.args = args # Pass params to HTTPServer xP _WebDoc.template_config = template_config host, _, port = args.http.partition(':') host = host or DEFAULT_HOST port = int(port or DEFAULT_PORT) print(f'Starting pdoc server on {host}:{port}', file=sys.stderr) httpd = HTTPServer((host, port), _WebDoc) print(f"pdoc server ready at http://{host}:{port}", file=sys.stderr) # Allow tests to perform `pdoc.cli._httpd.shutdown()` global _httpd _httpd = httpd try: httpd.serve_forever() finally: httpd.server_close() sys.exit(0) docfilter = None if args.filter and args.filter.strip(): def docfilter(obj, _filters=args.filter.strip().split(',')): return any(f in obj.refname or isinstance(obj, pdoc.Class) and f in obj.doc for f in _filters) modules = [ pdoc.Module(module, docfilter=docfilter, skip_errors=args.skip_errors) for module in args.modules ] pdoc.link_inheritance() if args.pdf: _print_pdf(modules, **template_config) import textwrap PANDOC_CMD = textwrap.indent(_PANDOC_COMMAND, ' ') print(f""" PDF-ready markdown written to standard output. ^^^^^^^^^^^^^^^ Convert this file to PDF using e.g. Pandoc: {PANDOC_CMD} or using Python-Markdown and Chrome/Chromium/WkHtmlToPDF: markdown_py --extension=meta \\ --extension=abbr \\ --extension=attr_list \\ --extension=def_list \\ --extension=fenced_code \\ --extension=footnotes \\ --extension=tables \\ --extension=admonition \\ --extension=smarty \\ --extension=toc \\ pdf.md > pdf.html chromium --headless --disable-gpu --print-to-pdf=pdf.pdf pdf.html wkhtmltopdf --encoding utf8 -s A4 --print-media-type pdf.html pdf.pdf or similar, at your own discretion.""", file=sys.stderr) sys.exit(0) for module in modules: if args.html: _quit_if_exists(module, ext='.html') recursive_write_files(module, ext='.html', **template_config) elif args.output_dir: # Generate text files _quit_if_exists(module, ext='.md') recursive_write_files(module, ext='.md', **template_config) else: sys.stdout.write(module.text(**template_config)) # Two blank lines between two modules' texts sys.stdout.write(os.linesep * (1 + 2 * int(module != modules[-1]))) if args.html: lunr_config = pdoc._get_config(**template_config).get('lunr_search') if lunr_config is not None: _generate_lunr_search(modules, lunr_config.get("index_docstrings", True), template_config)
os.path.abspath(os.path.join(CUDF_ROOT, "../include/cudf")), os.path.abspath(os.path.join(CUDF_ROOT, "../include")), os.path.abspath( os.path.join(CUDF_ROOT, "../libcudf_kafka/include/cudf_kafka")), os.path.join(CUDF_ROOT, "include"), os.path.join(CUDF_ROOT, "_deps/libcudacxx-src/include"), os.path.join( os.path.dirname(sysconfig.get_path("include")), "libcudf/libcudacxx", ), os.path.dirname(sysconfig.get_path("include")), np.get_include(), cuda_include_dir, ], library_dirs=([get_python_lib(), os.path.join(os.sys.prefix, "lib")]), libraries=["cudf", "cudf_kafka"], language="c++", extra_compile_args=["-std=c++14"], ) ] setup( name="cudf_kafka", version=versioneer.get_version(), description="cuDF Kafka Datasource", url="https://github.com/rapidsai/cudf", author="NVIDIA Corporation", license="Apache 2.0", classifiers=[
from distutils import sysconfig import json import logging import os import pprint import struct import sys import time import traceback import usb from stats_manager import StatsManager # Directory where hdctools installs configuration files into. LIB_DIR = os.path.join(sysconfig.get_python_lib(standard_lib=False), 'servo', 'data') # Potential config file locations: current working directory, the same directory # as powerlog.py file or LIB_DIR. CONFIG_LOCATIONS = [ os.getcwd(), os.path.dirname(os.path.realpath(__file__)), LIB_DIR ] def logoutput(msg): print(msg) sys.stdout.flush()