我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用sys.base_prefix()。
def getsitepackages(): """ Return only one item as list with one item. """ # For now used only on Windows. Raise Exception for other platforms. if is_win: pths = [os.path.join(sys.prefix, 'Lib', 'site-packages')] # Include Real sys.prefix for virtualenv. if is_virtualenv: pths.append(os.path.join(base_prefix, 'Lib', 'site-packages')) return pths else: # TODO Implement for Python 2.6 on other platforms. raise NotImplementedError() # Function to reload a module - used to reload module 'PyInstaller.config' for tests. # imp module is deprecated since Python 3.4.
def test_user_similar(self): # Issue #8759: make sure the posix scheme for the users # is similar to the global posix_prefix one base = get_config_var('base') user = get_config_var('userbase') # the global scheme mirrors the distinction between prefix and # exec-prefix but not the user scheme, so we have to adapt the paths # before comparing (issue #9100) adapt = sys.base_prefix != sys.base_exec_prefix for name in ('stdlib', 'platstdlib', 'purelib', 'platlib'): global_path = get_path(name, 'posix_prefix') if adapt: global_path = global_path.replace(sys.exec_prefix, sys.base_prefix) base = base.replace(sys.exec_prefix, sys.base_prefix) elif sys.base_prefix != sys.prefix: # virtual environment? Likewise, we have to adapt the paths # before comparing global_path = global_path.replace(sys.base_prefix, sys.prefix) base = base.replace(sys.base_prefix, sys.prefix) user_path = get_path(name, 'posix_user') self.assertEqual(user_path, global_path.replace(base, user, 1))
def test_prefixes(self): """ Test that the prefix values are as expected. """ #check our prefixes self.assertEqual(sys.base_prefix, sys.prefix) self.assertEqual(sys.base_exec_prefix, sys.exec_prefix) # check a venv's prefixes shutil.rmtree(self.env_dir) self.run_with_capture(venv.create, self.env_dir) envpy = os.path.join(self.env_dir, self.bindir, self.exe) cmd = [envpy, '-c', None] for prefix, expected in ( ('prefix', self.env_dir), ('prefix', self.env_dir), ('base_prefix', sys.prefix), ('base_exec_prefix', sys.exec_prefix)): cmd[2] = 'import sys; print(sys.%s)' % prefix p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, err = p.communicate() self.assertEqual(out.strip(), expected.encode())
def test_prefixes(self): """ Test that the prefix values are as expected. """ #check our prefixes self.assertEqual(sys.base_prefix, sys.prefix) self.assertEqual(sys.base_exec_prefix, sys.exec_prefix) # check a venv's prefixes rmtree(self.env_dir) self.run_with_capture(venv.create, self.env_dir) envpy = os.path.join(self.env_dir, self.bindir, self.exe) cmd = [envpy, '-c', None] for prefix, expected in ( ('prefix', self.env_dir), ('prefix', self.env_dir), ('base_prefix', sys.prefix), ('base_exec_prefix', sys.exec_prefix)): cmd[2] = 'import sys; print(sys.%s)' % prefix p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, err = p.communicate() self.assertEqual(out.strip(), expected.encode())
def __init__(self, name, folder=None, respect_venv=False): if folder is None: folder = JSONKVStore.DefaultFolder #If we are relative to a virtual environment, place the registry into that virtual env #Support both virtualenv and pythnon 3 venv if respect_venv and hasattr(sys, 'real_prefix'): folder = sys.prefix elif respect_venv and hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix: folder = sys.prefix if not os.path.exists(folder): os.makedirs(folder, 0755) jsonfile = os.path.join(folder, name) self.file = jsonfile
def __init__(self, name, folder=None, respect_venv=False): if folder is None: folder = SQLiteKVStore.DefaultFolder #If we are relative to a virtual environment, place the registry into that virtual env #Support both virtualenv and pythnon 3 venv if respect_venv and hasattr(sys, 'real_prefix'): folder = sys.prefix elif respect_venv and hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix: folder = sys.prefix if not os.path.exists(folder): os.makedirs(folder, 0755) dbfile = os.path.join(folder, name) self.connection = sqlite3.connect(dbfile) self.cursor = self.connection.cursor() self.file = dbfile self._setup_table()
def tearDown(self): if sys.version < "2.6" or hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix): return os.chdir(self.old_cwd) shutil.rmtree(self.dir) shutil.rmtree(site.USER_BASE) shutil.rmtree(site.USER_SITE) site.USER_BASE = self.old_base site.USER_SITE = self.old_site
def setup_detect_python2(): """ Call this before using the refactoring tools to create them on demand if needed. """ if None in [RTs._rt_py2_detect, RTs._rtp_py2_detect]: RTs._rt_py2_detect = RefactoringTool(py2_detect_fixers) RTs._rtp_py2_detect = RefactoringTool(py2_detect_fixers, {'print_function': True}) # We need to find a prefix for the standard library, as we don't want to # process any files there (they will already be Python 3). # # The following method is used by Sanjay Vinip in uprefix. This fails for # ``conda`` environments: # # In a non-pythonv virtualenv, sys.real_prefix points to the installed Python. # # In a pythonv venv, sys.base_prefix points to the installed Python. # # Outside a virtual environment, sys.prefix points to the installed Python. # if hasattr(sys, 'real_prefix'): # _syslibprefix = sys.real_prefix # else: # _syslibprefix = getattr(sys, 'base_prefix', sys.prefix) # Instead, we use the portion of the path common to both the stdlib modules # ``math`` and ``urllib``.
def change_prefix(filename, dst_prefix): prefixes = [sys.prefix] if is_darwin: prefixes.extend(( os.path.join("/Library/Python", sys.version[:3], "site-packages"), os.path.join(sys.prefix, "Extras", "lib", "python"), os.path.join("~", "Library", "Python", sys.version[:3], "site-packages"), # Python 2.6 no-frameworks os.path.join("~", ".local", "lib","python", sys.version[:3], "site-packages"), # System Python 2.7 on OSX Mountain Lion os.path.join("~", "Library", "Python", sys.version[:3], "lib", "python", "site-packages"))) if hasattr(sys, 'real_prefix'): prefixes.append(sys.real_prefix) if hasattr(sys, 'base_prefix'): prefixes.append(sys.base_prefix) prefixes = list(map(os.path.expanduser, prefixes)) prefixes = list(map(os.path.abspath, prefixes)) # Check longer prefixes first so we don't split in the middle of a filename prefixes = sorted(prefixes, key=len, reverse=True) filename = os.path.abspath(filename) for src_prefix in prefixes: if filename.startswith(src_prefix): _, relpath = filename.split(src_prefix, 1) if src_prefix != os.sep: # sys.prefix == "/" assert relpath[0] == os.sep relpath = relpath[1:] return join(dst_prefix, relpath) assert False, "Filename %s does not start with any of these prefixes: %s" % \ (filename, prefixes)
def change_prefix(filename, dst_prefix): prefixes = [sys.prefix] if is_darwin: prefixes.extend(( os.path.join("/Library/Python", sys.version[:3], "site-packages"), os.path.join(sys.prefix, "Extras", "lib", "python"), os.path.join("~", "Library", "Python", sys.version[:3], "site-packages"), # Python 2.6 no-frameworks os.path.join("~", ".local", "lib","python", sys.version[:3], "site-packages"), # System Python 2.7 on OSX Mountain Lion os.path.join("~", "Library", "Python", sys.version[:3], "lib", "python", "site-packages"))) if hasattr(sys, 'real_prefix'): prefixes.append(sys.real_prefix) if hasattr(sys, 'base_prefix'): prefixes.append(sys.base_prefix) prefixes = list(map(os.path.expanduser, prefixes)) prefixes = list(map(os.path.abspath, prefixes)) # Check longer prefixes first so we don't split in the middle of a filename prefixes = sorted(prefixes, key=len, reverse=True) filename = os.path.abspath(filename) # On Windows, make sure drive letter is uppercase if is_win and filename[0] in 'abcdefghijklmnopqrstuvwxyz': filename = filename[0].upper() + filename[1:] for i, prefix in enumerate(prefixes): if is_win and prefix[0] in 'abcdefghijklmnopqrstuvwxyz': prefixes[i] = prefix[0].upper() + prefix[1:] for src_prefix in prefixes: if filename.startswith(src_prefix): _, relpath = filename.split(src_prefix, 1) if src_prefix != os.sep: # sys.prefix == "/" assert relpath[0] == os.sep relpath = relpath[1:] return join(dst_prefix, relpath) assert False, "Filename %s does not start with any of these prefixes: %s" % \ (filename, prefixes)
def test_coverage(coverdir): trace = support.import_module('trace') tracer=trace.Trace(ignoredirs=[sys.base_prefix, sys.base_exec_prefix,], trace=0, count=1) tracer.run('reload(cmd);test_main()') r=tracer.results() print("Writing coverage results...") r.write_results(show_missing=True, summary=True, coverdir=coverdir)
def test_coverage(coverdir): trace = support.import_module('trace') tracer = trace.Trace(ignoredirs=[sys.base_prefix, sys.base_exec_prefix,], trace=0, count=1) tracer.run('test_main()') r = tracer.results() print('Writing coverage results...') r.write_results(show_missing=True, summary=True, coverdir=coverdir)
def test_coverage_ignore(self): # Ignore all files, nothing should be traced nor printed libpath = os.path.normpath(os.path.dirname(os.__file__)) # sys.prefix does not work when running from a checkout tracer = trace.Trace(ignoredirs=[sys.base_prefix, sys.base_exec_prefix, libpath], trace=0, count=1) with captured_stdout() as stdout: self._coverage(tracer) if os.path.exists(TESTFN): files = os.listdir(TESTFN) self.assertEqual(files, ['_importlib.cover']) # Ignore __import__
def test_is_inside_virtual_env(self): """ Check `utils.is_inside_virtual_env()` against various sets of sys prefix paths. """ system = mock.sentinel.system virtual = mock.sentinel.virtual # These are the sets of sys module attributes that should be present or absent # with various versions of Python and virtualenv / venv. test_cases = { 'py2_base': dict(prefix=system), # Python 3 (as of 3.3 / PEP 405) adds a sys.base_prefix attribute 'py3_base': dict(base_prefix=system, prefix=system), 'py3_venv': dict(base_prefix=system, prefix=virtual), # virtualenv saves sys.real_prefix, and changes the others 'py2_virtualenv': dict(real_prefix=system, prefix=virtual), 'py3_virtualenv': dict(real_prefix=system, prefix=virtual, base_prefix=virtual), } for (label, sys_attrs) in test_cases.items(): with self.subTest(label=label): # Note: The spec=[] is important so that absent sys_attrs raise AttributeError # instead of returning mocks. with mock.patch('django_develop.utils.sys', spec=[], **sys_attrs): expected = sys_attrs['prefix'] is virtual self.assertEqual(utils.is_inside_virtual_env(), expected)
def is_inside_virtual_env(): """ Detect whether a Python virtual environment is active. This detects environments created using virtualenv, or using Python's built-in venv (PEP 405). If true, `sys.prefix` should be the virtual environment's root. This implementation only looks at the `sys` module, so environment variables like VIRTUAL_ENV do not affect it. :rtype: bool """ is_virtualenv = hasattr(sys, 'real_prefix') is_venv = hasattr(sys, 'base_prefix') and sys.prefix != sys.base_prefix return is_virtualenv or is_venv
def _detect_python_environment(self): from distutils.command.install import install as cmd_install from distutils.dist import Distribution import sys cmd = cmd_install(Distribution()) cmd.finalize_options() self._python_install_dir = cmd.install_lib self._python_prefix = os.path.realpath(sys.prefix) self._python_virtual_env = hasattr(sys, "real_prefix") \ or (hasattr(sys, "base_prefix") and os.path.realpath(sys.prefix) != os.path.realpath(sys.base_prefix))
def _get_shebang(self, encoding, post_interp=b'', flags=None): if self.executable: executable = self.executable elif not sysconfig.is_python_build(): executable = get_executable() elif hasattr(sys, 'base_prefix') and sys.prefix != sys.base_prefix: executable = os.path.join( sysconfig.get_path('scripts'), 'python%s' % sysconfig.get_config_var('EXE')) else: executable = os.path.join( sysconfig.get_config_var('BINDIR'), 'python%s%s' % (sysconfig.get_config_var('VERSION'), sysconfig.get_config_var('EXE'))) if flags: executable = self._get_alternate_executable(executable, flags) executable = fsencode(executable) shebang = b'#!' + executable + post_interp + b'\n' # Python parser starts to read a script using UTF-8 until # it gets a #coding:xxx cookie. The shebang has to be the # first line of a file, the #coding:xxx cookie cannot be # written before. So the shebang has to be decodable from # UTF-8. try: shebang.decode('utf-8') except UnicodeDecodeError: raise ValueError( 'The shebang (%r) is not decodable from utf-8' % shebang) # If the script is encoded to a custom encoding (use a # #coding:xxx cookie), the shebang has to be decodable from # the script encoding too. if encoding != 'utf-8': try: shebang.decode(encoding) except UnicodeDecodeError: raise ValueError( 'The shebang (%r) is not decodable ' 'from the script encoding (%r)' % (shebang, encoding)) return shebang
def get_python_inc(plat_specific=0, prefix=None): """Return the directory containing installed Python header files. If 'plat_specific' is false (the default), this is the path to the non-platform-specific header files, i.e. Python.h and so on; otherwise, this is the path to platform-specific header files (namely pyconfig.h). If 'prefix' is supplied, use it instead of sys.base_prefix or sys.base_exec_prefix -- i.e., ignore 'plat_specific'. """ if prefix is None: prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX if os.name == "posix": if python_build: # Assume the executable is in the build directory. The # pyconfig.h file should be in the same directory. Since # the build directory may not be the source directory, we # must use "srcdir" from the makefile to find the "Include" # directory. base = _sys_home or project_base if plat_specific: return base if _sys_home: incdir = os.path.join(_sys_home, get_config_var('AST_H_DIR')) else: incdir = os.path.join(get_config_var('srcdir'), 'Include') return os.path.normpath(incdir) python_dir = 'python' + get_python_version() + build_flags return os.path.join(prefix, "include", python_dir) elif os.name == "nt": return os.path.join(prefix, "include") else: raise DistutilsPlatformError( "I don't know where Python installs its C header files " "on platform '%s'" % os.name)
def get_python_lib(plat_specific=0, standard_lib=0, prefix=None): """Return the directory containing the Python library (standard or site additions). If 'plat_specific' is true, return the directory containing platform-specific modules, i.e. any module from a non-pure-Python module distribution; otherwise, return the platform-shared library directory. If 'standard_lib' is true, return the directory containing standard Python library modules; otherwise, return the directory for site-specific modules. If 'prefix' is supplied, use it instead of sys.base_prefix or sys.base_exec_prefix -- i.e., ignore 'plat_specific'. """ if prefix is None: if standard_lib: prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX else: prefix = plat_specific and EXEC_PREFIX or PREFIX if os.name == "posix": libpython = os.path.join(prefix, "lib", "python" + get_python_version()) if standard_lib: return libpython else: return os.path.join(libpython, "site-packages") elif os.name == "nt": if standard_lib: return os.path.join(prefix, "Lib") else: return os.path.join(prefix, "Lib", "site-packages") else: raise DistutilsPlatformError( "I don't know where Python installs its library " "on platform '%s'" % os.name)
def test_coverage(coverdir): trace = support.import_module('trace') tracer=trace.Trace(ignoredirs=[sys.base_prefix, sys.base_exec_prefix,], trace=0, count=1) tracer.run('import importlib; importlib.reload(cmd); test_main()') r=tracer.results() print("Writing coverage results...") r.write_results(show_missing=True, summary=True, coverdir=coverdir)
def teardown_method(self, method): if hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix): return os.chdir(self.old_cwd) shutil.rmtree(self.dir) shutil.rmtree(site.USER_BASE) shutil.rmtree(site.USER_SITE) site.USER_BASE = self.old_base site.USER_SITE = self.old_site
def __env(envdir): # http://stackoverflow.com/a/1883251 if hasattr(sys, 'real_prefix'): # We're already inside someone else's virtualenv. return sys.prefix elif hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix: # We're already inside someone else's pyvenv. return sys.prefix elif os.path.exists(envdir): # We've already built our own virtualenv. return envdir args = [sys.executable] + ENV_ARGS + [envdir] run(*args) return envdir
def get_venv_basedir(): """Returns the base directory of the virtualenv, useful to read configuration and plugins""" exec_prefix = get_config_vars()['exec_prefix'] has_real_prefix = hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix) if has_real_prefix is False or (hasattr(sys, 'real_prefix') and exec_prefix.startswith(sys.real_prefix)): raise EnvironmentError('You must be in a virtual environment') return os.path.abspath(get_config_vars()['exec_prefix'] + '/../')
def load_sqlite3(finder, module): """In Windows, the sqlite3 module requires an additional dll sqlite3.dll to be present in the build directory.""" if sys.platform == "win32": dll_name = "sqlite3.dll" dll_path = os.path.join(sys.base_prefix, "DLLs", dll_name) finder.IncludeFiles(dll_path, os.path.join("lib", dll_name))
