give the threading API PEP 8 names

18 files changed, 107 insertions, 107 deletions

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 @@ class Queue:
             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 @@ class _localbase(object):
         # __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 @@ class local(_localbase):
                 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 @@ class LogRecord:
         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 @@ class DummyProcess(threading.Thread):
         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 DummyProcess(threading.Thread):
 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 @@ class Server(object):
                     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 @@ class Server(object):
         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 @@ class Server(object):
 

             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 @@ class Server(object):
                     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 @@ class Server(object):
         '''

         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 @@ class BaseProxy(object):
     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 @@ class BaseProxy(object):
             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 @@ class BaseProxy(object):
         # 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 AcquirerProxy(BaseProxy):
 

 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 @@ class Pool(object):
             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 @@ class Pool(object):
             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 @@ class Pool(object):
 

     @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 @@ class Pool(object):
 

     @staticmethod

     def _handle_results(outqueue, get, cache):

-        thread = threading.currentThread()

+        thread = threading.current_thread()

 

         while 1:

             try:

@@ -346,7 +346,7 @@ class Pool(object):
         # 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 @@ class Pool(object):
         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 @@ class ThreadPool(Pool):
         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 @@ class Queue(object):
                   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 @@ def _get_listener():
                 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 @@ class Lock(SemLock):
         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 @@ class RLock(SemLock):
         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 @@ class DummyThreadingTestCase(unittest.TestCase):
             #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 @@ class DummyThreadingTestCase(unittest.TestCase):
             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 @@ class _TestCondition(BaseTestCase):
         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 @@ class _TestCondition(BaseTestCase):
 

             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 @@ class _TestCondition(BaseTestCase):
             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 @@ class BlockingTestMixin:
         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 @@ class BlockingTestMixin:
                                  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 @@ def debugging_server(serv, serv_evt, client_evt):
 
             # 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 @@ def debugging_server(serv, serv_evt, client_evt):
     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 @@ class ThreadableTest:
             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 @@ class SocketServerTest(unittest.TestCase):
             # 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 @@ class TestThread(threading.Thread):
         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 @@ class TestThread(threading.Thread):
 
             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 @@ class ThreadTests(unittest.TestCase):
         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 @@ class ThreadTests(unittest.TestCase):
             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 @@ class ThreadTests(unittest.TestCase):
                     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 @@ class ThreadTests(unittest.TestCase):
                 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 @@ class ThreadingExceptionTests(unittest.TestCase):
         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 @@ class ThreadingExceptionTests(unittest.TestCase):
     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 @@ for name, func, args in [
     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 traceback import format_exc as _format_exc
 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 __debug__:
             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 @@ class _RLock(_Verbose):
         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 @@ class _RLock(_Verbose):
     __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 @@ class _RLock(_Verbose):
         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 @@ class _Condition(_Verbose):
         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 @@ class _Condition(_Verbose):
             except ValueError:
                 pass
 
-    def notifyAll(self):
+    def notify_all(self):
         self.notify(len(self.__waiters))
 
 
@@ -350,14 +350,14 @@ class _Event(_Verbose):
         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 @@ class Thread(_Verbose):
 
     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 @@ class Thread(_Verbose):
     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 @@ class Thread(_Verbose):
                 # 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 @@ class Thread(_Verbose):
                     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 @@ class Thread(_Verbose):
     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 @@ class Thread(_Verbose):
                 # 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 @@ class Thread(_Verbose):
     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 @@ class Thread(_Verbose):
         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 @@ class _Timer(Thread):
 
     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 @@ class _MainThread(Thread):
 
 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 @@ class _DummyThread(Thread):
 
 # 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 @@ def _test():
             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)