Rename thread to _thread and dummy_thread to _dummy_thread. Issue #2875.
diff --git a/Lib/dummy_thread.py b/Lib/_dummy_thread.py
similarity index 85%
rename from Lib/dummy_thread.py
rename to Lib/_dummy_thread.py
index c131384..352215a 100644
--- a/Lib/dummy_thread.py
+++ b/Lib/_dummy_thread.py
@@ -6,9 +6,9 @@
Suggested usage is::
try:
- import thread
+ import _thread
except ImportError:
- import dummy_thread as thread
+ import _dummy_thread as _thread
"""
# Exports only things specified by thread documentation;
@@ -20,17 +20,17 @@
import warnings
class error(Exception):
- """Dummy implementation of thread.error."""
+ """Dummy implementation of _thread.error."""
def __init__(self, *args):
self.args = args
def start_new_thread(function, args, kwargs={}):
- """Dummy implementation of thread.start_new_thread().
+ """Dummy implementation of _thread.start_new_thread().
Compatibility is maintained by making sure that ``args`` is a
tuple and ``kwargs`` is a dictionary. If an exception is raised
- and it is SystemExit (which can be done by thread.exit()) it is
+ and it is SystemExit (which can be done by _thread.exit()) it is
caught and nothing is done; all other exceptions are printed out
by using traceback.print_exc().
@@ -57,34 +57,34 @@
raise KeyboardInterrupt
def exit():
- """Dummy implementation of thread.exit()."""
+ """Dummy implementation of _thread.exit()."""
raise SystemExit
def get_ident():
- """Dummy implementation of thread.get_ident().
+ """Dummy implementation of _thread.get_ident().
- Since this module should only be used when threadmodule is not
+ Since this module should only be used when _threadmodule is not
available, it is safe to assume that the current process is the
only thread. Thus a constant can be safely returned.
"""
return -1
def allocate_lock():
- """Dummy implementation of thread.allocate_lock()."""
+ """Dummy implementation of _thread.allocate_lock()."""
return LockType()
def stack_size(size=None):
- """Dummy implementation of thread.stack_size()."""
+ """Dummy implementation of _thread.stack_size()."""
if size is not None:
raise error("setting thread stack size not supported")
return 0
class LockType(object):
- """Class implementing dummy implementation of thread.LockType.
+ """Class implementing dummy implementation of _thread.LockType.
Compatibility is maintained by maintaining self.locked_status
which is a boolean that stores the state of the lock. Pickling of
- the lock, though, should not be done since if the thread module is
+ the lock, though, should not be done since if the _thread module is
then used with an unpickled ``lock()`` from here problems could
occur from this class not having atomic methods.
diff --git a/Lib/_strptime.py b/Lib/_strptime.py
index b323e8f..c3568b0 100644
--- a/Lib/_strptime.py
+++ b/Lib/_strptime.py
@@ -18,9 +18,9 @@
from re import escape as re_escape
from datetime import date as datetime_date
try:
- from thread import allocate_lock as _thread_allocate_lock
+ from _thread import allocate_lock as _thread_allocate_lock
except:
- from dummy_thread import allocate_lock as _thread_allocate_lock
+ from _dummy_thread import allocate_lock as _thread_allocate_lock
__all__ = []
diff --git a/Lib/bsddb/__init__.py b/Lib/bsddb/__init__.py
index b2786d3..0e68219 100644
--- a/Lib/bsddb/__init__.py
+++ b/Lib/bsddb/__init__.py
@@ -526,8 +526,8 @@
# BerkeleyDB was too.
try:
- import thread
- del thread
+ import _thread
+ del _thread
if db.version() < (3, 3, 0):
db.DB_THREAD = 0
except ImportError:
diff --git a/Lib/dummy_threading.py b/Lib/dummy_threading.py
index 81028a3..1bb7eee 100644
--- a/Lib/dummy_threading.py
+++ b/Lib/dummy_threading.py
@@ -3,12 +3,12 @@
The module ``_dummy_threading`` is added to ``sys.modules`` in order
to not have ``threading`` considered imported. Had ``threading`` been
directly imported it would have made all subsequent imports succeed
-regardless of whether ``thread`` was available which is not desired.
+regardless of whether ``_thread`` was available which is not desired.
"""
from sys import modules as sys_modules
-import dummy_thread
+import _dummy_thread
# Declaring now so as to not have to nest ``try``s to get proper clean-up.
holding_thread = False
@@ -16,15 +16,15 @@
holding__threading_local = False
try:
- # Could have checked if ``thread`` was not in sys.modules and gone
+ # Could have checked if ``_thread`` was not in sys.modules and gone
# a different route, but decided to mirror technique used with
# ``threading`` below.
- if 'thread' in sys_modules:
- held_thread = sys_modules['thread']
+ if '_thread' in sys_modules:
+ held_thread = sys_modules['_thread']
holding_thread = True
- # Must have some module named ``thread`` that implements its API
+ # Must have some module named ``_thread`` that implements its API
# in order to initially import ``threading``.
- sys_modules['thread'] = sys_modules['dummy_thread']
+ sys_modules['_thread'] = sys_modules['_dummy_thread']
if 'threading' in sys_modules:
# If ``threading`` is already imported, might as well prevent
@@ -68,11 +68,11 @@
# Put back ``thread`` if we overwrote, else del the entry we made
if holding_thread:
- sys_modules['thread'] = held_thread
+ sys_modules['_thread'] = held_thread
del held_thread
else:
- del sys_modules['thread']
+ del sys_modules['_thread']
del holding_thread
- del dummy_thread
+ del _dummy_thread
del sys_modules
diff --git a/Lib/idlelib/run.py b/Lib/idlelib/run.py
index c9f5010..7a662c9 100644
--- a/Lib/idlelib/run.py
+++ b/Lib/idlelib/run.py
@@ -3,7 +3,7 @@
import time
import socket
import traceback
-import thread
+import _thread as thread
import threading
import queue
diff --git a/Lib/logging/__init__.py b/Lib/logging/__init__.py
index 92ab502..99e813b 100644
--- a/Lib/logging/__init__.py
+++ b/Lib/logging/__init__.py
@@ -35,7 +35,7 @@
codecs = None
try:
- import thread
+ import _thread as thread
import threading
except ImportError:
thread = None
diff --git a/Lib/logging/config.py b/Lib/logging/config.py
index 006d669..73f3ecc 100644
--- a/Lib/logging/config.py
+++ b/Lib/logging/config.py
@@ -27,7 +27,7 @@
import sys, logging, logging.handlers, socket, struct, os, traceback
try:
- import thread
+ import _thread as thread
import threading
except ImportError:
thread = None
diff --git a/Lib/mimetools.py b/Lib/mimetools.py
index 0112f48..3ea5e1b 100644
--- a/Lib/mimetools.py
+++ b/Lib/mimetools.py
@@ -96,11 +96,11 @@
# -----------------
try:
- import thread
+ import _thread
except ImportError:
- import dummy_thread as thread
-_counter_lock = thread.allocate_lock()
-del thread
+ import _dummy_thread as _thread
+_counter_lock = _thread.allocate_lock()
+del _thread
_counter = 0
def _get_next_counter():
diff --git a/Lib/pydoc.py b/Lib/pydoc.py
index 57bd5e2..140e1d8 100755
--- a/Lib/pydoc.py
+++ b/Lib/pydoc.py
@@ -347,7 +347,7 @@
if (isinstance(object, type(os)) and
(object.__name__ in ('errno', 'exceptions', 'gc', 'imp',
'marshal', 'posix', 'signal', 'sys',
- 'thread', 'zipimport') or
+ '_thread', 'zipimport') or
(file.startswith(basedir) and
not file.startswith(os.path.join(basedir, 'site-packages'))))):
if docloc.startswith("http://"):
diff --git a/Lib/telnetlib.py b/Lib/telnetlib.py
index db37200..33029e1 100644
--- a/Lib/telnetlib.py
+++ b/Lib/telnetlib.py
@@ -548,8 +548,8 @@
def mt_interact(self):
"""Multithreaded version of interact()."""
- import thread
- thread.start_new_thread(self.listener, ())
+ import _thread
+ _thread.start_new_thread(self.listener, ())
while 1:
line = sys.stdin.readline()
if not line:
diff --git a/Lib/tempfile.py b/Lib/tempfile.py
index 1041c14..2caa56a 100644
--- a/Lib/tempfile.py
+++ b/Lib/tempfile.py
@@ -52,9 +52,9 @@
try:
- import thread as _thread
+ import _thread
except ImportError:
- import dummy_thread as _thread
+ import _dummy_thread as _thread
_allocate_lock = _thread.allocate_lock
_text_openflags = _os.O_RDWR | _os.O_CREAT | _os.O_EXCL
diff --git a/Lib/test/crashers/multithreaded_close.py b/Lib/test/crashers/multithreaded_close.py
index 5224341..f862d28 100644
--- a/Lib/test/crashers/multithreaded_close.py
+++ b/Lib/test/crashers/multithreaded_close.py
@@ -6,9 +6,9 @@
# http://bugs.python.org/issue595601
# http://bugs.python.org/issue815646
-import thread
+import _thread
while 1:
f = open("multithreaded_close.tmp", "w")
- thread.start_new_thread(f.close, ())
+ _thread.start_new_thread(f.close, ())
f.close()
diff --git a/Lib/test/fork_wait.py b/Lib/test/fork_wait.py
index 678e3c4..03a4d6f 100644
--- a/Lib/test/fork_wait.py
+++ b/Lib/test/fork_wait.py
@@ -9,7 +9,7 @@
active threads survive in the child after a fork(); this is an error.
"""
-import os, sys, time, thread, unittest
+import os, sys, time, _thread, unittest
LONGSLEEP = 2
SHORTSLEEP = 0.5
@@ -43,7 +43,7 @@
def test_wait(self):
for i in range(NUM_THREADS):
- thread.start_new(self.f, (i,))
+ _thread.start_new(self.f, (i,))
time.sleep(LONGSLEEP)
diff --git a/Lib/test/test___all__.py b/Lib/test/test___all__.py
index c58aead..615f6c5 100644
--- a/Lib/test/test___all__.py
+++ b/Lib/test/test___all__.py
@@ -63,7 +63,7 @@
self.check_all("dircache")
self.check_all("dis")
self.check_all("doctest")
- self.check_all("dummy_thread")
+ self.check_all("_dummy_thread")
self.check_all("dummy_threading")
self.check_all("filecmp")
self.check_all("fileinput")
diff --git a/Lib/test/test_asynchat.py b/Lib/test/test_asynchat.py
index 4d49f58..082fde9 100644
--- a/Lib/test/test_asynchat.py
+++ b/Lib/test/test_asynchat.py
@@ -1,6 +1,6 @@
# test asynchat -- requires threading
-import thread # If this fails, we can't test this module
+import _thread as thread # If this fails, we can't test this module
import asyncore, asynchat, socket, threading, time
import unittest
import sys
diff --git a/Lib/test/test_capi.py b/Lib/test/test_capi.py
index df5ce0b..6c87645 100644
--- a/Lib/test/test_capi.py
+++ b/Lib/test/test_capi.py
@@ -22,13 +22,13 @@
idents = []
def callback():
- idents.append(thread.get_ident())
+ idents.append(_thread.get_ident())
_testcapi._test_thread_state(callback)
a = b = callback
time.sleep(1)
# Check our main thread is in the list exactly 3 times.
- if idents.count(thread.get_ident()) != 3:
+ if idents.count(_thread.get_ident()) != 3:
raise support.TestFailed(
"Couldn't find main thread correctly in the list")
@@ -39,11 +39,11 @@
have_thread_state = False
if have_thread_state:
- import thread
+ import _thread
import time
TestThreadState()
import threading
- t=threading.Thread(target=TestThreadState)
+ t = threading.Thread(target=TestThreadState)
t.start()
t.join()
diff --git a/Lib/test/test_dummy_thread.py b/Lib/test/test_dummy_thread.py
index 585711f..5b7db18 100644
--- a/Lib/test/test_dummy_thread.py
+++ b/Lib/test/test_dummy_thread.py
@@ -5,15 +5,15 @@
implementation as its sole argument.
"""
-import dummy_thread as _thread
+import _dummy_thread as _thread
import time
import queue
import random
import unittest
from test import support
-DELAY = 0 # Set > 0 when testing a module other than dummy_thread, such as
- # the 'thread' module.
+DELAY = 0 # Set > 0 when testing a module other than _dummy_thread, such as
+ # the '_thread' module.
class LockTests(unittest.TestCase):
"""Test lock objects."""
diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
index 349548f..d12968c 100644
--- a/Lib/test/test_socket.py
+++ b/Lib/test/test_socket.py
@@ -6,7 +6,8 @@
import errno
import socket
import select
-import thread, threading
+import _thread as thread
+import threading
import time
import traceback
import queue
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index 7c66e0d..231b460 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -191,7 +191,7 @@
def test_current_frames(self):
have_threads = True
try:
- import thread
+ import _thread
except ImportError:
have_threads = False
@@ -202,7 +202,7 @@
# Test sys._current_frames() in a WITH_THREADS build.
def current_frames_with_threads(self):
- import threading, thread
+ import threading, _thread
import traceback
# Spawn a thread that blocks at a known place. Then the main
@@ -216,7 +216,7 @@
g456()
def g456():
- thread_info.append(thread.get_ident())
+ thread_info.append(_thread.get_ident())
entered_g.set()
leave_g.wait()
@@ -232,7 +232,7 @@
d = sys._current_frames()
- main_id = thread.get_ident()
+ main_id = _thread.get_ident()
self.assert_(main_id in d)
self.assert_(thread_id in d)
diff --git a/Lib/test/test_thread.py b/Lib/test/test_thread.py
index cff9f81..84d5a9d 100644
--- a/Lib/test/test_thread.py
+++ b/Lib/test/test_thread.py
@@ -2,7 +2,7 @@
import unittest
import random
from test import support
-import thread
+import _thread as thread
import time
diff --git a/Lib/test/test_threaded_import.py b/Lib/test/test_threaded_import.py
index fbe479c..67d1505 100644
--- a/Lib/test/test_threaded_import.py
+++ b/Lib/test/test_threaded_import.py
@@ -5,7 +5,7 @@
# complains several times about module random having no attribute
# randrange, and then Python hangs.
-import thread
+import _thread as thread
from test.support import verbose, TestSkipped, TestFailed
critical_section = thread.allocate_lock()
diff --git a/Lib/test/test_threadedtempfile.py b/Lib/test/test_threadedtempfile.py
index fb122d0..d93b382 100644
--- a/Lib/test/test_threadedtempfile.py
+++ b/Lib/test/test_threadedtempfile.py
@@ -16,7 +16,7 @@
NUM_THREADS = 20
FILES_PER_THREAD = 50
-import thread # If this fails, we can't test this module
+import _thread as thread # If this fails, we can't test this module
import threading
import tempfile
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index 9582dde..3c09b0b 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -5,7 +5,7 @@
import random
import sys
import threading
-import thread
+import _thread
import time
import unittest
import weakref
@@ -88,7 +88,7 @@
print('with 256kB thread stack size...')
try:
threading.stack_size(262144)
- except thread.error:
+ except _thread.error:
if verbose:
print('platform does not support changing thread stack size')
return
@@ -101,7 +101,7 @@
print('with 1MB thread stack size...')
try:
threading.stack_size(0x100000)
- except thread.error:
+ except _thread.error:
if verbose:
print('platform does not support changing thread stack size')
return
@@ -120,7 +120,7 @@
mutex = threading.Lock()
mutex.acquire()
- tid = thread.start_new_thread(f, (mutex,))
+ tid = _thread.start_new_thread(f, (mutex,))
# Wait for the thread to finish.
mutex.acquire()
self.assert_(tid in threading._active)
@@ -154,7 +154,7 @@
class Worker(threading.Thread):
def run(self):
- self.id = thread.get_ident()
+ self.id = _thread.get_ident()
self.finished = False
try:
@@ -211,10 +211,10 @@
import subprocess
rc = subprocess.call([sys.executable, "-c", """if 1:
- import ctypes, sys, time, thread
+ import ctypes, sys, time, _thread
# This lock is used as a simple event variable.
- ready = thread.allocate_lock()
+ ready = _thread.allocate_lock()
ready.acquire()
# Module globals are cleared before __del__ is run
@@ -231,7 +231,7 @@
ready.release()
time.sleep(100)
- thread.start_new_thread(waitingThread, ())
+ _thread.start_new_thread(waitingThread, ())
ready.acquire() # Be sure the other thread is waiting.
sys.exit(42)
"""])
@@ -357,7 +357,7 @@
def test_main():
test.support.run_unittest(ThreadTests,
- ThreadingExceptionTests)
+ ThreadingExceptionTests)
if __name__ == "__main__":
test_main()
diff --git a/Lib/test/test_threadsignals.py b/Lib/test/test_threadsignals.py
index cbed42c..14bd3b7 100644
--- a/Lib/test/test_threadsignals.py
+++ b/Lib/test/test_threadsignals.py
@@ -1,7 +1,7 @@
"""PyUnit testing that threads honor our signal semantics"""
import unittest
-import thread
+import _thread as thread
import signal
import os
import sys
diff --git a/Lib/threading.py b/Lib/threading.py
index be97807..673d88e 100644
--- a/Lib/threading.py
+++ b/Lib/threading.py
@@ -1,12 +1,7 @@
"""Thread module emulating a subset of Java's threading model."""
import sys as _sys
-
-try:
- import thread
-except ImportError:
- del _sys.modules[__name__]
- raise
+import _thread
from time import time as _time, sleep as _sleep
from traceback import format_exc as _format_exc
@@ -17,11 +12,11 @@
'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Thread',
'Timer', 'setprofile', 'settrace', 'local', 'stack_size']
-_start_new_thread = thread.start_new_thread
-_allocate_lock = thread.allocate_lock
-_get_ident = thread.get_ident
-ThreadError = thread.error
-del thread
+_start_new_thread = _thread.start_new_thread
+_allocate_lock = _thread.allocate_lock
+_get_ident = _thread.get_ident
+ThreadError = _thread.error
+del _thread
# Debug support (adapted from ihooks.py).
@@ -556,18 +551,18 @@
def _delete(self):
"Remove current thread from the dict of currently running threads."
- # Notes about running with dummy_thread:
+ # Notes about running with _dummy_thread:
#
- # Must take care to not raise an exception if dummy_thread is being
+ # Must take care to not raise an exception if _dummy_thread is being
# used (and thus this module is being used as an instance of
- # dummy_threading). dummy_thread.get_ident() always returns -1 since
- # there is only one thread if dummy_thread is being used. Thus
+ # dummy_threading). _dummy_thread.get_ident() always returns -1 since
+ # there is only one thread if _dummy_thread is being used. Thus
# len(_active) is always <= 1 here, and any Thread instance created
# overwrites the (if any) thread currently registered in _active.
#
# An instance of _MainThread is always created by 'threading'. This
# gets overwritten the instant an instance of Thread is created; both
- # threads return -1 from dummy_thread.get_ident() and thus have the
+ # threads return -1 from _dummy_thread.get_ident() and thus have the
# same key in the dict. So when the _MainThread instance created by
# 'threading' tries to clean itself up when atexit calls this method
# it gets a KeyError if another Thread instance was created.
@@ -763,7 +758,7 @@
_active_limbo_lock.release()
return active
-from thread import stack_size
+from _thread import stack_size
# Create the main thread object,
# and make it available for the interpreter
@@ -775,7 +770,7 @@
# module, or from the python fallback
try:
- from thread import _local as local
+ from _thread import _local as local
except ImportError:
from _threading_local import local