Merged revisions 64125 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r64125 | benjamin.peterson | 2008-06-11 12:27:50 -0500 (Wed, 11 Jun 2008) | 2 lines

  give the threading API PEP 8 names
........

1 files changed, 35 insertions, 35 deletions

diff --git a/Lib/threading.py b/Lib/threading.py
index bce291e..934eeae 100644
--- a/Lib/threading.py
+++ b/Lib/threading.py
@@ -8,7 +8,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']
 
@@ -40,7 +40,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:
@@ -83,11 +83,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__:
@@ -107,7 +107,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:
@@ -141,7 +141,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):
@@ -190,7 +190,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()
@@ -258,7 +258,7 @@ class _Condition(_Verbose):
             except ValueError:
                 pass
 
-    def notifyAll(self):
+    def notify_all(self):
         self.notify(len(self._waiters))
 
 
@@ -337,14 +337,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()
 
@@ -412,12 +412,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"
@@ -431,7 +431,7 @@ class Thread(_Verbose):
         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)
@@ -502,7 +502,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
@@ -510,7 +510,7 @@ class Thread(_Verbose):
                     exc_type, exc_value, exc_tb = self._exc_info()
                     try:
                         print((
-                            "Exception in thread " + self.getName() +
+                            "Exception in thread " + self.get_name() +
                             " (most likely raised during interpreter shutdown):"), file=self._stderr)
                         print((
                             "Traceback (most recent call last):"), file=self._stderr)
@@ -549,7 +549,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):
@@ -582,7 +582,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
@@ -590,9 +590,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__:
@@ -621,30 +621,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
 
@@ -675,7 +675,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()
 
@@ -709,16 +709,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).
 
@@ -747,14 +747,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()
@@ -831,7 +831,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)