Rename to PYTHONPYCACHEPREFIX / pycache_prefix.

Author: carljm

Doc/library/compileall.rst

@@ -109,9 +109,9 @@ There is no command-line option to control the optimization level used by the
 :func:`compile` function, because the Python interpreter itself already
 provides the option: :program:`python -O -m compileall`.
 
-Similarly, the :func:`compile` function respects the :attr:`sys.bytecode_prefix`
+Similarly, the :func:`compile` function respects the :attr:`sys.pycache_prefix`
 setting. The generated bytecode cache will only be useful if :func:`compile` is
-run with the same :attr:`sys.bytecode_prefix` (if any) that will be used at
+run with the same :attr:`sys.pycache_prefix` (if any) that will be used at
 runtime.
 
 Public functions

Doc/library/sys.rst

@@ -209,7 +209,7 @@ always available.
    yourself to control bytecode file generation.
 
 
-.. data:: bytecode_prefix
+.. data:: pycache_prefix
 
    If this is set (not ``None``), Python will write bytecode-cache ``.pyc``
    files to (and read them from) a parallel directory tree rooted at this
@@ -222,8 +222,8 @@ always available.
    A relative path is interpreted relative to the current working directory.
 
    This value is initially set based on the value of the :option:`-X`
-   ``bytecode_prefix=PATH`` command-line option or the
-   :envvar:`PYTHONBYTECODEPREFIX` environment variable (command-line takes
+   ``pycache_prefix=PATH`` command-line option or the
+   :envvar:`PYTHONPYCACHEPREFIX` environment variable (command-line takes
    precedence). If neither are set, it is ``None``.
 
    .. versionadded:: 3.8

Doc/using/cmdline.rst

@@ -442,9 +442,9 @@ Miscellaneous options
      the default locale-aware mode. ``-X utf8=0`` explicitly disables UTF-8
      mode (even when it would otherwise activate automatically).
      See :envvar:`PYTHONUTF8` for more details.
-   * ``-X bytecode_prefix=PATH`` enables writing ``.pyc`` files to a parallel
+   * ``-X pycache_prefix=PATH`` enables writing ``.pyc`` files to a parallel
      tree rooted at the given directory instead of to the code tree. See also
-     :envvar:`PYTHONBYTECODEPREFIX`.
+     :envvar:`PYTHONPYCACHEPREFIX`.
 
    It also allows passing arbitrary values and retrieving them through the
    :data:`sys._xoptions` dictionary.
@@ -465,7 +465,7 @@ Miscellaneous options
       The ``-X importtime``, ``-X dev`` and ``-X utf8`` options.
 
    .. versionadded:: 3.8
-      The ``-X bytecode_prefix`` option.
+      The ``-X pycache_prefix`` option.
 
 
 Options you shouldn't use
@@ -593,12 +593,12 @@ conflict.
    specifying the :option:`-B` option.
 
 
-.. envvar:: PYTHONBYTECODEPREFIX
+.. envvar:: PYTHONPYCACHEPREFIX
 
    If this is set, Python will write ``.pyc`` files in a mirror directory tree
    at this path, instead of in ``__pycache__`` directories within the source
    tree. This is equivalent to specifying the :option:`-X`
-   ``bytecode_prefix=PATH`` option.
+   ``pycache_prefix=PATH`` option.
 
    .. versionadded:: 3.8
 

Include/pystate.h

@@ -1,4 +1,3 @@
-
 /* Thread and interpreter state structures and their interfaces */
 
 
@@ -44,7 +43,7 @@ typedef struct {
     int coerce_c_locale;    /* PYTHONCOERCECLOCALE, -1 means unknown */
     int coerce_c_locale_warn; /* PYTHONCOERCECLOCALE=warn */
     int utf8_mode;          /* PYTHONUTF8, -X utf8; -1 means unknown */
-    wchar_t *bytecode_prefix; /* PYTHONBYTECODEPREFIX; -X bytecode_prefix=PATH */
+    wchar_t *pycache_prefix; /* PYTHONPYCACHEPREFIX, -X pycache_prefix=PATH */
 
     wchar_t *program_name;  /* Program name, see also Py_GetProgramName() */
     int argc;               /* Number of command line arguments,
@@ -102,7 +101,7 @@ typedef struct {
     PyObject *warnoptions;         /* sys.warnoptions list, can be NULL */
     PyObject *xoptions;            /* sys._xoptions dict, can be NULL */
     PyObject *module_search_path;  /* sys.path list */
-    PyObject *bytecode_prefix;     /* sys.bytecode_prefix str, can be NULL */
+    PyObject *pycache_prefix;      /* sys.pycache_prefix str, can be NULL */
 } _PyMainInterpreterConfig;
 
 #define _PyMainInterpreterConfig_INIT \

Lib/importlib/_bootstrap_external.py

@@ -322,15 +322,15 @@ def cache_from_source(path, debug_override=None, *, optimization=None):
             raise ValueError('{!r} is not alphanumeric'.format(optimization))
         almost_filename = '{}.{}{}'.format(almost_filename, _OPT, optimization)
     filename = almost_filename + BYTECODE_SUFFIXES[0]
-    if sys.bytecode_prefix is not None:
+    if sys.pycache_prefix is not None:
         # We need an absolute path to the py file to avoid the possibility of
-        # collisions within sys.bytecode_prefix, if someone has two different
+        # collisions within sys.pycache_prefix, if someone has two different
         # `foo/bar.py` on their system and they import both of them using the
-        # same sys.bytecode_prefix. Let's say sys.bytecode_prefix is
+        # same sys.pycache_prefix. Let's say sys.pycache_prefix is
         # `C:\Bytecode`; the idea here is that if we get `Foo\Bar`, we first
         # make it absolute (`C:\Somewhere\Foo\Bar`), then make it root-relative
-        # (`Somewhere\Foo\Bar`), so we end up placing the bytecode file in
-        # an unambiguous `C:\Bytecode\Somewhere\Foo\Bar\`.
+        # (`Somewhere\Foo\Bar`), so we end up placing the bytecode file in an
+        # unambiguous `C:\Bytecode\Somewhere\Foo\Bar\`.
         if not _path_isabs(head):
             head = _path_join(_os.getcwd(), head)
 
@@ -343,7 +343,7 @@ def cache_from_source(path, debug_override=None, *, optimization=None):
         # Strip initial path separator from `head` to complete the conversion
         # back to a root-relative path before joining.
         return _path_join(
-            sys.bytecode_prefix,
+            sys.pycache_prefix,
             head.lstrip(path_separators),
             filename,
         )
@@ -364,8 +364,8 @@ def source_from_cache(path):
     path = _os.fspath(path)
     head, pycache_filename = _path_split(path)
     found_in_bytecode_prefix = False
-    if sys.bytecode_prefix is not None:
-        stripped_path = sys.bytecode_prefix.rstrip(path_separators)
+    if sys.pycache_prefix is not None:
+        stripped_path = sys.pycache_prefix.rstrip(path_separators)
         if head.startswith(stripped_path + path_sep):
             head = head[len(stripped_path):]
             found_in_bytecode_prefix = True

Lib/test/test_cmd_line.py

@@ -519,12 +519,12 @@ def test_sys_flags_set(self):
             with self.subTest(envar_value=value):
                 assert_python_ok('-c', code, **env_vars)
 
-    def test_set_bytecode_prefix(self):
-        # sys.bytecode_prefix can be set from either -X bytecode_prefix or
-        # PYTHONBYTECODEPREFIX env var, with the former taking precedence.
-        NO_VALUE = object()  # `-X bytecode_prefix` with no `=PATH`
+    def test_set_pycache_prefix(self):
+        # sys.pycache_prefix can be set from either -X pycache_prefix or
+        # PYTHONPYCACHEPREFIX env var, with the former taking precedence.
+        NO_VALUE = object()  # `-X pycache_prefix` with no `=PATH`
         cases = [
-            # (PYTHONBYTECODEPREFIX, -X bytecode_prefix, sys.bytecode_prefix)
+            # (PYTHONPYCACHEPREFIX, -X pycache_prefix, sys.pycache_prefix)
             (None, None, None),
             ('foo', None, 'foo'),
             (None, 'bar', 'bar'),
@@ -534,15 +534,13 @@ def test_set_bytecode_prefix(self):
         ]
         for envval, opt, expected in cases:
             exp_clause = "is None" if expected is None else f'== "{expected}"'
-            code = f"import sys; sys.exit(not sys.bytecode_prefix {exp_clause})"
+            code = f"import sys; sys.exit(not sys.pycache_prefix {exp_clause})"
             args = ['-c', code]
-            env = {}
-            if envval is not None:
-                env = {'PYTHONBYTECODEPREFIX': envval}
+            env = {} if envval is None else {'PYTHONPYCACHEPREFIX': envval}
             if opt is NO_VALUE:
-                args[:0] = ['-X', 'bytecode_prefix']
+                args[:0] = ['-X', 'pycache_prefix']
             elif opt is not None:
-                args[:0] = ['-X', f'bytecode_prefix={opt}']
+                args[:0] = ['-X', f'pycache_prefix={opt}']
             with self.subTest(envval=envval, opt=opt):
                 with support.temp_cwd():
                     assert_python_ok(*args, **env)

Lib/test/test_importlib/test_util.py

@@ -760,75 +760,75 @@ def test_source_from_cache_path_like_arg(self):
 
     @unittest.skipIf(sys.implementation.cache_tag is None,
                      'requires sys.implementation.cache_tag to not be None')
-    def test_cache_from_source_respects_bytecode_prefix(self):
-        # If bytecode_prefix is set, cache_from_source will return a bytecode
+    def test_cache_from_source_respects_pycache_prefix(self):
+        # If pycache_prefix is set, cache_from_source will return a bytecode
         # path inside that directory (in a subdirectory mirroring the .py file's
         # path) rather than in a __pycache__ dir next to the py file.
-        bytecode_prefixes = [
+        pycache_prefixes = [
             os.path.join(os.path.sep, 'tmp', 'bytecode'),
             os.path.join(os.path.sep, 'tmp', '\u2603'),  # non-ASCII in path!
             os.path.join(os.path.sep, 'tmp', 'trailing-slash') + os.path.sep,
         ]
         drive = ''
         if os.name == 'nt':
             drive = 'C:'
-            bytecode_prefixes = [
-                f'{drive}{prefix}' for prefix in bytecode_prefixes]
-            bytecode_prefixes += [r'\\?\C:\foo', r'\\localhost\c$\bar']
-        for bytecode_prefix in bytecode_prefixes:
-            with self.subTest(path=bytecode_prefix):
+            pycache_prefixes = [
+                f'{drive}{prefix}' for prefix in pycache_prefixes]
+            pycache_prefixes += [r'\\?\C:\foo', r'\\localhost\c$\bar']
+        for pycache_prefix in pycache_prefixes:
+            with self.subTest(path=pycache_prefix):
                 path = drive + os.path.join(
                     os.path.sep, 'foo', 'bar', 'baz', 'qux.py')
                 expect = os.path.join(
-                    bytecode_prefix, 'foo', 'bar', 'baz',
+                    pycache_prefix, 'foo', 'bar', 'baz',
                     'qux.{}.pyc'.format(self.tag))
-                with util.temporary_bytecode_prefix(bytecode_prefix):
+                with util.temporary_pycache_prefix(pycache_prefix):
                     self.assertEqual(
                         self.util.cache_from_source(path, optimization=''),
                         expect)
 
     @unittest.skipIf(sys.implementation.cache_tag is None,
                      'requires sys.implementation.cache_tag to not be None')
-    def test_cache_from_source_respects_bytecode_prefix_relative(self):
+    def test_cache_from_source_respects_pycache_prefix_relative(self):
         # If the .py path we are given is relative, we will resolve to an
-        # absolute path before prefixing with bytecode_prefix, to avoid any
+        # absolute path before prefixing with pycache_prefix, to avoid any
         # possible ambiguity.
-        bytecode_prefix = os.path.join(os.path.sep, 'tmp', 'bytecode')
+        pycache_prefix = os.path.join(os.path.sep, 'tmp', 'bytecode')
         path = os.path.join('foo', 'bar', 'baz', 'qux.py')
         root = os.path.splitdrive(os.getcwd())[0] + os.path.sep
         expect = os.path.join(
-            bytecode_prefix,
+            pycache_prefix,
             os.path.relpath(os.getcwd(), root),
             'foo', 'bar', 'baz', f'qux.{self.tag}.pyc')
-        with util.temporary_bytecode_prefix(bytecode_prefix):
+        with util.temporary_pycache_prefix(pycache_prefix):
             self.assertEqual(
                 self.util.cache_from_source(path, optimization=''),
                 expect)
 
     @unittest.skipIf(sys.implementation.cache_tag is None,
                      'requires sys.implementation.cache_tag to not be None')
-    def test_source_from_cache_inside_bytecode_prefix(self):
-        # If bytecode_prefix is set and the cache path we get is inside it,
+    def test_source_from_cache_inside_pycache_prefix(self):
+        # If pycache_prefix is set and the cache path we get is inside it,
         # we return an absolute path to the py file based on the remainder of
-        # the path within bytecode_prefix.
-        bytecode_prefix = os.path.join(os.path.sep, 'tmp', 'bytecode')
-        path = os.path.join(bytecode_prefix, 'foo', 'bar', 'baz',
+        # the path within pycache_prefix.
+        pycache_prefix = os.path.join(os.path.sep, 'tmp', 'bytecode')
+        path = os.path.join(pycache_prefix, 'foo', 'bar', 'baz',
                             f'qux.{self.tag}.pyc')
         expect = os.path.join(os.path.sep, 'foo', 'bar', 'baz', 'qux.py')
-        with util.temporary_bytecode_prefix(bytecode_prefix):
+        with util.temporary_pycache_prefix(pycache_prefix):
             self.assertEqual(self.util.source_from_cache(path), expect)
 
     @unittest.skipIf(sys.implementation.cache_tag is None,
                      'requires sys.implementation.cache_tag to not be None')
-    def test_source_from_cache_outside_bytecode_prefix(self):
-        # If bytecode_prefix is set but the cache path we get is not inside
+    def test_source_from_cache_outside_pycache_prefix(self):
+        # If pycache_prefix is set but the cache path we get is not inside
         # it, just ignore it and handle the cache path according to the default
         # behavior.
-        bytecode_prefix = os.path.join(os.path.sep, 'tmp', 'bytecode')
+        pycache_prefix = os.path.join(os.path.sep, 'tmp', 'bytecode')
         path = os.path.join('foo', 'bar', 'baz', '__pycache__',
                             f'qux.{self.tag}.pyc')
         expect = os.path.join('foo', 'bar', 'baz', 'qux.py')
-        with util.temporary_bytecode_prefix(bytecode_prefix):
+        with util.temporary_pycache_prefix(pycache_prefix):
             self.assertEqual(self.util.source_from_cache(path), expect)
 
 

Lib/test/test_importlib/util.py

@@ -320,14 +320,14 @@ def ensure_bytecode_path(bytecode_path):
 
 
 @contextlib.contextmanager
-def temporary_bytecode_prefix(prefix):
-    """Adjust and restore sys.bytecode_prefix."""
-    _orig_prefix = sys.bytecode_prefix
-    sys.bytecode_prefix = prefix
+def temporary_pycache_prefix(prefix):
+    """Adjust and restore sys.pycache_prefix."""
+    _orig_prefix = sys.pycache_prefix
+    sys.pycache_prefix = prefix
     try:
         yield
     finally:
-        sys.bytecode_prefix = _orig_prefix
+        sys.pycache_prefix = _orig_prefix
 
 
 @contextlib.contextmanager

Modules/main.c

@@ -145,7 +145,7 @@ static const char usage_6[] =
 "   coercion behavior. Use PYTHONCOERCECLOCALE=warn to request display of\n"
 "   locale coercion and locale compatibility warnings on stderr.\n"
 "PYTHONDEVMODE: enable the development mode.\n"
-"PYTHONBYTECODEPREFIX: root directory for bytecode cache (pyc) files.\n";
+"PYTHONPYCACHEPREFIX: root directory for bytecode cache (pyc) files.\n";
 
 static void
 pymain_usage(int error, const wchar_t* program)
@@ -1677,29 +1677,29 @@ pymain_init_tracemalloc(_PyCoreConfig *config)
 
 
 static _PyInitError
-pymain_init_bytecode_prefix(_PyCoreConfig *config)
+pymain_init_pycache_prefix(_PyCoreConfig *config)
 {
     wchar_t *env;
 
     int res = config_get_env_var_dup(
-        &env, L"PYTHONBYTECODEPREFIX", "PYTHONBYTECODEPREFIX");
+        &env, L"PYTHONPYCACHEPREFIX", "PYTHONPYCACHEPREFIX");
     if (res < 0) {
-        return DECODE_LOCALE_ERR("PYTHONBYTECODEPREFIX", res);
+        return DECODE_LOCALE_ERR("PYTHONPYCACHEPREFIX", res);
     } else if (env) {
-        config->bytecode_prefix = env;
+        config->pycache_prefix = env;
     }
 
-    const wchar_t *xoption = config_get_xoption(config, L"bytecode_prefix");
+    const wchar_t *xoption = config_get_xoption(config, L"pycache_prefix");
     if (xoption) {
         const wchar_t *sep = wcschr(xoption, L'=');
         if (sep && wcslen(sep) > 1) {
-            config->bytecode_prefix = _PyMem_RawWcsdup(sep + 1);
-            if (config->bytecode_prefix == NULL) {
+            config->pycache_prefix = _PyMem_RawWcsdup(sep + 1);
+            if (config->pycache_prefix == NULL) {
                 return _Py_INIT_NO_MEMORY();
             }
         } else {
-            // -X bytecode_prefix= can cancel the env var
-            config->bytecode_prefix = NULL;
+            // -X pycache_prefix= can cancel the env var
+            config->pycache_prefix = NULL;
         }
     }
 
@@ -1901,7 +1901,7 @@ config_read_complex_options(_PyCoreConfig *config)
         return err;
     }
 
-    err = pymain_init_bytecode_prefix(config);
+    err = pymain_init_pycache_prefix(config);
     if (_Py_INIT_FAILED(err)) {
         return err;
     }
@@ -2275,7 +2275,7 @@ _PyCoreConfig_Clear(_PyCoreConfig *config)
         LIST = NULL; \
     } while (0)
 
-    CLEAR(config->bytecode_prefix);
+    CLEAR(config->pycache_prefix);
     CLEAR(config->module_search_path_env);
     CLEAR(config->home);
     CLEAR(config->program_name);
@@ -2340,7 +2340,7 @@ _PyCoreConfig_Copy(_PyCoreConfig *config, const _PyCoreConfig *config2)
     COPY_ATTR(malloc_stats);
     COPY_ATTR(utf8_mode);
 
-    COPY_STR_ATTR(bytecode_prefix);
+    COPY_STR_ATTR(pycache_prefix);
     COPY_STR_ATTR(module_search_path_env);
     COPY_STR_ATTR(home);
     COPY_STR_ATTR(program_name);
@@ -2376,7 +2376,7 @@ _PyMainInterpreterConfig_Clear(_PyMainInterpreterConfig *config)
     Py_CLEAR(config->warnoptions);
     Py_CLEAR(config->xoptions);
     Py_CLEAR(config->module_search_path);
-    Py_CLEAR(config->bytecode_prefix);
+    Py_CLEAR(config->pycache_prefix);
 }
 
 
@@ -2429,7 +2429,7 @@ _PyMainInterpreterConfig_Copy(_PyMainInterpreterConfig *config,
     COPY_ATTR(warnoptions);
     COPY_ATTR(xoptions);
     COPY_ATTR(module_search_path);
-    COPY_ATTR(bytecode_prefix);
+    COPY_ATTR(pycache_prefix);
 #undef COPY_ATTR
     return 0;
 }
@@ -2488,10 +2488,10 @@ _PyMainInterpreterConfig_Read(_PyMainInterpreterConfig *main_config,
         COPY_WSTRLIST(main_config->module_search_path,
                       config->nmodule_search_path, config->module_search_paths);
 
-        if (config->bytecode_prefix != NULL) {
-            COPY_WSTR(bytecode_prefix);
+        if (config->pycache_prefix != NULL) {
+            COPY_WSTR(pycache_prefix);
         } else {
-            main_config->bytecode_prefix = NULL;
+            main_config->pycache_prefix = NULL;
         }
 
     }