Index: Python/errors.c =================================================================== --- Python/errors.c (Revision 59256) +++ Python/errors.c (Arbeitskopie) @@ -645,7 +645,7 @@ else { char* modstr = PyUnicode_AsString(moduleName); if (modstr && - strcmp(modstr, "__builtin__") != 0) + strcmp(modstr, "builtins") != 0) { PyFile_WriteString(modstr, f); PyFile_WriteString(".", f); Index: Python/pythonrun.c =================================================================== --- Python/pythonrun.c (Revision 59256) +++ Python/pythonrun.c (Arbeitskopie) @@ -211,7 +211,7 @@ bimod = _PyBuiltin_Init(); if (bimod == NULL) - Py_FatalError("Py_Initialize: can't initialize __builtin__"); + Py_FatalError("Py_Initialize: can't initialize builtins modules"); interp->builtins = PyModule_GetDict(bimod); if (interp->builtins == NULL) Py_FatalError("Py_Initialize: can't initialize builtins dict"); @@ -243,7 +243,7 @@ _PyImport_Init(); /* phase 2 of builtins */ - _PyImport_FixupExtension("__builtin__", "__builtin__"); + _PyImport_FixupExtension("builtins", "builtins"); _PyImportHooks_Init(); @@ -572,7 +572,7 @@ interp->modules = PyDict_New(); interp->modules_reloading = PyDict_New(); - bimod = _PyImport_FindExtension("__builtin__", "__builtin__"); + bimod = _PyImport_FindExtension("builtins", "builtins"); if (bimod != NULL) { interp->builtins = PyModule_GetDict(bimod); if (interp->builtins == NULL) @@ -682,7 +682,7 @@ Py_FatalError("can't create __main__ module"); d = PyModule_GetDict(m); if (PyDict_GetItemString(d, "__builtins__") == NULL) { - PyObject *bimod = PyImport_ImportModule("__builtin__"); + PyObject *bimod = PyImport_ImportModule("builtins"); if (bimod == NULL || PyDict_SetItemString(d, "__builtins__", bimod) != 0) Py_FatalError("can't add __builtins__ to __main__"); @@ -717,7 +717,7 @@ } } -/* Initialize sys.stdin, stdout, stderr and __builtin__.open */ +/* Initialize sys.stdin, stdout, stderr and builtins.open */ static int initstdio(void) { @@ -739,7 +739,7 @@ } Py_DECREF(m); - if (!(bimod = PyImport_ImportModule("__builtin__"))) { + if (!(bimod = PyImport_ImportModule("builtins"))) { goto error; } @@ -750,7 +750,7 @@ goto error; } - /* Set __builtin__.open */ + /* Set builtins.open */ if (PyObject_SetAttrString(bimod, "open", wrapper) == -1) { goto error; } @@ -1362,7 +1362,7 @@ } else { char* modstr = PyUnicode_AsString(moduleName); - if (modstr && strcmp(modstr, "__builtin__")) + if (modstr && strcmp(modstr, "builtins")) { err = PyFile_WriteString(modstr, f); err += PyFile_WriteString(".", f); Index: Python/import.c =================================================================== --- Python/import.c (Revision 59256) +++ Python/import.c (Arbeitskopie) @@ -400,11 +400,11 @@ deleted *last* of all, they would come too late in the normal destruction order. Sigh. */ - value = PyDict_GetItemString(modules, "__builtin__"); + value = PyDict_GetItemString(modules, "builtins"); if (value != NULL && PyModule_Check(value)) { dict = PyModule_GetDict(value); if (Py_VerboseFlag) - PySys_WriteStderr("# clear __builtin__._\n"); + PySys_WriteStderr("# clear builtins._\n"); PyDict_SetItemString(dict, "_", Py_None); } value = PyDict_GetItemString(modules, "sys"); @@ -436,11 +436,11 @@ PyDict_SetItemString(modules, "__main__", Py_None); } - /* The special treatment of __builtin__ here is because even + /* The special treatment of "builtins" here is because even when it's not referenced as a module, its dictionary is referenced by almost every module's __builtins__. Since deleting a module clears its dictionary (even if there are - references left to it), we need to delete the __builtin__ + references left to it), we need to delete the "builtins" module last. Likewise, we don't delete sys until the very end because it is implicitly referenced (e.g. by print). @@ -451,7 +451,7 @@ re-imported. */ /* Next, repeatedly delete modules with a reference count of - one (skipping __builtin__ and sys) and delete them */ + one (skipping builtins and sys) and delete them */ do { ndone = 0; pos = 0; @@ -460,7 +460,7 @@ continue; if (PyUnicode_Check(key) && PyModule_Check(value)) { name = PyUnicode_AsString(key); - if (strcmp(name, "__builtin__") == 0) + if (strcmp(name, "builtins") == 0) continue; if (strcmp(name, "sys") == 0) continue; @@ -474,12 +474,12 @@ } } while (ndone > 0); - /* Next, delete all modules (still skipping __builtin__ and sys) */ + /* Next, delete all modules (still skipping builtins and sys) */ pos = 0; while (PyDict_Next(modules, &pos, &key, &value)) { if (PyUnicode_Check(key) && PyModule_Check(value)) { name = PyUnicode_AsString(key); - if (strcmp(name, "__builtin__") == 0) + if (strcmp(name, "builtins") == 0) continue; if (strcmp(name, "sys") == 0) continue; @@ -490,7 +490,7 @@ } } - /* Next, delete sys and __builtin__ (in that order) */ + /* Next, delete sys and builtins (in that order) */ value = PyDict_GetItemString(modules, "sys"); if (value != NULL && PyModule_Check(value)) { if (Py_VerboseFlag) @@ -498,12 +498,12 @@ _PyModule_Clear(value); PyDict_SetItemString(modules, "sys", Py_None); } - value = PyDict_GetItemString(modules, "__builtin__"); + value = PyDict_GetItemString(modules, "builtins"); if (value != NULL && PyModule_Check(value)) { if (Py_VerboseFlag) - PySys_WriteStderr("# cleanup __builtin__\n"); + PySys_WriteStderr("# cleanup builtins\n"); _PyModule_Clear(value); - PyDict_SetItemString(modules, "__builtin__", Py_None); + PyDict_SetItemString(modules, "builtins", Py_None); } /* Finally, clear and delete the modules directory */ @@ -2491,7 +2491,7 @@ /* No globals -- use standard builtins, and fake globals */ PyErr_Clear(); - builtins = PyImport_ImportModuleLevel("__builtin__", + builtins = PyImport_ImportModuleLevel("builtins", NULL, NULL, NULL, 0); if (builtins == NULL) return NULL; Index: Python/bltinmodule.c =================================================================== --- Python/bltinmodule.c (Revision 59256) +++ Python/bltinmodule.c (Arbeitskopie) @@ -1851,7 +1851,7 @@ _PyBuiltin_Init(void) { PyObject *mod, *dict, *debug; - mod = Py_InitModule4("__builtin__", builtin_methods, + mod = Py_InitModule4("builtins", builtin_methods, builtin_doc, (PyObject *)NULL, PYTHON_API_VERSION); if (mod == NULL) @@ -1859,7 +1859,7 @@ dict = PyModule_GetDict(mod); #ifdef Py_TRACE_REFS - /* __builtin__ exposes a number of statically allocated objects + /* "builtins" exposes a number of statically allocated objects * that, before this code was added in 2.3, never showed up in * the list of "all objects" maintained by Py_TRACE_REFS. As a * result, programs leaking references to None and False (etc) Index: Python/sysmodule.c =================================================================== --- Python/sysmodule.c (Revision 59256) +++ Python/sysmodule.c (Arbeitskopie) @@ -72,10 +72,10 @@ PyObject *outf; PyInterpreterState *interp = PyThreadState_GET()->interp; PyObject *modules = interp->modules; - PyObject *builtins = PyDict_GetItemString(modules, "__builtin__"); + PyObject *builtins = PyDict_GetItemString(modules, "builtins"); if (builtins == NULL) { - PyErr_SetString(PyExc_RuntimeError, "lost __builtin__"); + PyErr_SetString(PyExc_RuntimeError, "lost builtins module"); return NULL; } @@ -106,7 +106,7 @@ PyDoc_STRVAR(displayhook_doc, "displayhook(object) -> None\n" "\n" -"Print an object to sys.stdout and also save it in __builtin__.\n" +"Print an object to sys.stdout and also save it in builtins.\n" ); static PyObject * @@ -896,7 +896,7 @@ \n\ Functions:\n\ \n\ -displayhook() -- print an object to the screen, and save it in __builtin__._\n\ +displayhook() -- print an object to the screen, and save it in builtins._\n\ excepthook() -- print an exception and its traceback to sys.stderr\n\ exc_info() -- return thread-safe information about the current exception\n\ exit() -- exit the interpreter by raising SystemExit\n\ Index: Include/object.h =================================================================== --- Include/object.h (Revision 59256) +++ Include/object.h (Arbeitskopie) @@ -458,8 +458,8 @@ extern int _PyObject_SlotCompare(PyObject *, PyObject *); -/* PyObject_Dir(obj) acts like Python __builtin__.dir(obj), returning a - list of strings. PyObject_Dir(NULL) is like __builtin__.dir(), +/* PyObject_Dir(obj) acts like Python builtins.dir(obj), returning a + list of strings. PyObject_Dir(NULL) is like builtins.dir(), returning the names of the current locals. In this case, if there are no current locals, NULL is returned, and PyErr_Occurred() is false. */ Index: Demo/pdist/client.py =================================================================== --- Demo/pdist/client.py (Revision 59256) +++ Demo/pdist/client.py (Arbeitskopie) @@ -3,7 +3,7 @@ import sys import socket import pickle -import __builtin__ +import builtins import os @@ -90,8 +90,8 @@ if exception is None: return value x = exception - if hasattr(__builtin__, exception): - x = getattr(__builtin__, exception) + if hasattr(builtins, exception): + x = getattr(builtins, exception) elif exception in ('posix.error', 'mac.error'): x = os.error if x == exception: Index: Demo/imputil/knee.py =================================================================== --- Demo/imputil/knee.py (Revision 59256) +++ Demo/imputil/knee.py (Arbeitskopie) @@ -7,7 +7,7 @@ """ -import sys, imp, __builtin__ +import sys, imp, builtins # Replacement for __import__() @@ -117,7 +117,7 @@ # Save the original hooks -original_import = __builtin__.__import__ +original_import = builtins.__import__ # Now install our hooks -__builtin__.__import__ = import_hook +builtins.__import__ = import_hook Index: Demo/classes/Range.py =================================================================== --- Demo/classes/Range.py (Revision 59256) +++ Demo/classes/Range.py (Arbeitskopie) @@ -64,9 +64,9 @@ def test(): - import time, __builtin__ + import time, builtins #Just a quick sanity check - correct_result = __builtin__.range(5, 100, 3) + correct_result = builtins.range(5, 100, 3) oldrange_result = list(oldrange(5, 100, 3)) genrange_result = list(genrange(5, 100, 3)) if genrange_result != correct_result or oldrange_result != correct_result: @@ -81,7 +81,7 @@ for i in genrange(1000): pass t3 = time.time() - for i in __builtin__.range(1000): + for i in builtins.range(1000): pass t4 = time.time() print(t2-t1, 'sec (old-style class)') Index: Objects/typeobject.c =================================================================== --- Objects/typeobject.c (Revision 59256) +++ Objects/typeobject.c (Arbeitskopie) @@ -112,7 +112,7 @@ if (s != NULL) return PyUnicode_FromStringAndSize( type->tp_name, (Py_ssize_t)(s - type->tp_name)); - return PyUnicode_FromString("__builtin__"); + return PyUnicode_FromString("builtins"); } } @@ -397,7 +397,7 @@ else kind = "type"; - if (mod != NULL && PyUnicode_CompareWithASCIIString(mod, "__builtin__")) + if (mod != NULL && PyUnicode_CompareWithASCIIString(mod, "builtins")) rtn = PyUnicode_FromFormat("<%s '%U.%U'>", kind, mod, name); else rtn = PyUnicode_FromFormat("<%s '%s'>", kind, type->tp_name); @@ -2455,7 +2455,7 @@ name = type_name(type, NULL); if (name == NULL) return NULL; - if (mod != NULL && PyUnicode_CompareWithASCIIString(mod, "__builtin__")) + if (mod != NULL && PyUnicode_CompareWithASCIIString(mod, "builtins")) rtn = PyUnicode_FromFormat("<%U.%U object at %p>", mod, name, self); else rtn = PyUnicode_FromFormat("<%s object at %p>", Index: Objects/listobject.c =================================================================== --- Objects/listobject.c (Revision 59256) +++ Objects/listobject.c (Arbeitskopie) @@ -1961,7 +1961,7 @@ module = PyUnicode_AsString(f->m_module); if (module == NULL) return 0; - if (strcmp(module, "__builtin__") != 0) + if (strcmp(module, "builtins") != 0) return 0; if (strcmp(f->m_ml->ml_name, "cmp") != 0) return 0; Index: Objects/exceptions.c =================================================================== --- Objects/exceptions.c (Revision 59256) +++ Objects/exceptions.c (Arbeitskopie) @@ -1849,7 +1849,7 @@ PRE_INIT(UnicodeWarning) PRE_INIT(BytesWarning) - bltinmod = PyImport_ImportModule("__builtin__"); + bltinmod = PyImport_ImportModule("builtins"); if (bltinmod == NULL) Py_FatalError("exceptions bootstrapping error."); bdict = PyModule_GetDict(bltinmod); Index: Misc/Vim/vim_syntax.py =================================================================== --- Misc/Vim/vim_syntax.py (Revision 59256) +++ Misc/Vim/vim_syntax.py (Arbeitskopie) @@ -4,7 +4,7 @@ import keyword import exceptions -import __builtin__ +import builtins from string import Template comment_header = '''" Auto-generated Vim syntax file for Python. @@ -39,7 +39,7 @@ # nothing that comes with modules (e.g., __name__), so just exclude anything in # the 'exceptions' module since we want to ignore exceptions *and* what any # module would have -builtin_names = sorted(builtin for builtin in dir(__builtin__) +builtin_names = sorted(builtin for builtin in dir(builtins) if builtin not in dir(exceptions)) escapes = (r'+\\[abfnrtv\'"\\]+', r'"\\\o\{1,3}"', r'"\\x\x\{2}"', Index: Tools/freeze/makeconfig.py =================================================================== --- Tools/freeze/makeconfig.py (Revision 59256) +++ Tools/freeze/makeconfig.py (Arbeitskopie) @@ -3,7 +3,7 @@ # Write the config.c file -never = ['marshal', '__main__', '__builtin__', 'sys', 'exceptions'] +never = ['marshal', '__main__', 'builtins', 'sys', 'exceptions'] def makeconfig(infp, outfp, modules, with_ifdef=0): m1 = re.compile('-- ADDMODULE MARKER 1 --') Index: PC/config.c =================================================================== --- PC/config.c (Revision 59256) +++ PC/config.c (Arbeitskopie) @@ -143,7 +143,7 @@ /* These entries are here for sys.builtin_module_names */ {"__main__", NULL}, - {"__builtin__", NULL}, + {"builtins", NULL}, {"sys", NULL}, {"_types", init_types}, Index: PC/os2emx/config.c =================================================================== --- PC/os2emx/config.c (Revision 59256) +++ PC/os2emx/config.c (Arbeitskopie) @@ -156,7 +156,7 @@ /* These entries are here for sys.builtin_module_names */ {"__main__", NULL}, - {"__builtin__", NULL}, + {"builtins", NULL}, {"sys", NULL}, /* This lives in gcmodule.c */ Index: PC/bdist_wininst/install.c =================================================================== --- PC/bdist_wininst/install.c (Revision 59256) +++ PC/bdist_wininst/install.c (Arbeitskopie) @@ -654,7 +654,7 @@ if (!Py_BuildValue || !PyArg_ParseTuple || !PyErr_Format) return 1; - mod = PyImport_ImportModule("__builtin__"); + mod = PyImport_ImportModule("builtins"); if (mod) { int i; g_PyExc_ValueError = PyObject_GetAttrString(mod, "ValueError"); Index: PC/os2vacpp/config.c =================================================================== --- PC/os2vacpp/config.c (Revision 59256) +++ PC/os2vacpp/config.c (Arbeitskopie) @@ -94,7 +94,7 @@ /* These entries are here for sys.builtin_module_names */ {"__main__", NULL}, - {"__builtin__", NULL}, + {"builtins", NULL}, {"sys", NULL}, /* Sentinel */ Index: Doc/c-api/intro.rst =================================================================== --- Doc/c-api/intro.rst (Revision 59256) +++ Doc/c-api/intro.rst (Arbeitskopie) @@ -507,7 +507,7 @@ .. index:: single: Py_Initialize() - module: __builtin__ + module: builtins module: __main__ module: sys module: exceptions @@ -516,7 +516,7 @@ The basic initialization function is :cfunc:`Py_Initialize`. This initializes the table of loaded modules, and creates the fundamental modules -:mod:`__builtin__`, :mod:`__main__`, :mod:`sys`, and :mod:`exceptions`. It also +:mod:`builtins`, :mod:`__main__`, :mod:`sys`, and :mod:`exceptions`. It also initializes the module search path (``sys.path``). .. index:: single: PySys_SetArgv() Index: Doc/c-api/init.rst =================================================================== --- Doc/c-api/init.rst (Revision 59256) +++ Doc/c-api/init.rst (Arbeitskopie) @@ -17,7 +17,7 @@ single: PyEval_AcquireLock() single: modules (in module sys) single: path (in module sys) - module: __builtin__ + module: builtins module: __main__ module: sys triple: module; search; path @@ -29,7 +29,7 @@ exception of :cfunc:`Py_SetProgramName`, :cfunc:`PyEval_InitThreads`, :cfunc:`PyEval_ReleaseLock`, and :cfunc:`PyEval_AcquireLock`. This initializes the table of loaded modules (``sys.modules``), and creates the fundamental - modules :mod:`__builtin__`, :mod:`__main__` and :mod:`sys`. It also initializes + modules :mod:`builtins`, :mod:`__main__` and :mod:`sys`. It also initializes the module search path (``sys.path``). It does not set ``sys.argv``; use :cfunc:`PySys_SetArgv` for that. This is a no-op when called for a second time (without calling :cfunc:`Py_Finalize` first). There is no return value; it is a @@ -83,7 +83,7 @@ .. cfunction:: PyThreadState* Py_NewInterpreter() .. index:: - module: __builtin__ + module: builtins module: __main__ module: sys single: stdout (in module sys) @@ -93,7 +93,7 @@ Create a new sub-interpreter. This is an (almost) totally separate environment for the execution of Python code. In particular, the new interpreter has separate, independent versions of all imported modules, including the - fundamental modules :mod:`__builtin__`, :mod:`__main__` and :mod:`sys`. The + fundamental modules :mod:`builtins`, :mod:`__main__` and :mod:`sys`. The table of loaded modules (``sys.modules``) and the module search path (``sys.path``) are also separate. The new environment has no ``sys.argv`` variable. It has new standard I/O stream file objects ``sys.stdin``, Index: Doc/reference/toplevel_components.rst =================================================================== --- Doc/reference/toplevel_components.rst (Revision 59256) +++ Doc/reference/toplevel_components.rst (Arbeitskopie) @@ -23,13 +23,13 @@ .. index:: module: sys module: __main__ - module: __builtin__ + module: builtins While a language specification need not prescribe how the language interpreter is invoked, it is useful to have a notion of a complete Python program. A complete Python program is executed in a minimally initialized environment: all built-in and standard modules are available, but none have been initialized, -except for :mod:`sys` (various system services), :mod:`__builtin__` (built-in +except for :mod:`sys` (various system services), :mod:`builtins` (built-in functions, exceptions and ``None``) and :mod:`__main__`. The latter is used to provide the local and global namespace for execution of the complete program. Index: Doc/reference/executionmodel.rst =================================================================== --- Doc/reference/executionmodel.rst (Revision 59256) +++ Doc/reference/executionmodel.rst (Arbeitskopie) @@ -105,7 +105,7 @@ specified in the statement refer to the binding of that name in the top-level namespace. Names are resolved in the top-level namespace by searching the global namespace, i.e. the namespace of the module containing the code block, -and the builtin namespace, the namespace of the module :mod:`__builtin__`. The +and the builtin namespace, the namespace of the module :mod:`builtins`. The global namespace is searched first. If the name is not found there, the builtin namespace is searched. The global statement must precede all uses of the name. @@ -117,8 +117,8 @@ found by looking up the name ``__builtins__`` in its global namespace; this should be a dictionary or a module (in the latter case the module's dictionary is used). By default, when in the :mod:`__main__` module, ``__builtins__`` is -the built-in module :mod:`__builtin__` (note: no 's'); when in any other module, -``__builtins__`` is an alias for the dictionary of the :mod:`__builtin__` module +the built-in module :mod:`builtins`; when in any other module, +``__builtins__`` is an alias for the dictionary of the :mod:`builtins` module itself. ``__builtins__`` can be set to a user-created dictionary to create a weak form of restricted execution. @@ -126,7 +126,7 @@ Users should not touch ``__builtins__``; it is strictly an implementation detail. Users wanting to override values in the built-in namespace should - :keyword:`import` the :mod:`__builtin__` (no 's') module and modify its + :keyword:`import` the :mod:`builtins` module and modify its attributes appropriately. .. index:: module: __main__ Index: Doc/reference/lexical_analysis.rst =================================================================== --- Doc/reference/lexical_analysis.rst (Revision 59256) +++ Doc/reference/lexical_analysis.rst (Arbeitskopie) @@ -344,7 +344,7 @@ ``_*`` Not imported by ``from module import *``. The special identifier ``_`` is used in the interactive interpreter to store the result of the last evaluation; it is - stored in the :mod:`__builtin__` module. When not in interactive mode, ``_`` + stored in the :mod:`builtins` module. When not in interactive mode, ``_`` has no special meaning and is not defined. See section :ref:`import`. .. note:: Index: Doc/tutorial/modules.rst =================================================================== --- Doc/tutorial/modules.rst (Revision 59256) +++ Doc/tutorial/modules.rst (Arbeitskopie) @@ -308,14 +308,14 @@ Note that it lists all types of names: variables, modules, functions, etc. -.. index:: module: __builtin__ +.. index:: module: builtins :func:`dir` does not list the names of built-in functions and variables. If you want a list of those, they are defined in the standard module -:mod:`__builtin__`:: +:mod:`builtins`:: - >>> import __builtin__ - >>> dir(__builtin__) + >>> import builtins + >>> dir(builtins) ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'Buffer Error', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Excep Index: Doc/tutorial/classes.rst =================================================================== --- Doc/tutorial/classes.rst (Revision 59256) +++ Doc/tutorial/classes.rst (Arbeitskopie) @@ -98,7 +98,7 @@ invocation of the interpreter, either read from a script file or interactively, are considered part of a module called :mod:`__main__`, so they have their own global namespace. (The built-in names actually also live in a module; this is -called :mod:`__builtin__`.) +called :mod:`builtins`.) The local namespace for a function is created when the function is called, and deleted when the function returns or raises an exception that is not handled Index: Doc/library/rlcompleter.rst =================================================================== --- Doc/library/rlcompleter.rst (Revision 59256) +++ Doc/library/rlcompleter.rst (Arbeitskopie) @@ -55,7 +55,7 @@ Return the *state*th completion for *text*. If called for *text* that doesn't include a period character (``'.'``), it will - complete from names currently defined in :mod:`__main__`, :mod:`__builtin__` and + complete from names currently defined in :mod:`__main__`, :mod:`builtins` and keywords (as defined by the :mod:`keyword` module). If called for a dotted name, it will try to evaluate anything without obvious Index: Doc/library/sys.rst =================================================================== --- Doc/library/sys.rst (Revision 59256) +++ Doc/library/sys.rst (Arbeitskopie) @@ -78,7 +78,7 @@ .. function:: displayhook(value) If *value* is not ``None``, this function prints it to ``sys.stdout``, and saves - it in ``__builtin__._``. + it in ``builtins._``. ``sys.displayhook`` is called on the result of evaluating an expression entered in an interactive Python session. The display of these values can be customized Index: Doc/library/__builtin__.rst =================================================================== --- Doc/library/__builtin__.rst (Revision 59256) +++ Doc/library/__builtin__.rst (Arbeitskopie) @@ -1,41 +0,0 @@ - -:mod:`__builtin__` --- Built-in objects -======================================= - -.. module:: __builtin__ - :synopsis: The module that provides the built-in namespace. - - -This module provides direct access to all 'built-in' identifiers of Python; for -example, ``__builtin__.open`` is the full name for the built-in function -:func:`open`. See chapter :ref:`builtin`. - -This module is not normally accessed explicitly by most applications, but can be -useful in modules that provide objects with the same name as a built-in value, -but in which the built-in of that name is also needed. For example, in a module -that wants to implement an :func:`open` function that wraps the built-in -:func:`open`, this module can be used directly:: - - import __builtin__ - - def open(path): - f = __builtin__.open(path, 'r') - return UpperCaser(f) - - class UpperCaser: - '''Wrapper around a file that converts output to upper-case.''' - - def __init__(self, f): - self._f = f - - def read(self, count=-1): - return self._f.read(count).upper() - - # ... - -As an implementation detail, most modules have the name ``__builtins__`` (note -the ``'s'``) made available as part of their globals. The value of -``__builtins__`` is normally either this module or the value of this modules's -:attr:`__dict__` attribute. Since this is an implementation detail, it may not -be used by alternate implementations of Python. - Index: Doc/library/builtins.rst =================================================================== --- Doc/library/builtins.rst (Revision 59256) +++ Doc/library/builtins.rst (Arbeitskopie) @@ -1,13 +1,13 @@ -:mod:`__builtin__` --- Built-in objects -======================================= +:mod:`builtins` --- Built-in objects +==================================== -.. module:: __builtin__ +.. module:: builtins :synopsis: The module that provides the built-in namespace. This module provides direct access to all 'built-in' identifiers of Python; for -example, ``__builtin__.open`` is the full name for the built-in function +example, ``builtins.open`` is the full name for the built-in function :func:`open`. See chapter :ref:`builtin`. This module is not normally accessed explicitly by most applications, but can be @@ -16,10 +16,10 @@ that wants to implement an :func:`open` function that wraps the built-in :func:`open`, this module can be used directly:: - import __builtin__ + import builtins def open(path): - f = __builtin__.open(path, 'r') + f = builtins.open(path, 'r') return UpperCaser(f) class UpperCaser: Index: Doc/library/python.rst =================================================================== --- Doc/library/python.rst (Revision 59256) +++ Doc/library/python.rst (Arbeitskopie) @@ -13,7 +13,7 @@ .. toctree:: sys.rst - __builtin__.rst + builtins.rst __main__.rst warnings.rst contextlib.rst Index: Doc/library/runpy.rst =================================================================== --- Doc/library/runpy.rst (Revision 59256) +++ Doc/library/runpy.rst (Arbeitskopie) @@ -46,7 +46,7 @@ does not make filename information available, this variable is set to ``None``. ``__builtins__`` is automatically initialised with a reference to the top level - namespace of the :mod:`__builtin__` module. + namespace of the :mod:`builtins` module. If the argument *alter_sys* is supplied and evaluates to ``True``, then ``sys.argv[0]`` is updated with the value of ``__file__`` and Index: Doc/library/imputil.rst =================================================================== --- Doc/library/imputil.rst (Revision 59256) +++ Doc/library/imputil.rst (Arbeitskopie) @@ -108,7 +108,7 @@ :: - import sys, imp, __builtin__ + import sys, imp, builtins # Replacement for __import__() def import_hook(name, globals=None, locals=None, fromlist=None): @@ -218,12 +218,12 @@ # Save the original hooks - original_import = __builtin__.__import__ - original_reload = __builtin__.reload + original_import = builtins.__import__ + original_reload = builtins.reload # Now install our hooks - __builtin__.__import__ = import_hook - __builtin__.reload = reload_hook + builtins.__import__ = import_hook + builtins.reload = reload_hook .. index:: module: knee Index: Doc/library/functions.rst =================================================================== --- Doc/library/functions.rst (Revision 59256) +++ Doc/library/functions.rst (Arbeitskopie) @@ -356,7 +356,7 @@ dictionaries as global and local namespace. If the *globals* dictionary is present and lacks '__builtins__', the current globals are copied into *globals* before *expression* is parsed. This means that *expression* normally has full - access to the standard :mod:`__builtin__` module and restricted environments are + access to the standard :mod:`builtins` module and restricted environments are propagated. If the *locals* dictionary is omitted it defaults to the *globals* dictionary. If both dictionaries are omitted, the expression is executed in the environment where :keyword:`eval` is called. The return value is the result of @@ -398,7 +398,7 @@ If the *globals* dictionary does not contain a value for the key ``__builtins__``, a reference to the dictionary of the built-in module - :mod:`__builtin__` is inserted under that key. That way you can control what + :mod:`builtins` is inserted under that key. That way you can control what builtins are available to the executed code by inserting your own ``__builtins__`` dictionary into *globals* before passing it to :func:`exec`. Index: Doc/glossary.rst =================================================================== --- Doc/glossary.rst (Revision 59256) +++ Doc/glossary.rst (Arbeitskopie) @@ -268,7 +268,7 @@ dictionaries. There are the local, global and builtin namespaces as well as nested namespaces in objects (in methods). Namespaces support modularity by preventing naming conflicts. For instance, the functions - :func:`__builtin__.open` and :func:`os.open` are distinguished by their + :func:`builtins.open` and :func:`os.open` are distinguished by their namespaces. Namespaces also aid readability and maintainability by making it clear which module implements a function. For instance, writing :func:`random.seed` or :func:`itertools.izip` makes it clear that those Index: Lib/rlcompleter.py =================================================================== --- Lib/rlcompleter.py (Revision 59256) +++ Lib/rlcompleter.py (Arbeitskopie) @@ -33,7 +33,7 @@ """ -import __builtin__ +import builtins import __main__ __all__ = ["Completer"] @@ -97,7 +97,7 @@ matches = [] n = len(text) for list in [keyword.kwlist, - __builtin__.__dict__, + builtins.__dict__, self.namespace]: for word in list: if word[:n] == text and word != "__builtins__": Index: Lib/wave.py =================================================================== --- Lib/wave.py (Revision 59256) +++ Lib/wave.py (Arbeitskopie) @@ -71,7 +71,7 @@ is destroyed. """ -import __builtin__ +import builtins __all__ = ["open", "openfp", "Error"] @@ -156,7 +156,7 @@ def __init__(self, f): self._i_opened_the_file = None if isinstance(f, str): - f = __builtin__.open(f, 'rb') + f = builtins.open(f, 'rb') self._i_opened_the_file = f # else, assume it is an open file object already try: @@ -300,7 +300,7 @@ def __init__(self, f): self._i_opened_the_file = None if isinstance(f, str): - f = __builtin__.open(f, 'wb') + f = builtins.open(f, 'wb') self._i_opened_the_file = f try: self.initfp(f) Index: Lib/site.py =================================================================== --- Lib/site.py (Revision 59256) +++ Lib/site.py (Arbeitskopie) @@ -60,7 +60,7 @@ import sys import os -import __builtin__ +import builtins def makepath(*paths): @@ -251,8 +251,8 @@ except: pass raise SystemExit(code) - __builtin__.quit = Quitter('quit') - __builtin__.exit = Quitter('exit') + builtins.quit = Quitter('quit') + builtins.exit = Quitter('exit') class _Printer(object): @@ -319,18 +319,18 @@ break def setcopyright(): - """Set 'copyright' and 'credits' in __builtin__""" - __builtin__.copyright = _Printer("copyright", sys.copyright) + """Set 'copyright' and 'credits' in builtins""" + builtins.copyright = _Printer("copyright", sys.copyright) if sys.platform[:4] == 'java': - __builtin__.credits = _Printer( + builtins.credits = _Printer( "credits", "Jython is maintained by the Jython developers (www.jython.org).") else: - __builtin__.credits = _Printer("credits", """\ + builtins.credits = _Printer("credits", """\ Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands for supporting Python development. See www.python.org for more information.""") here = os.path.dirname(os.__file__) - __builtin__.license = _Printer( + builtins.license = _Printer( "license", "See http://www.python.org/%.3s/license.html" % sys.version, ["LICENSE.txt", "LICENSE"], [os.path.join(here, os.pardir), here, os.curdir]) @@ -350,7 +350,7 @@ return pydoc.help(*args, **kwds) def sethelper(): - __builtin__.help = _Helper() + builtins.help = _Helper() def aliasmbcs(): """On Windows, some default encodings are not provided by Python, Index: Lib/idlelib/ColorDelegator.py =================================================================== --- Lib/idlelib/ColorDelegator.py (Revision 59256) +++ Lib/idlelib/ColorDelegator.py (Arbeitskopie) @@ -1,7 +1,7 @@ import time import re import keyword -import __builtin__ +import builtins from Tkinter import * from idlelib.Delegator import Delegator from idlelib.configHandler import idleConf @@ -14,7 +14,7 @@ def make_pat(): kw = r"\b" + any("KEYWORD", keyword.kwlist) + r"\b" - builtinlist = [str(name) for name in dir(__builtin__) + builtinlist = [str(name) for name in dir(builtins) if not name.startswith('_')] # self.file = open("file") : # 1st 'file' colorized normal, 2nd as builtin, 3rd as string Index: Lib/idlelib/RemoteDebugger.py =================================================================== --- Lib/idlelib/RemoteDebugger.py (Revision 59256) +++ Lib/idlelib/RemoteDebugger.py (Arbeitskopie) @@ -172,7 +172,7 @@ def dict_item(self, did, key): dict = dicttable[did] value = dict[key] - value = repr(value) ### can't pickle module '__builtin__' + value = repr(value) ### can't pickle module 'builtins' return value #----------end class IdbAdapter---------- Index: Lib/optparse.py =================================================================== --- Lib/optparse.py (Revision 59256) +++ Lib/optparse.py (Arbeitskopie) @@ -636,13 +636,13 @@ else: # Allow type objects or builtin type conversion functions # (int, str, etc.) as an alternative to their names. (The - # complicated check of __builtin__ is only necessary for + # complicated check of builtins is only necessary for # Python 2.1 and earlier, and is short-circuited by the # first check on modern Pythons.) - import __builtin__ + import builtins if ( isinstance(self.type, type) or (hasattr(self.type, "__name__") and - getattr(__builtin__, self.type.__name__, None) is self.type) ): + getattr(builtins, self.type.__name__, None) is self.type) ): self.type = self.type.__name__ if self.type == "str": Index: Lib/py_compile.py =================================================================== --- Lib/py_compile.py (Revision 59256) +++ Lib/py_compile.py (Arbeitskopie) @@ -3,7 +3,7 @@ This module has intimate knowledge of the format of .pyc files. """ -import __builtin__ +import builtins import imp import marshal import os @@ -139,7 +139,7 @@ if codestring and codestring[-1] != '\n': codestring = codestring + '\n' try: - codeobject = __builtin__.compile(codestring, dfile or file,'exec') + codeobject = builtins.compile(codestring, dfile or file,'exec') except Exception as err: py_exc = PyCompileError(err.__class__, err, dfile or file) if doraise: Index: Lib/dumbdbm.py =================================================================== --- Lib/dumbdbm.py (Revision 59256) +++ Lib/dumbdbm.py (Arbeitskopie) @@ -23,7 +23,6 @@ import io as _io import os as _os -import __builtin__ import UserDict _BLOCKSIZE = 512 Index: Lib/sunau.py =================================================================== --- Lib/sunau.py (Revision 59256) +++ Lib/sunau.py (Arbeitskopie) @@ -153,8 +153,8 @@ def __init__(self, f): if type(f) == type(''): - import __builtin__ - f = __builtin__.open(f, 'rb') + import builtins + f = builtins.open(f, 'rb') self.initfp(f) def __del__(self): @@ -282,8 +282,8 @@ def __init__(self, f): if type(f) == type(''): - import __builtin__ - f = __builtin__.open(f, 'wb') + import builtins + f = builtins.open(f, 'wb') self.initfp(f) def __del__(self): Index: Lib/gzip.py =================================================================== --- Lib/gzip.py (Revision 59256) +++ Lib/gzip.py (Arbeitskopie) @@ -7,7 +7,7 @@ import struct, sys, time import zlib -import __builtin__ +import builtins __all__ = ["GzipFile","open"] @@ -92,7 +92,7 @@ if mode and 'b' not in mode: mode += 'b' if fileobj is None: - fileobj = self.myfileobj = __builtin__.open(filename, mode or 'rb') + fileobj = self.myfileobj = builtins.open(filename, mode or 'rb') if filename is None: if hasattr(fileobj, 'name'): filename = fileobj.name else: filename = '' @@ -487,13 +487,13 @@ print("filename doesn't end in .gz:", repr(arg)) continue f = open(arg, "rb") - g = __builtin__.open(arg[:-3], "wb") + g = builtins.open(arg[:-3], "wb") else: if arg == "-": f = sys.stdin g = GzipFile(filename="", mode="wb", fileobj=sys.stdout) else: - f = __builtin__.open(arg, "rb") + f = builtins.open(arg, "rb") g = open(arg + ".gz", "wb") while True: chunk = f.read(1024) Index: Lib/pickletools.py =================================================================== --- Lib/pickletools.py (Revision 59256) +++ Lib/pickletools.py (Arbeitskopie) @@ -2054,7 +2054,7 @@ 33: ( MARK 34: c GLOBAL 'pickletools _Example' 56: p PUT 2 - 59: c GLOBAL '__builtin__ object' + 59: c GLOBAL 'builtins object' 79: p PUT 3 82: N NONE 83: t TUPLE (MARK at 33) @@ -2084,7 +2084,7 @@ 31: ( MARK 32: c GLOBAL 'pickletools _Example' 54: q BINPUT 2 - 56: c GLOBAL '__builtin__ object' + 56: c GLOBAL 'builtins object' 76: q BINPUT 3 78: N NONE 79: t TUPLE (MARK at 31) Index: Lib/ihooks.py =================================================================== --- Lib/ihooks.py (Revision 59256) +++ Lib/ihooks.py (Arbeitskopie) @@ -49,7 +49,7 @@ """ -import __builtin__ +import builtins import imp import os import sys @@ -375,18 +375,18 @@ # XXX Should this try to clear the module's namespace? def install(self): - self.save_import_module = __builtin__.__import__ - if not hasattr(__builtin__, 'unload'): - __builtin__.unload = None - self.save_unload = __builtin__.unload - __builtin__.__import__ = self.import_module - __builtin__.unload = self.unload + self.save_import_module = builtins.__import__ + if not hasattr(builtins, 'unload'): + builtins.unload = None + self.save_unload = builtins.unload + builtins.__import__ = self.import_module + builtins.unload = self.unload def uninstall(self): - __builtin__.__import__ = self.save_import_module - __builtin__.unload = self.save_unload - if not __builtin__.unload: - del __builtin__.unload + builtins.__import__ = self.save_import_module + builtins.unload = self.save_unload + if not builtins.unload: + del builtins.unload class ModuleImporter(BasicModuleImporter): Index: Lib/inspect.py =================================================================== --- Lib/inspect.py (Revision 59256) +++ Lib/inspect.py (Arbeitskopie) @@ -444,7 +444,7 @@ if mainobject is object: return main # Check builtins - builtin = sys.modules['__builtin__'] + builtin = sys.modules['builtins'] if hasattr(builtin, object.__name__): builtinobject = getattr(builtin, object.__name__) if builtinobject is object: @@ -775,7 +775,7 @@ def formatannotation(annotation, base_module=None): if isinstance(annotation, type): - if annotation.__module__ in ('__builtin__', base_module): + if annotation.__module__ in ('builtins', base_module): return annotation.__name__ return annotation.__module__+'.'+annotation.__name__ return repr(annotation) Index: Lib/traceback.py =================================================================== --- Lib/traceback.py (Revision 59256) +++ Lib/traceback.py (Arbeitskopie) @@ -168,7 +168,7 @@ stype = etype.__name__ smod = etype.__module__ - if smod not in ("__main__", "__builtin__"): + if smod not in ("__main__", "builtins"): stype = smod + '.' + stype if not issubclass(etype, SyntaxError): Index: Lib/io.py =================================================================== --- Lib/io.py (Revision 59256) +++ Lib/io.py (Arbeitskopie) @@ -184,7 +184,7 @@ class OpenWrapper: - """Wrapper for __builtin__.open + """Wrapper for builtins.open Trick so that open won't become a bound method when stored as a class variable (as dumbdbm does). Index: Lib/pydoc.py =================================================================== --- Lib/pydoc.py (Revision 59256) +++ Lib/pydoc.py (Arbeitskopie) @@ -52,7 +52,7 @@ # the current directory is changed with os.chdir(), an incorrect # path will be displayed. -import sys, imp, os, re, inspect, __builtin__, pkgutil +import sys, imp, os, re, inspect, builtins, pkgutil from repr import Repr try: from collections import deque @@ -787,7 +787,7 @@ thisclass = attrs[0][2] attrs, inherited = _split_list(attrs, lambda t: t[2] is thisclass) - if thisclass is __builtin__.object: + if thisclass is builtins.object: attrs = inherited continue elif thisclass is object: @@ -1184,7 +1184,7 @@ thisclass = attrs[0][2] attrs, inherited = _split_list(attrs, lambda t: t[2] is thisclass) - if thisclass is __builtin__.object: + if thisclass is builtins.object: attrs = inherited continue elif thisclass is object: @@ -1450,8 +1450,8 @@ except AttributeError: return None return object else: - if hasattr(__builtin__, path): - return getattr(__builtin__, path) + if hasattr(builtins, path): + return getattr(builtins, path) # --------------------------------------- interactive interpreter interface Index: Lib/gettext.py =================================================================== --- Lib/gettext.py (Revision 59256) +++ Lib/gettext.py (Arbeitskopie) @@ -236,18 +236,18 @@ self._output_charset = charset def install(self, str=False, names=None): - import __builtin__ - __builtin__.__dict__['_'] = str and self.ugettext or self.gettext + import builtins + builtins.__dict__['_'] = str and self.ugettext or self.gettext if hasattr(names, "__contains__"): if "gettext" in names: - __builtin__.__dict__['gettext'] = __builtin__.__dict__['_'] + builtins.__dict__['gettext'] = builtins.__dict__['_'] if "ngettext" in names: - __builtin__.__dict__['ngettext'] = (str and self.ungettext + builtins.__dict__['ngettext'] = (str and self.ungettext or self.ngettext) if "lgettext" in names: - __builtin__.__dict__['lgettext'] = self.lgettext + builtins.__dict__['lgettext'] = self.lgettext if "lngettext" in names: - __builtin__.__dict__['lngettext'] = self.lngettext + builtins.__dict__['lngettext'] = self.lngettext class GNUTranslations(NullTranslations): Index: Lib/aifc.py =================================================================== --- Lib/aifc.py (Revision 59256) +++ Lib/aifc.py (Arbeitskopie) @@ -135,7 +135,7 @@ """ import struct -import __builtin__ +import builtins __all__ = ["Error","open","openfp"] @@ -336,7 +336,7 @@ def __init__(self, f): if type(f) == type(''): - f = __builtin__.open(f, 'rb') + f = builtins.open(f, 'rb') # else, assume it is an open file object already self.initfp(f) @@ -557,7 +557,7 @@ def __init__(self, f): if type(f) == type(''): filename = f - f = __builtin__.open(f, 'wb') + f = builtins.open(f, 'wb') else: # else, assume it is an open file object already filename = '???' Index: Lib/repr.py =================================================================== --- Lib/repr.py (Revision 59256) +++ Lib/repr.py (Arbeitskopie) @@ -2,7 +2,7 @@ __all__ = ["Repr","repr"] -import __builtin__ +import builtins from itertools import islice class Repr: @@ -84,16 +84,16 @@ return '{%s}' % (s,) def repr_str(self, x, level): - s = __builtin__.repr(x[:self.maxstring]) + s = builtins.repr(x[:self.maxstring]) if len(s) > self.maxstring: i = max(0, (self.maxstring-3)//2) j = max(0, self.maxstring-3-i) - s = __builtin__.repr(x[:i] + x[len(x)-j:]) + s = builtins.repr(x[:i] + x[len(x)-j:]) s = s[:i] + '...' + s[len(s)-j:] return s def repr_int(self, x, level): - s = __builtin__.repr(x) # XXX Hope this isn't too slow... + s = builtins.repr(x) # XXX Hope this isn't too slow... if len(s) > self.maxlong: i = max(0, (self.maxlong-3)//2) j = max(0, self.maxlong-3-i) @@ -102,7 +102,7 @@ def repr_instance(self, x, level): try: - s = __builtin__.repr(x) + s = builtins.repr(x) # Bugs in x.__repr__() can cause arbitrary # exceptions -- then make up something except Exception: Index: Lib/tarfile.py =================================================================== --- Lib/tarfile.py (Revision 59256) +++ Lib/tarfile.py (Arbeitskopie) @@ -65,7 +65,7 @@ # from tarfile import * __all__ = ["TarFile", "TarInfo", "is_tarfile", "TarError"] -from __builtin__ import open as _open # Since 'open' is TarFile.open +from builtins import open as _open # Since 'open' is TarFile.open #--------------------------------------------------------- # tar constants Index: Lib/test/test_pep352.py =================================================================== --- Lib/test/test_pep352.py (Revision 59256) +++ Lib/test/test_pep352.py (Arbeitskopie) @@ -1,5 +1,5 @@ import unittest -import __builtin__ +import builtins import warnings from test.test_support import run_unittest import os @@ -23,7 +23,7 @@ def test_inheritance(self): # Make sure the inheritance hierarchy matches the documentation exc_set = set() - for object_ in __builtin__.__dict__.values(): + for object_ in builtins.__dict__.values(): try: if issubclass(object_, BaseException): exc_set.add(object_.__name__) @@ -35,7 +35,7 @@ try: superclass_name = inheritance_tree.readline().rstrip() try: - last_exc = getattr(__builtin__, superclass_name) + last_exc = getattr(builtins, superclass_name) except AttributeError: self.fail("base class %s not a built-in" % superclass_name) self.failUnless(superclass_name in exc_set, @@ -58,7 +58,7 @@ left_bracket = exc_name.index('[') exc_name = exc_name[:left_bracket-1] # cover space try: - exc = getattr(__builtin__, exc_name) + exc = getattr(builtins, exc_name) except AttributeError: self.fail("%s not a built-in exception" % exc_name) if last_depth < depth: Index: Lib/test/test_exceptions.py =================================================================== --- Lib/test/test_exceptions.py (Revision 59256) +++ Lib/test/test_exceptions.py (Arbeitskopie) @@ -288,7 +288,7 @@ raise else: # Verify module name - self.assertEquals(type(e).__module__, '__builtin__') + self.assertEquals(type(e).__module__, 'builtins') # Verify no ref leaks in Exc_str() s = str(e) for checkArgName in expected: Index: Lib/test/test_traceback.py =================================================================== --- Lib/test/test_traceback.py (Revision 59256) +++ Lib/test/test_traceback.py (Arbeitskopie) @@ -65,7 +65,7 @@ err = traceback.format_exception_only(X, X()) self.assertEqual(len(err), 1) str_value = '' % X.__name__ - if X.__module__ in ('__main__', '__builtin__'): + if X.__module__ in ('__main__', 'builtins'): str_name = X.__name__ else: str_name = '.'.join([X.__module__, X.__name__]) Index: Lib/test/test_site.py =================================================================== --- Lib/test/test_site.py (Revision 59256) +++ Lib/test/test_site.py (Arbeitskopie) @@ -6,7 +6,7 @@ """ import unittest from test.test_support import TestSkipped, TestFailed, run_unittest, TESTFN -import __builtin__ +import builtins import os import sys import encodings @@ -162,7 +162,7 @@ # as an absolute path. # Handled by abs__file__() site.abs__file__() - for module in (sys, os, __builtin__): + for module in (sys, os, builtins): try: self.failUnless(os.path.isabs(module.__file__), repr(module)) except AttributeError: @@ -187,18 +187,18 @@ pass def test_setting_quit(self): - # 'quit' and 'exit' should be injected into __builtin__ - self.failUnless(hasattr(__builtin__, "quit")) - self.failUnless(hasattr(__builtin__, "exit")) + # 'quit' and 'exit' should be injected into builtins + self.failUnless(hasattr(builtins, "quit")) + self.failUnless(hasattr(builtins, "exit")) def test_setting_copyright(self): - # 'copyright' and 'credits' should be in __builtin__ - self.failUnless(hasattr(__builtin__, "copyright")) - self.failUnless(hasattr(__builtin__, "credits")) + # 'copyright' and 'credits' should be in builtins + self.failUnless(hasattr(builtins, "copyright")) + self.failUnless(hasattr(builtins, "credits")) def test_setting_help(self): - # 'help' should be set in __builtin__ - self.failUnless(hasattr(__builtin__, "help")) + # 'help' should be set in builtins + self.failUnless(hasattr(builtins, "help")) def test_aliasing_mbcs(self): if sys.platform == "win32": Index: Lib/test/test_inspect.py =================================================================== --- Lib/test/test_inspect.py (Revision 59256) +++ Lib/test/test_inspect.py (Arbeitskopie) @@ -29,7 +29,7 @@ def revise(filename, *args): return (normcase(filename),) + args -import __builtin__ +import builtins try: 1/0 @@ -197,7 +197,7 @@ # Do it again (check the caching isn't broken) self.assertEqual(inspect.getmodule(mod.StupidGit.abuse), mod) # Check a builtin - self.assertEqual(inspect.getmodule(str), sys.modules["__builtin__"]) + self.assertEqual(inspect.getmodule(str), sys.modules["builtins"]) # Check filename override self.assertEqual(inspect.getmodule(None, modfile), mod) Index: Lib/test/test_compile.py =================================================================== --- Lib/test/test_compile.py (Revision 59256) +++ Lib/test/test_compile.py (Arbeitskopie) @@ -7,10 +7,10 @@ def test_debug_assignment(self): # catch assignments to __debug__ self.assertRaises(SyntaxError, compile, '__debug__ = 1', '?', 'single') - import __builtin__ - prev = __builtin__.__debug__ - setattr(__builtin__, '__debug__', 'sure') - setattr(__builtin__, '__debug__', prev) + import builtins + prev = builtins.__debug__ + setattr(builtins, '__debug__', 'sure') + setattr(builtins, '__debug__', prev) def test_argument_handling(self): # detect duplicate positional and keyword arguments Index: Lib/test/test_iterlen.py =================================================================== --- Lib/test/test_iterlen.py (Revision 59256) +++ Lib/test/test_iterlen.py (Arbeitskopie) @@ -46,7 +46,7 @@ from itertools import repeat from collections import deque from UserList import UserList -from __builtin__ import len as _len +from builtins import len as _len n = 10 Index: Lib/test/pickletester.py =================================================================== --- Lib/test/pickletester.py (Revision 59256) +++ Lib/test/pickletester.py (Arbeitskopie) @@ -91,7 +91,7 @@ DATA0 = ( b'(lp0\nL0\naL1\naF2.0\nac' - b'__builtin__\ncomplex\n' + b'builtins\ncomplex\n' b'p1\n(F3.0\nF0.0\ntp2\nRp' b'3\naL1\naL-1\naL255\naL-' b'255\naL-256\naL65535\na' @@ -118,7 +118,7 @@ 12: a APPEND 13: F FLOAT 2.0 18: a APPEND - 19: c GLOBAL '__builtin__ complex' + 19: c GLOBAL 'builtins complex' 40: p PUT 1 43: ( MARK 44: F FLOAT 3.0 @@ -159,7 +159,7 @@ 199: ( MARK 200: c GLOBAL '__main__ C' 212: p PUT 6 - 215: c GLOBAL '__builtin__ object' + 215: c GLOBAL 'builtins object' 235: p PUT 7 238: N NONE 239: t TUPLE (MARK at 199) @@ -199,7 +199,7 @@ b'\xff\x7fJ\x01\x00\x00\x80J\x00\x00\x00\x80(X\x03\x00\x00\x00ab' b'cq\x04h\x04ccopy_reg\n_reco' b'nstructor\nq\x05(c__main' - b'__\nC\nq\x06c__builtin__\n' + b'__\nC\nq\x06cbuiltins\n' b'object\nq\x07Ntq\x08Rq\t}q\n(' b'X\x03\x00\x00\x00fooq\x0bK\x01X\x03\x00\x00\x00bar' b'q\x0cK\x02ubh\ttq\rh\rK\x05e.' @@ -213,7 +213,7 @@ 4: K BININT1 0 6: K BININT1 1 8: G BINFLOAT 2.0 - 17: c GLOBAL '__builtin__ complex' + 17: c GLOBAL 'builtins complex' 38: q BINPUT 1 40: ( MARK 41: G BINFLOAT 3.0 @@ -242,7 +242,7 @@ 152: ( MARK 153: c GLOBAL '__main__ C' 165: q BINPUT 6 - 167: c GLOBAL '__builtin__ object' + 167: c GLOBAL 'builtins object' 187: q BINPUT 7 189: N NONE 190: t TUPLE (MARK at 152) @@ -272,7 +272,7 @@ DATA2 = ( b'\x80\x02]q\x00(K\x00K\x01G@\x00\x00\x00\x00\x00\x00\x00c' - b'__builtin__\ncomplex\n' + b'builtins\ncomplex\n' b'q\x01G@\x08\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x00\x00\x00\x00\x00' b'\x86q\x02Rq\x03K\x01J\xff\xff\xff\xffK\xffJ\x01\xff\xff\xff' b'J\x00\xff\xff\xffM\xff\xffJ\x01\x00\xff\xffJ\x00\x00\xff\xffJ\xff' @@ -292,7 +292,7 @@ 6: K BININT1 0 8: K BININT1 1 10: G BINFLOAT 2.0 - 19: c GLOBAL '__builtin__ complex' + 19: c GLOBAL 'builtins complex' 40: q BINPUT 1 42: G BINFLOAT 3.0 51: G BINFLOAT 0.0 Index: Lib/test/test_gettext.py =================================================================== --- Lib/test/test_gettext.py (Revision 59256) +++ Lib/test/test_gettext.py (Arbeitskopie) @@ -146,13 +146,13 @@ t.install(str=True) eq(_('mullusk'), 'bacon') # Test installation of other methods - import __builtin__ + import builtins t.install(str=True, names=["gettext", "lgettext"]) eq(_, t.ugettext) - eq(__builtin__.gettext, t.ugettext) + eq(builtins.gettext, t.ugettext) eq(lgettext, t.lgettext) - del __builtin__.gettext - del __builtin__.lgettext + del builtins.gettext + del builtins.lgettext class GettextTestCase2(GettextBaseTest): Index: Lib/test/test_sys.py =================================================================== --- Lib/test/test_sys.py (Revision 59256) +++ Lib/test/test_sys.py (Arbeitskopie) @@ -15,22 +15,22 @@ sys.displayhook = self.orig_displayhook def test_original_displayhook(self): - import __builtin__ + import builtins out = io.StringIO() sys.stdout = out dh = sys.__displayhook__ self.assertRaises(TypeError, dh) - if hasattr(__builtin__, "_"): - del __builtin__._ + if hasattr(builtins, "_"): + del builtins._ dh(None) self.assertEqual(out.getvalue(), "") - self.assert_(not hasattr(__builtin__, "_")) + self.assert_(not hasattr(builtins, "_")) dh(42) self.assertEqual(out.getvalue(), "42\n") - self.assertEqual(__builtin__._, 42) + self.assertEqual(builtins._, 42) del sys.stdout self.assertRaises(RuntimeError, dh, 42) Index: Lib/locale.py =================================================================== --- Lib/locale.py (Revision 59256) +++ Lib/locale.py (Arbeitskopie) @@ -12,7 +12,7 @@ """ import sys, encodings, encodings.aliases -from __builtin__ import str as _builtin_str +from builtins import str as _builtin_str # Try importing the _locale module. # Index: Lib/codecs.py =================================================================== --- Lib/codecs.py (Revision 59256) +++ Lib/codecs.py (Arbeitskopie) @@ -7,7 +7,7 @@ """#" -import __builtin__, sys +import builtins, sys ### Registry and builtin stateless codec functions @@ -858,7 +858,7 @@ 'b' not in mode: # Force opening of the file in binary mode mode = mode + 'b' - file = __builtin__.open(filename, mode, buffering) + file = builtins.open(filename, mode, buffering) if encoding is None: return file info = lookup(encoding) Index: Lib/plat-mac/icopen.py =================================================================== --- Lib/plat-mac/icopen.py (Revision 59256) +++ Lib/plat-mac/icopen.py (Arbeitskopie) @@ -37,9 +37,9 @@ effect. """ -import __builtin__ +import builtins -_builtin_open = globals().get('_builtin_open', __builtin__.open) +_builtin_open = globals().get('_builtin_open', builtins.open) def _open_with_typer(*args): file = _builtin_open(*args) @@ -55,7 +55,7 @@ pass return file -__builtin__.open = _open_with_typer +builtins.open = _open_with_typer """ open('test.py') Index: Lib/imputil.py =================================================================== --- Lib/imputil.py (Revision 59256) +++ Lib/imputil.py (Arbeitskopie) @@ -13,7 +13,7 @@ # note: avoid importing non-builtin modules import imp ### not available in JPython? import sys -import __builtin__ +import builtins # for the DirectoryImporter import struct @@ -26,7 +26,7 @@ class ImportManager: "Manage the import process." - def install(self, namespace=vars(__builtin__)): + def install(self, namespace=vars(builtins)): "Install this ImportManager into the specified namespace." if isinstance(namespace, _ModuleType): @@ -404,7 +404,7 @@ codestring = open(pathname, 'rU').read() if codestring and codestring[-1] != '\n': codestring = codestring + '\n' - code = __builtin__.compile(codestring, pathname, 'exec') + code = builtins.compile(codestring, pathname, 'exec') # try to cache the compiled code try: Index: Modules/_lsprof.c =================================================================== --- Modules/_lsprof.c (Revision 59256) +++ Modules/_lsprof.c (Arbeitskopie) @@ -186,13 +186,13 @@ modname = PyModule_GetName(mod); if (modname == NULL) { PyErr_Clear(); - modname = "__builtin__"; + modname = "builtins"; } } else { - modname = "__builtin__"; + modname = "builtins"; } - if (strcmp(modname, "__builtin__") != 0) + if (strcmp(modname, "builtins") != 0) return PyUnicode_FromFormat("<%s.%s>", modname, fn->m_ml->ml_name); Index: Modules/_bsddb.c =================================================================== --- Modules/_bsddb.c (Revision 59256) +++ Modules/_bsddb.c (Arbeitskopie) @@ -6002,7 +6002,7 @@ * using one base class. */ PyDict_SetItemString(d, "KeyError", PyExc_KeyError); { - PyObject *builtin_mod = PyImport_ImportModule("__builtin__"); + PyObject *builtin_mod = PyImport_ImportModule("builtins"); PyDict_SetItemString(d, "__builtins__", builtin_mod); } PyRun_String("class DBNotFoundError(DBError, KeyError): pass\n" Index: Modules/config.c.in =================================================================== --- Modules/config.c.in (Revision 59256) +++ Modules/config.c.in (Arbeitskopie) @@ -48,7 +48,7 @@ /* These entries are here for sys.builtin_module_names */ {"__main__", NULL}, - {"__builtin__", NULL}, + {"builtins", NULL}, {"sys", NULL}, /* This lives in gcmodule.c */