give the threading API PEP 8 names
diff --git a/Lib/Queue.py b/Lib/Queue.py
index 7b0b328..773b680 100644
--- a/Lib/Queue.py
+++ b/Lib/Queue.py
@@ -62,7 +62,7 @@
if unfinished <= 0:
if unfinished < 0:
raise ValueError('task_done() called too many times')
- self.all_tasks_done.notifyAll()
+ self.all_tasks_done.notify_all()
self.unfinished_tasks = unfinished
finally:
self.all_tasks_done.release()
diff --git a/Lib/_threading_local.py b/Lib/_threading_local.py
index f0ce857..4eda630 100644
--- a/Lib/_threading_local.py
+++ b/Lib/_threading_local.py
@@ -162,16 +162,16 @@
# __init__ being called, to make sure we don't call it
# again ourselves.
dict = object.__getattribute__(self, '__dict__')
- currentThread().__dict__[key] = dict
+ current_thread().__dict__[key] = dict
return self
def _patch(self):
key = object.__getattribute__(self, '_local__key')
- d = currentThread().__dict__.get(key)
+ d = current_thread().__dict__.get(key)
if d is None:
d = {}
- currentThread().__dict__[key] = d
+ current_thread().__dict__[key] = d
object.__setattr__(self, '__dict__', d)
# we have a new instance dict, so call out __init__ if we have
@@ -238,4 +238,4 @@
except KeyError:
pass # didn't have anything in this thread
-from threading import currentThread, RLock
+from threading import current_thread, RLock
diff --git a/Lib/logging/__init__.py b/Lib/logging/__init__.py
index 2c84a6a..38bbae0 100644
--- a/Lib/logging/__init__.py
+++ b/Lib/logging/__init__.py
@@ -262,7 +262,7 @@
self.relativeCreated = (self.created - _startTime) * 1000
if logThreads and thread:
self.thread = thread.get_ident()
- self.threadName = threading.currentThread().getName()
+ self.threadName = threading.current_thread().get_name()
else:
self.thread = None
self.threadName = None
diff --git a/Lib/multiprocessing/dummy/__init__.py b/Lib/multiprocessing/dummy/__init__.py
index e35ccee..cabf580 100644
--- a/Lib/multiprocessing/dummy/__init__.py
+++ b/Lib/multiprocessing/dummy/__init__.py
@@ -48,24 +48,24 @@
threading.Thread.start(self)
def get_exitcode(self):
- if self._start_called and not self.isAlive():
+ if self._start_called and not self.is_alive():
return 0
else:
return None
# XXX
if sys.version_info < (3, 0):
- is_alive = threading.Thread.isAlive.im_func
- get_name = threading.Thread.getName.im_func
- set_name = threading.Thread.setName.im_func
- is_daemon = threading.Thread.isDaemon.im_func
- set_daemon = threading.Thread.setDaemon.im_func
+ is_alive = threading.Thread.is_alive.im_func
+ get_name = threading.Thread.get_name.im_func
+ set_name = threading.Thread.set_name.im_func
+ is_daemon = threading.Thread.is_daemon.im_func
+ set_daemon = threading.Thread.set_daemon.im_func
else:
- is_alive = threading.Thread.isAlive
- get_name = threading.Thread.getName
- set_name = threading.Thread.setName
- is_daemon = threading.Thread.isDaemon
- set_daemon = threading.Thread.setDaemon
+ is_alive = threading.Thread.is_alive
+ get_name = threading.Thread.get_name
+ set_name = threading.Thread.set_name
+ is_daemon = threading.Thread.is_daemon
+ set_daemon = threading.Thread.set_daemon
#
#
@@ -74,22 +74,22 @@
class Condition(threading._Condition):
# XXX
if sys.version_info < (3, 0):
- notify_all = threading._Condition.notifyAll.im_func
+ notify_all = threading._Condition.notify_all.im_func
else:
- notify_all = threading._Condition.notifyAll
+ notify_all = threading._Condition.notify_all
#
#
#
Process = DummyProcess
-current_process = threading.currentThread
+current_process = threading.current_thread
current_process()._children = weakref.WeakKeyDictionary()
def active_children():
children = current_process()._children
for p in list(children):
- if not p.isAlive():
+ if not p.is_alive():
children.pop(p, None)
return list(children)
diff --git a/Lib/multiprocessing/managers.py b/Lib/multiprocessing/managers.py
index 4af2107..908c193 100644
--- a/Lib/multiprocessing/managers.py
+++ b/Lib/multiprocessing/managers.py
@@ -169,7 +169,7 @@
except (OSError, IOError):
continue
t = threading.Thread(target=self.handle_request, args=(c,))
- t.setDaemon(True)
+ t.set_daemon(True)
t.start()
except (KeyboardInterrupt, SystemExit):
pass
@@ -216,7 +216,7 @@
Handle requests from the proxies in a particular process/thread
'''
util.debug('starting server thread to service %r',
- threading.currentThread().getName())
+ threading.current_thread().get_name())
recv = conn.recv
send = conn.send
@@ -266,7 +266,7 @@
except EOFError:
util.debug('got EOF -- exiting thread serving %r',
- threading.currentThread().getName())
+ threading.current_thread().get_name())
sys.exit(0)
except Exception:
@@ -279,7 +279,7 @@
send(('#UNSERIALIZABLE', repr(msg)))
except Exception, e:
util.info('exception in thread serving %r',
- threading.currentThread().getName())
+ threading.current_thread().get_name())
util.info(' ... message was %r', msg)
util.info(' ... exception was %r', e)
conn.close()
@@ -401,7 +401,7 @@
'''
Spawn a new thread to serve this connection
'''
- threading.currentThread().setName(name)
+ threading.current_thread().set_name(name)
c.send(('#RETURN', None))
self.serve_client(c)
@@ -715,8 +715,8 @@
def _connect(self):
util.debug('making connection to manager')
name = current_process().get_name()
- if threading.currentThread().getName() != 'MainThread':
- name += '|' + threading.currentThread().getName()
+ if threading.current_thread().get_name() != 'MainThread':
+ name += '|' + threading.current_thread().get_name()
conn = self._Client(self._token.address, authkey=self._authkey)
dispatch(conn, None, 'accept_connection', (name,))
self._tls.connection = conn
@@ -729,7 +729,7 @@
conn = self._tls.connection
except AttributeError:
util.debug('thread %r does not own a connection',
- threading.currentThread().getName())
+ threading.current_thread().get_name())
self._connect()
conn = self._tls.connection
@@ -790,7 +790,7 @@
# the process owns no more references to objects for this manager
if not idset and hasattr(tls, 'connection'):
util.debug('thread %r has no more proxies so closing conn',
- threading.currentThread().getName())
+ threading.current_thread().get_name())
tls.connection.close()
del tls.connection
@@ -969,13 +969,13 @@
class ConditionProxy(AcquirerProxy):
# XXX will Condition.notfyAll() name be available in Py3.0?
- _exposed_ = ('acquire', 'release', 'wait', 'notify', 'notifyAll')
+ _exposed_ = ('acquire', 'release', 'wait', 'notify', 'notify_all')
def wait(self, timeout=None):
return self._callmethod('wait', (timeout,))
def notify(self):
return self._callmethod('notify')
def notify_all(self):
- return self._callmethod('notifyAll')
+ return self._callmethod('notify_all')
class EventProxy(BaseProxy):
# XXX will Event.isSet name be available in Py3.0?
diff --git a/Lib/multiprocessing/pool.py b/Lib/multiprocessing/pool.py
index b455893..0255c86 100644
--- a/Lib/multiprocessing/pool.py
+++ b/Lib/multiprocessing/pool.py
@@ -107,7 +107,7 @@
target=Pool._handle_tasks,
args=(self._taskqueue, self._quick_put, self._outqueue, self._pool)
)
- self._task_handler.setDaemon(True)
+ self._task_handler.set_daemon(True)
self._task_handler._state = RUN
self._task_handler.start()
@@ -115,7 +115,7 @@
target=Pool._handle_results,
args=(self._outqueue, self._quick_get, self._cache)
)
- self._result_handler.setDaemon(True)
+ self._result_handler.set_daemon(True)
self._result_handler._state = RUN
self._result_handler.start()
@@ -213,7 +213,7 @@
@staticmethod
def _handle_tasks(taskqueue, put, outqueue, pool):
- thread = threading.currentThread()
+ thread = threading.current_thread()
for taskseq, set_length in iter(taskqueue.get, None):
i = -1
@@ -252,7 +252,7 @@
@staticmethod
def _handle_results(outqueue, get, cache):
- thread = threading.currentThread()
+ thread = threading.current_thread()
while 1:
try:
@@ -346,7 +346,7 @@
# task_handler may be blocked trying to put items on inqueue
debug('removing tasks from inqueue until task handler finished')
inqueue._rlock.acquire()
- while task_handler.isAlive() and inqueue._reader.poll():
+ while task_handler.is_alive() and inqueue._reader.poll():
inqueue._reader.recv()
time.sleep(0)
@@ -362,7 +362,7 @@
debug('helping task handler/workers to finish')
cls._help_stuff_finish(inqueue, task_handler, len(pool))
- assert result_handler.isAlive() or len(cache) == 0
+ assert result_handler.is_alive() or len(cache) == 0
result_handler._state = TERMINATE
outqueue.put(None) # sentinel
@@ -591,6 +591,6 @@
try:
inqueue.queue.clear()
inqueue.queue.extend([None] * size)
- inqueue.not_empty.notifyAll()
+ inqueue.not_empty.notify_all()
finally:
inqueue.not_empty.release()
diff --git a/Lib/multiprocessing/queues.py b/Lib/multiprocessing/queues.py
index 07d5aa9..78cb362 100644
--- a/Lib/multiprocessing/queues.py
+++ b/Lib/multiprocessing/queues.py
@@ -155,7 +155,7 @@
self._wlock, self._writer.close),
name='QueueFeederThread'
)
- self._thread.setDaemon(True)
+ self._thread.set_daemon(True)
debug('doing self._thread.start()')
self._thread.start()
diff --git a/Lib/multiprocessing/reduction.py b/Lib/multiprocessing/reduction.py
index aa77075..0d6cf4f 100644
--- a/Lib/multiprocessing/reduction.py
+++ b/Lib/multiprocessing/reduction.py
@@ -84,7 +84,7 @@
debug('starting listener and thread for sending handles')
_listener = Listener(authkey=current_process().get_authkey())
t = threading.Thread(target=_serve)
- t.setDaemon(True)
+ t.set_daemon(True)
t.start()
finally:
_lock.release()
diff --git a/Lib/multiprocessing/synchronize.py b/Lib/multiprocessing/synchronize.py
index aa09857..d642032 100644
--- a/Lib/multiprocessing/synchronize.py
+++ b/Lib/multiprocessing/synchronize.py
@@ -109,8 +109,8 @@
try:
if self._semlock._is_mine():
name = current_process().get_name()
- if threading.currentThread().getName() != 'MainThread':
- name += '|' + threading.currentThread().getName()
+ if threading.current_thread().get_name() != 'MainThread':
+ name += '|' + threading.current_thread().get_name()
elif self._semlock._get_value() == 1:
name = 'None'
elif self._semlock._count() > 0:
@@ -134,8 +134,8 @@
try:
if self._semlock._is_mine():
name = current_process().get_name()
- if threading.currentThread().getName() != 'MainThread':
- name += '|' + threading.currentThread().getName()
+ if threading.current_thread().get_name() != 'MainThread':
+ name += '|' + threading.current_thread().get_name()
count = self._semlock._count()
elif self._semlock._get_value() == 1:
name, count = 'None', 0
diff --git a/Lib/test/test_dummy_threading.py b/Lib/test/test_dummy_threading.py
index df7df3c..ce248a2 100644
--- a/Lib/test/test_dummy_threading.py
+++ b/Lib/test/test_dummy_threading.py
@@ -16,7 +16,7 @@
#delay = random.random() * 2
delay = 0
if test_support.verbose:
- print 'task', self.getName(), 'will run for', delay, 'sec'
+ print 'task', self.get_name(), 'will run for', delay, 'sec'
sema.acquire()
mutex.acquire()
running += 1
@@ -25,11 +25,11 @@
mutex.release()
time.sleep(delay)
if test_support.verbose:
- print 'task', self.getName(), 'done'
+ print 'task', self.get_name(), 'done'
mutex.acquire()
running -= 1
if test_support.verbose:
- print self.getName(), 'is finished.', running, 'tasks are running'
+ print self.get_name(), 'is finished.', running, 'tasks are running'
mutex.release()
sema.release()
diff --git a/Lib/test/test_multiprocessing.py b/Lib/test/test_multiprocessing.py
index a67c296..d75fd20 100644
--- a/Lib/test/test_multiprocessing.py
+++ b/Lib/test/test_multiprocessing.py
@@ -632,7 +632,7 @@
p.start()
p = threading.Thread(target=self.f, args=(cond, sleeping, woken))
- p.setDaemon(True)
+ p.set_daemon(True)
p.start()
# wait for both children to start sleeping
@@ -679,7 +679,7 @@
t = threading.Thread(target=self.f,
args=(cond, sleeping, woken, TIMEOUT1))
- t.setDaemon(True)
+ t.set_daemon(True)
t.start()
# wait for them all to sleep
@@ -701,7 +701,7 @@
p.start()
t = threading.Thread(target=self.f, args=(cond, sleeping, woken))
- t.setDaemon(True)
+ t.set_daemon(True)
t.start()
# wait for them to all sleep
diff --git a/Lib/test/test_queue.py b/Lib/test/test_queue.py
index 660e177..e0eb8f4 100644
--- a/Lib/test/test_queue.py
+++ b/Lib/test/test_queue.py
@@ -49,11 +49,11 @@
self.t.start()
self.result = block_func(*block_args)
# If block_func returned before our thread made the call, we failed!
- if not self.t.startedEvent.isSet():
+ if not self.t.startedEvent.is_set():
self.fail("blocking function '%r' appeared not to block" %
block_func)
self.t.join(10) # make sure the thread terminates
- if self.t.isAlive():
+ if self.t.is_alive():
self.fail("trigger function '%r' appeared to not return" %
trigger_func)
return self.result
@@ -73,10 +73,10 @@
expected_exception_class)
finally:
self.t.join(10) # make sure the thread terminates
- if self.t.isAlive():
+ if self.t.is_alive():
self.fail("trigger function '%r' appeared to not return" %
trigger_func)
- if not self.t.startedEvent.isSet():
+ if not self.t.startedEvent.is_set():
self.fail("trigger thread ended but event never set")
diff --git a/Lib/test/test_smtplib.py b/Lib/test/test_smtplib.py
index be28de7..7caa8a7 100644
--- a/Lib/test/test_smtplib.py
+++ b/Lib/test/test_smtplib.py
@@ -109,7 +109,7 @@
# when the client conversation is finished, it will
# set client_evt, and it's then ok to kill the server
- if client_evt.isSet():
+ if client_evt.is_set():
serv.close()
break
@@ -118,7 +118,7 @@
except socket.timeout:
pass
finally:
- if not client_evt.isSet():
+ if not client_evt.is_set():
# allow some time for the client to read the result
time.sleep(0.5)
serv.close()
diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
index ba5eea9..1287dd1 100644
--- a/Lib/test/test_socket.py
+++ b/Lib/test/test_socket.py
@@ -107,7 +107,7 @@
self.clientRun, (test_method,))
self.__setUp()
- if not self.server_ready.isSet():
+ if not self.server_ready.is_set():
self.server_ready.set()
self.client_ready.wait()
diff --git a/Lib/test/test_socketserver.py b/Lib/test/test_socketserver.py
index 8595e5a..f6de8fa 100644
--- a/Lib/test/test_socketserver.py
+++ b/Lib/test/test_socketserver.py
@@ -139,7 +139,7 @@
# Time between requests is short enough that we won't wake
# up spuriously too many times.
kwargs={'poll_interval':0.01})
- t.setDaemon(True) # In case this function raises.
+ t.set_daemon(True) # In case this function raises.
t.start()
if verbose: print "server running"
for i in range(3):
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index b974715..db6b0d7 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -34,7 +34,7 @@
delay = random.random() / 10000.0
if verbose:
print 'task %s will run for %.1f usec' % (
- self.getName(), delay * 1e6)
+ self.get_name(), delay * 1e6)
with self.sema:
with self.mutex:
@@ -45,14 +45,14 @@
time.sleep(delay)
if verbose:
- print 'task', self.getName(), 'done'
+ print 'task', self.get_name(), 'done'
with self.mutex:
self.nrunning.dec()
self.testcase.assert_(self.nrunning.get() >= 0)
if verbose:
print '%s is finished. %d tasks are running' % (
- self.getName(), self.nrunning.get())
+ self.get_name(), self.nrunning.get())
class ThreadTests(unittest.TestCase):
@@ -73,7 +73,7 @@
for i in range(NUMTASKS):
t = TestThread("<thread %d>"%i, self, sema, mutex, numrunning)
threads.append(t)
- self.failUnlessEqual(t.getIdent(), None)
+ self.failUnlessEqual(t.get_ident(), None)
self.assert_(re.match('<TestThread\(.*, initial\)>', repr(t)))
t.start()
@@ -81,8 +81,8 @@
print 'waiting for all tasks to complete'
for t in threads:
t.join(NUMTASKS)
- self.assert_(not t.isAlive())
- self.failIfEqual(t.getIdent(), 0)
+ self.assert_(not t.is_alive())
+ self.failIfEqual(t.get_ident(), 0)
self.assert_(re.match('<TestThread\(.*, \w+ -?\d+\)>', repr(t)))
if verbose:
print 'all tasks done'
@@ -172,7 +172,7 @@
worker_saw_exception.set()
t = Worker()
- t.setDaemon(True) # so if this fails, we don't hang Python at shutdown
+ t.set_daemon(True) # so if this fails, we don't hang Python at shutdown
t.start()
if verbose:
print " started worker thread"
@@ -258,12 +258,12 @@
print 'program blocked; aborting'
os._exit(2)
t = threading.Thread(target=killer)
- t.setDaemon(True)
+ t.set_daemon(True)
t.start()
# This is the trace function
def func(frame, event, arg):
- threading.currentThread()
+ threading.current_thread()
return func
sys.settrace(func)
@@ -348,8 +348,8 @@
self.assertRaises(ValueError, threading.Semaphore, value = -sys.maxint)
def test_joining_current_thread(self):
- currentThread = threading.currentThread()
- self.assertRaises(RuntimeError, currentThread.join);
+ current_thread = threading.current_thread()
+ self.assertRaises(RuntimeError, current_thread.join);
def test_joining_inactive_thread(self):
thread = threading.Thread()
@@ -358,7 +358,7 @@
def test_daemonize_active_thread(self):
thread = threading.Thread()
thread.start()
- self.assertRaises(RuntimeError, thread.setDaemon, True)
+ self.assertRaises(RuntimeError, thread.set_daemon, True)
def test_main():
diff --git a/Lib/test/threaded_import_hangers.py b/Lib/test/threaded_import_hangers.py
index b21c52f..d750874 100644
--- a/Lib/test/threaded_import_hangers.py
+++ b/Lib/test/threaded_import_hangers.py
@@ -38,5 +38,5 @@
t = Worker(func, args)
t.start()
t.join(TIMEOUT)
- if t.isAlive():
+ if t.is_alive():
errors.append("%s appeared to hang" % name)
diff --git a/Lib/threading.py b/Lib/threading.py
index 0d34b6a..751b692 100644
--- a/Lib/threading.py
+++ b/Lib/threading.py
@@ -14,7 +14,7 @@
from collections import deque
# Rename some stuff so "from threading import *" is safe
-__all__ = ['activeCount', 'Condition', 'currentThread', 'enumerate', 'Event',
+__all__ = ['active_count', 'Condition', 'current_thread', 'enumerate', 'Event',
'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Thread',
'Timer', 'setprofile', 'settrace', 'local', 'stack_size']
@@ -52,7 +52,7 @@
if self.__verbose:
format = format % args
format = "%s: %s\n" % (
- currentThread().getName(), format)
+ current_thread().get_name(), format)
_sys.stderr.write(format)
else:
@@ -95,11 +95,11 @@
owner = self.__owner
return "<%s(%s, %d)>" % (
self.__class__.__name__,
- owner and owner.getName(),
+ owner and owner.get_name(),
self.__count)
def acquire(self, blocking=1):
- me = currentThread()
+ me = current_thread()
if self.__owner is me:
self.__count = self.__count + 1
if __debug__:
@@ -119,7 +119,7 @@
__enter__ = acquire
def release(self):
- if self.__owner is not currentThread():
+ if self.__owner is not current_thread():
raise RuntimeError("cannot release un-aquired lock")
self.__count = count = self.__count - 1
if not count:
@@ -154,7 +154,7 @@
return (count, owner)
def _is_owned(self):
- return self.__owner is currentThread()
+ return self.__owner is current_thread()
def Condition(*args, **kwargs):
@@ -203,7 +203,7 @@
self.__lock.acquire() # Ignore saved state
def _is_owned(self):
- # Return True if lock is owned by currentThread.
+ # Return True if lock is owned by current_thread.
# This method is called only if __lock doesn't have _is_owned().
if self.__lock.acquire(0):
self.__lock.release()
@@ -271,7 +271,7 @@
except ValueError:
pass
- def notifyAll(self):
+ def notify_all(self):
self.notify(len(self.__waiters))
@@ -350,14 +350,14 @@
self.__cond = Condition(Lock())
self.__flag = False
- def isSet(self):
+ def is_set(self):
return self.__flag
def set(self):
self.__cond.acquire()
try:
self.__flag = True
- self.__cond.notifyAll()
+ self.__cond.notify_all()
finally:
self.__cond.release()
@@ -425,12 +425,12 @@
def _set_daemon(self):
# Overridden in _MainThread and _DummyThread
- return currentThread().isDaemon()
+ return current_thread().is_daemon()
def __repr__(self):
assert self.__initialized, "Thread.__init__() was not called"
status = "initial"
- if self.__started.isSet():
+ if self.__started.is_set():
status = "started"
if self.__stopped:
status = "stopped"
@@ -443,7 +443,7 @@
def start(self):
if not self.__initialized:
raise RuntimeError("thread.__init__() not called")
- if self.__started.isSet():
+ if self.__started.is_set():
raise RuntimeError("thread already started")
if __debug__:
self._note("%s.start(): starting thread", self)
@@ -514,7 +514,7 @@
# self.
if _sys:
_sys.stderr.write("Exception in thread %s:\n%s\n" %
- (self.getName(), _format_exc()))
+ (self.get_name(), _format_exc()))
else:
# Do the best job possible w/o a huge amt. of code to
# approximate a traceback (code ideas from
@@ -522,7 +522,7 @@
exc_type, exc_value, exc_tb = self.__exc_info()
try:
print>>self.__stderr, (
- "Exception in thread " + self.getName() +
+ "Exception in thread " + self.get_name() +
" (most likely raised during interpreter shutdown):")
print>>self.__stderr, (
"Traceback (most recent call last):")
@@ -560,7 +560,7 @@
def __stop(self):
self.__block.acquire()
self.__stopped = True
- self.__block.notifyAll()
+ self.__block.notify_all()
self.__block.release()
def __delete(self):
@@ -593,7 +593,7 @@
# There must not be any python code between the previous line
# and after the lock is released. Otherwise a tracing function
# could try to acquire the lock again in the same thread, (in
- # currentThread()), and would block.
+ # current_thread()), and would block.
except KeyError:
if 'dummy_threading' not in _sys.modules:
raise
@@ -601,9 +601,9 @@
def join(self, timeout=None):
if not self.__initialized:
raise RuntimeError("Thread.__init__() not called")
- if not self.__started.isSet():
+ if not self.__started.is_set():
raise RuntimeError("cannot join thread before it is started")
- if self is currentThread():
+ if self is current_thread():
raise RuntimeError("cannot join current thread")
if __debug__:
@@ -631,30 +631,30 @@
finally:
self.__block.release()
- def getName(self):
+ def get_name(self):
assert self.__initialized, "Thread.__init__() not called"
return self.__name
- def setName(self, name):
+ def set_name(self, name):
assert self.__initialized, "Thread.__init__() not called"
self.__name = str(name)
- def getIdent(self):
+ def get_ident(self):
assert self.__initialized, "Thread.__init__() not called"
return self.__ident
- def isAlive(self):
+ def is_alive(self):
assert self.__initialized, "Thread.__init__() not called"
- return self.__started.isSet() and not self.__stopped
+ return self.__started.is_set() and not self.__stopped
- def isDaemon(self):
+ def is_daemon(self):
assert self.__initialized, "Thread.__init__() not called"
return self.__daemonic
- def setDaemon(self, daemonic):
+ def set_daemon(self, daemonic):
if not self.__initialized:
raise RuntimeError("Thread.__init__() not called")
- if self.__started.isSet():
+ if self.__started.is_set():
raise RuntimeError("cannot set daemon status of active thread");
self.__daemonic = daemonic
@@ -685,7 +685,7 @@
def run(self):
self.finished.wait(self.interval)
- if not self.finished.isSet():
+ if not self.finished.is_set():
self.function(*self.args, **self.kwargs)
self.finished.set()
@@ -719,16 +719,16 @@
def _pickSomeNonDaemonThread():
for t in enumerate():
- if not t.isDaemon() and t.isAlive():
+ if not t.is_daemon() and t.is_alive():
return t
return None
# Dummy thread class to represent threads not started here.
# These aren't garbage collected when they die, nor can they be waited for.
-# If they invoke anything in threading.py that calls currentThread(), they
+# If they invoke anything in threading.py that calls current_thread(), they
# leave an entry in the _active dict forever after.
-# Their purpose is to return *something* from currentThread().
+# Their purpose is to return *something* from current_thread().
# They are marked as daemon threads so we won't wait for them
# when we exit (conform previous semantics).
@@ -756,14 +756,14 @@
# Global API functions
-def currentThread():
+def current_thread():
try:
return _active[_get_ident()]
except KeyError:
- ##print "currentThread(): no current thread for", _get_ident()
+ ##print "current_thread(): no current thread for", _get_ident()
return _DummyThread()
-def activeCount():
+def active_count():
_active_limbo_lock.acquire()
count = len(_active) + len(_limbo)
_active_limbo_lock.release()
@@ -840,7 +840,7 @@
counter = 0
while counter < self.quota:
counter = counter + 1
- self.queue.put("%s.%d" % (self.getName(), counter))
+ self.queue.put("%s.%d" % (self.get_name(), counter))
_sleep(random() * 0.00001)