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:
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)')
"""
-import sys, imp, __builtin__
+import sys, imp, builtins
# Replacement for __import__()
# Save the original hooks
-original_import = __builtin__.__import__
+original_import = builtins.__import__
# Now install our hooks
-__builtin__.__import__ = import_hook
+builtins.__import__ = import_hook
import sys
import socket
import pickle
-import __builtin__
+import builtins
import os
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:
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
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
.. cfunction:: PyThreadState* Py_NewInterpreter()
.. index::
- module: __builtin__
+ module: builtins
module: __main__
module: sys
single: stdout (in module sys)
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::
single: Py_Initialize()
- module: __builtin__
+ module: builtins
module: __main__
module: sys
module: exceptions
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()
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
-: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
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:
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
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`.
::
- import sys, imp, __builtin__
+ import sys, imp, builtins
# Replacement for __import__()
def import_hook(name, globals=None, locals=None, fromlist=None):
# 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
.. toctree::
sys.rst
- __builtin__.rst
+ builtins.rst
__main__.rst
warnings.rst
contextlib.rst
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
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
.. 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
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.
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.
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__
``_*``
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::
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.
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
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
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.
*/
"""
import struct
-import __builtin__
+import builtins
__all__ = ["Error","open","openfp"]
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)
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 = '???'
"""#"
-import __builtin__, sys
+import builtins, sys
### Registry and builtin stateless codec functions
'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)
import io as _io
import os as _os
-import __builtin__
import UserDict
_BLOCKSIZE = 512
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):
import struct, sys, time
import zlib
-import __builtin__
+import builtins
__all__ = ["GzipFile","open"]
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 = ''
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)
import time
import re
import keyword
-import __builtin__
+import builtins
from Tkinter import *
from idlelib.Delegator import Delegator
from idlelib.configHandler import idleConf
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
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----------
"""
-import __builtin__
+import builtins
import imp
import os
import sys
# 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):
# note: avoid importing non-builtin modules
import imp ### not available in JPython?
import sys
-import __builtin__
+import builtins
# for the DirectoryImporter
import struct
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):
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:
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:
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)
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).
"""
import sys, encodings, encodings.aliases
-from __builtin__ import str as _builtin_str
+from builtins import str as _builtin_str
# Try importing the _locale module.
#
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":
33: ( MARK
34: c GLOBAL 'pickletools _Example'
56: p PUT 2
- 59: c GLOBAL '__builtin__ object'
- 79: p PUT 3
- 82: N NONE
- 83: t TUPLE (MARK at 33)
- 84: p PUT 4
- 87: R REDUCE
- 88: p PUT 5
- 91: ( MARK
- 92: d DICT (MARK at 91)
- 93: p PUT 6
- 96: V UNICODE 'value'
- 103: p PUT 7
- 106: L LONG 42
- 110: s SETITEM
- 111: b BUILD
- 112: a APPEND
- 113: g GET 5
- 116: a APPEND
- 117: . STOP
+ 59: c GLOBAL 'builtins object'
+ 76: p PUT 3
+ 79: N NONE
+ 80: t TUPLE (MARK at 33)
+ 81: p PUT 4
+ 84: R REDUCE
+ 85: p PUT 5
+ 88: ( MARK
+ 89: d DICT (MARK at 88)
+ 90: p PUT 6
+ 93: V UNICODE 'value'
+ 100: p PUT 7
+ 103: L LONG 42
+ 107: s SETITEM
+ 108: b BUILD
+ 109: a APPEND
+ 110: g GET 5
+ 113: a APPEND
+ 114: . STOP
highest protocol among opcodes = 0
>>> dis(pickle.dumps(x, 1))
31: ( MARK
32: c GLOBAL 'pickletools _Example'
54: q BINPUT 2
- 56: c GLOBAL '__builtin__ object'
- 76: q BINPUT 3
- 78: N NONE
- 79: t TUPLE (MARK at 31)
- 80: q BINPUT 4
- 82: R REDUCE
- 83: q BINPUT 5
- 85: } EMPTY_DICT
- 86: q BINPUT 6
- 88: X BINUNICODE 'value'
- 98: q BINPUT 7
- 100: K BININT1 42
- 102: s SETITEM
- 103: b BUILD
- 104: h BINGET 5
- 106: e APPENDS (MARK at 3)
- 107: . STOP
+ 56: c GLOBAL 'builtins object'
+ 73: q BINPUT 3
+ 75: N NONE
+ 76: t TUPLE (MARK at 31)
+ 77: q BINPUT 4
+ 79: R REDUCE
+ 80: q BINPUT 5
+ 82: } EMPTY_DICT
+ 83: q BINPUT 6
+ 85: X BINUNICODE 'value'
+ 95: q BINPUT 7
+ 97: K BININT1 42
+ 99: s SETITEM
+ 100: b BUILD
+ 101: h BINGET 5
+ 103: e APPENDS (MARK at 3)
+ 104: . STOP
highest protocol among opcodes = 1
Try "the canonical" recursive-object test.
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)
pass
return file
-__builtin__.open = _open_with_typer
+builtins.open = _open_with_typer
"""
open('test.py')
This module has intimate knowledge of the format of .pyc files.
"""
-import __builtin__
+import builtins
import imp
import marshal
import os
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:
# 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
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:
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:
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
__all__ = ["Repr","repr"]
-import __builtin__
+import builtins
from itertools import islice
class Repr:
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)
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:
"""
-import __builtin__
+import builtins
import __main__
__all__ = ["Completer"]
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__":
import sys
import os
-import __builtin__
+import builtins
def makepath(*paths):
except:
pass
raise SystemExit(code)
- __builtin__.quit = Quitter('quit')
- __builtin__.exit = Quitter('exit')
+ builtins.quit = Quitter('quit')
+ builtins.exit = Quitter('exit')
class _Printer(object):
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])
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,
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):
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):
# 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
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'
b'647\naL-2147483648\na('
b'Vabc\np4\ng4\nccopy_reg'
b'\n_reconstructor\np5\n('
- b'c__main__\nC\np6\nc__bu'
- b'iltin__\nobject\np7\nNt'
+ b'c__main__\nC\np6\ncbu'
+ b'iltins\nobject\np7\nNt'
b'p8\nRp9\n(dp10\nVfoo\np1'
b'1\nL1\nsVbar\np12\nL2\nsb'
b'g9\ntp13\nag13\naL5\na.'
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
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)
"""
DATA1 = (
- b']q\x00(K\x00K\x01G@\x00\x00\x00\x00\x00\x00\x00c__'
- b'builtin__\ncomplex\nq\x01'
+ b']q\x00(K\x00K\x01G@\x00\x00\x00\x00\x00\x00\x00c'
+ b'builtins\ncomplex\nq\x01'
b'(G@\x08\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x00\x00\x00\x00\x00t'
b'q\x02Rq\x03K\x01J\xff\xff\xff\xffK\xffJ\x01\xff\xff\xffJ'
b'\x00\xff\xff\xffM\xff\xffJ\x01\x00\xff\xffJ\x00\x00\xff\xffJ\xff\xff'
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.'
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
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)
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'
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
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
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:
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):
def revise(filename, *args):
return (normcase(filename),) + args
-import __builtin__
+import builtins
try:
1/0
# 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)
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
import unittest
-import __builtin__
+import builtins
import warnings
from test.test_support import run_unittest
import os
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__)
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,
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:
"""
import unittest
from test.test_support import TestSkipped, TestFailed, run_unittest, TESTFN
-import __builtin__
+import builtins
import os
import sys
import encodings
# 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:
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":
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)
err = traceback.format_exception_only(X, X())
self.assertEqual(len(err), 1)
str_value = '<unprintable %s object>' % 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__])
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):
is destroyed.
"""
-import __builtin__
+import builtins
__all__ = ["open", "openfp", "Error"]
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:
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)
import keyword
import exceptions
-import __builtin__
+import builtins
from string import Template
comment_header = '''" Auto-generated Vim syntax file for Python.
# 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}"',
* 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"
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);
/* These entries are here for sys.builtin_module_names */
{"__main__", NULL},
- {"__builtin__", NULL},
+ {"builtins", NULL},
{"sys", NULL},
/* This lives in gcmodule.c */
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);
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;
if (s != NULL)
return PyUnicode_FromStringAndSize(
type->tp_name, (Py_ssize_t)(s - type->tp_name));
- return PyUnicode_FromString("__builtin__");
+ return PyUnicode_FromString("builtins");
}
}
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);
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>",
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");
/* These entries are here for sys.builtin_module_names */
{"__main__", NULL},
- {"__builtin__", NULL},
+ {"builtins", NULL},
{"sys", NULL},
{"_types", init_types},
/* These entries are here for sys.builtin_module_names */
{"__main__", NULL},
- {"__builtin__", NULL},
+ {"builtins", NULL},
{"sys", NULL},
/* This lives in gcmodule.c */
/* These entries are here for sys.builtin_module_names */
{"__main__", NULL},
- {"__builtin__", NULL},
+ {"builtins", NULL},
{"sys", NULL},
/* Sentinel */
_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)
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)
else {
char* modstr = PyUnicode_AsString(moduleName);
if (modstr &&
- strcmp(modstr, "__builtin__") != 0)
+ strcmp(modstr, "builtins") != 0)
{
PyFile_WriteString(modstr, f);
PyFile_WriteString(".", f);
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");
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).
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;
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;
}
} 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;
}
}
- /* 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)
_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 */
/* 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;
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");
_PyImport_Init();
/* phase 2 of builtins */
- _PyImport_FixupExtension("__builtin__", "__builtin__");
+ _PyImport_FixupExtension("builtins", "builtins");
_PyImportHooks_Init();
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)
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__");
}
}
-/* Initialize sys.stdin, stdout, stderr and __builtin__.open */
+/* Initialize sys.stdin, stdout, stderr and builtins.open */
static int
initstdio(void)
{
}
Py_DECREF(m);
- if (!(bimod = PyImport_ImportModule("__builtin__"))) {
+ if (!(bimod = PyImport_ImportModule("builtins"))) {
goto error;
}
goto error;
}
- /* Set __builtin__.open */
+ /* Set builtins.open */
if (PyObject_SetAttrString(bimod, "open", wrapper) == -1) {
goto error;
}
}
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);
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;
}
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 *
\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\
# 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 --')
projects / python / commitdiff