[Python-checkins] r64125 - in python/trunk: Doc/library/threading.rst Lib/Queue.py Lib/_threading_local.py Lib/logging/__init__.py Lib/multiprocessing/dummy/__init__.py Lib/multiprocessing/managers.py Lib/multiprocessing/pool.py Lib/multiprocessi
Guido van Rossum
guido at python.org
Wed Jun 11 19:36:41 CEST 2008
Eek! Looks like this went too far: the old names were supposed to
remain as backwards incompatible aliases! This will break all 3rd
party code using threading that worked under 2.5. This is
unacceptable.
On Wed, Jun 11, 2008 at 10:27 AM, benjamin.peterson
<python-checkins at python.org> wrote:
> Author: benjamin.peterson
> Date: Wed Jun 11 19:27:50 2008
> New Revision: 64125
>
> Log:
> give the threading API PEP 8 names
>
>
> Modified:
> python/trunk/Doc/library/threading.rst
> python/trunk/Lib/Queue.py
> python/trunk/Lib/_threading_local.py
> python/trunk/Lib/logging/__init__.py
> python/trunk/Lib/multiprocessing/dummy/__init__.py
> python/trunk/Lib/multiprocessing/managers.py
> python/trunk/Lib/multiprocessing/pool.py
> python/trunk/Lib/multiprocessing/queues.py
> python/trunk/Lib/multiprocessing/reduction.py
> python/trunk/Lib/multiprocessing/synchronize.py
> python/trunk/Lib/test/test_dummy_threading.py
> python/trunk/Lib/test/test_multiprocessing.py
> python/trunk/Lib/test/test_queue.py
> python/trunk/Lib/test/test_smtplib.py
> python/trunk/Lib/test/test_socket.py
> python/trunk/Lib/test/test_socketserver.py
> python/trunk/Lib/test/test_threading.py
> python/trunk/Lib/test/threaded_import_hangers.py
> python/trunk/Lib/threading.py
> python/trunk/Misc/NEWS
>
> Modified: python/trunk/Doc/library/threading.rst
> ==============================================================================
> --- python/trunk/Doc/library/threading.rst (original)
> +++ python/trunk/Doc/library/threading.rst Wed Jun 11 19:27:50 2008
> @@ -16,7 +16,7 @@
> This module defines the following functions and objects:
>
>
> -.. function:: activeCount()
> +.. function:: active_count()
>
> Return the number of :class:`Thread` objects currently alive. The returned
> count is equal to the length of the list returned by :func:`enumerate`.
> @@ -30,7 +30,7 @@
> thread.
>
>
> -.. function:: currentThread()
> +.. function:: current_thread()
>
> Return the current :class:`Thread` object, corresponding to the caller's thread
> of control. If the caller's thread of control was not created through the
> @@ -40,10 +40,10 @@
>
> .. function:: enumerate()
>
> - Return a list of all :class:`Thread` objects currently alive. The list includes
> - daemonic threads, dummy thread objects created by :func:`currentThread`, and the
> - main thread. It excludes terminated threads and threads that have not yet been
> - started.
> + Return a list of all :class:`Thread` objects currently alive. The list
> + includes daemonic threads, dummy thread objects created by
> + :func:`current_thread`, and the main thread. It excludes terminated threads
> + and threads that have not yet been started.
>
>
> .. function:: Event()
> @@ -395,7 +395,7 @@
> lock, its caller should.
>
>
> -.. method:: Condition.notifyAll()
> +.. method:: Condition.notify_all()
>
> Wake up all threads waiting on this condition. This method acts like
> :meth:`notify`, but wakes up all waiting threads instead of one. If the calling
> @@ -552,12 +552,12 @@
> thread until the thread whose :meth:`join` method is called is terminated.
>
> A thread has a name. The name can be passed to the constructor, set with the
> -:meth:`setName` method, and retrieved with the :meth:`getName` method.
> +:meth:`set_name` method, and retrieved with the :meth:`get_name` method.
>
> A thread can be flagged as a "daemon thread". The significance of this flag is
> that the entire Python program exits when only daemon threads are left. The
> initial value is inherited from the creating thread. The flag can be set with
> -the :meth:`setDaemon` method and retrieved with the :meth:`isDaemon` method.
> +the :meth:`set_daemon` method and retrieved with the :meth:`is_daemon` method.
>
> There is a "main thread" object; this corresponds to the initial thread of
> control in the Python program. It is not a daemon thread.
> @@ -637,12 +637,12 @@
> raises the same exception.
>
>
> -.. method:: Thread.getName()
> +.. method:: Thread.get_name()
>
> Return the thread's name.
>
>
> -.. method:: Thread.setName(name)
> +.. method:: Thread.set_same(name)
>
> Set the thread's name.
>
> @@ -651,18 +651,18 @@
> constructor.
>
>
> -.. method:: Thread.getIdent()
> +.. method:: Thread.get_ddent()
>
> Return the 'thread identifier' of this thread or None if the thread has not
> - been started. This is a nonzero integer. See the :mod:`thread` module's
> - :func:`get_ident()` function. Thread identifiers may be recycled when a
> - thread exits and another thread is created. The identifier is returned
> - even after the thread has exited.
> + been started. This is a nonzero integer. See the :func:`thread.get_ident()`
> + function. Thread identifiers may be recycled when a thread exits and another
> + thread is created. The identifier is returned even after the thread has
> + exited.
>
> .. versionadded:: 2.6
>
>
> -.. method:: Thread.isAlive()
> +.. method:: Thread.is_alive()
>
> Return whether the thread is alive.
>
> @@ -671,12 +671,12 @@
> returns a list of all alive threads.
>
>
> -.. method:: Thread.isDaemon()
> +.. method:: Thread.is_daemon()
>
> Return the thread's daemon flag.
>
>
> -.. method:: Thread.setDaemon(daemonic)
> +.. method:: Thread.set_daemon(daemonic)
>
> Set the thread's daemon flag to the Boolean value *daemonic*. This must be
> called before :meth:`start` is called, otherwise :exc:`RuntimeError` is raised.
>
> Modified: python/trunk/Lib/Queue.py
> ==============================================================================
> --- python/trunk/Lib/Queue.py (original)
> +++ python/trunk/Lib/Queue.py Wed Jun 11 19:27:50 2008
> @@ -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()
>
> Modified: python/trunk/Lib/_threading_local.py
> ==============================================================================
> --- python/trunk/Lib/_threading_local.py (original)
> +++ python/trunk/Lib/_threading_local.py Wed Jun 11 19:27:50 2008
> @@ -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
>
> Modified: python/trunk/Lib/logging/__init__.py
> ==============================================================================
> --- python/trunk/Lib/logging/__init__.py (original)
> +++ python/trunk/Lib/logging/__init__.py Wed Jun 11 19:27:50 2008
> @@ -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
>
> Modified: python/trunk/Lib/multiprocessing/dummy/__init__.py
> ==============================================================================
> --- python/trunk/Lib/multiprocessing/dummy/__init__.py (original)
> +++ python/trunk/Lib/multiprocessing/dummy/__init__.py Wed Jun 11 19:27:50 2008
> @@ -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)
>
>
> Modified: python/trunk/Lib/multiprocessing/managers.py
> ==============================================================================
> --- python/trunk/Lib/multiprocessing/managers.py (original)
> +++ python/trunk/Lib/multiprocessing/managers.py Wed Jun 11 19:27:50 2008
> @@ -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?
>
> Modified: python/trunk/Lib/multiprocessing/pool.py
> ==============================================================================
> --- python/trunk/Lib/multiprocessing/pool.py (original)
> +++ python/trunk/Lib/multiprocessing/pool.py Wed Jun 11 19:27:50 2008
> @@ -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()
>
> Modified: python/trunk/Lib/multiprocessing/queues.py
> ==============================================================================
> --- python/trunk/Lib/multiprocessing/queues.py (original)
> +++ python/trunk/Lib/multiprocessing/queues.py Wed Jun 11 19:27:50 2008
> @@ -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()
>
> Modified: python/trunk/Lib/multiprocessing/reduction.py
> ==============================================================================
> --- python/trunk/Lib/multiprocessing/reduction.py (original)
> +++ python/trunk/Lib/multiprocessing/reduction.py Wed Jun 11 19:27:50 2008
> @@ -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()
>
> Modified: python/trunk/Lib/multiprocessing/synchronize.py
> ==============================================================================
> --- python/trunk/Lib/multiprocessing/synchronize.py (original)
> +++ python/trunk/Lib/multiprocessing/synchronize.py Wed Jun 11 19:27:50 2008
> @@ -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
>
> Modified: python/trunk/Lib/test/test_dummy_threading.py
> ==============================================================================
> --- python/trunk/Lib/test/test_dummy_threading.py (original)
> +++ python/trunk/Lib/test/test_dummy_threading.py Wed Jun 11 19:27:50 2008
> @@ -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()
>
>
> Modified: python/trunk/Lib/test/test_multiprocessing.py
> ==============================================================================
> --- python/trunk/Lib/test/test_multiprocessing.py (original)
> +++ python/trunk/Lib/test/test_multiprocessing.py Wed Jun 11 19:27:50 2008
> @@ -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
>
> Modified: python/trunk/Lib/test/test_queue.py
> ==============================================================================
> --- python/trunk/Lib/test/test_queue.py (original)
> +++ python/trunk/Lib/test/test_queue.py Wed Jun 11 19:27:50 2008
> @@ -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")
>
>
>
> Modified: python/trunk/Lib/test/test_smtplib.py
> ==============================================================================
> --- python/trunk/Lib/test/test_smtplib.py (original)
> +++ python/trunk/Lib/test/test_smtplib.py Wed Jun 11 19:27:50 2008
> @@ -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()
>
> Modified: python/trunk/Lib/test/test_socket.py
> ==============================================================================
> --- python/trunk/Lib/test/test_socket.py (original)
> +++ python/trunk/Lib/test/test_socket.py Wed Jun 11 19:27:50 2008
> @@ -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()
>
>
> Modified: python/trunk/Lib/test/test_socketserver.py
> ==============================================================================
> --- python/trunk/Lib/test/test_socketserver.py (original)
> +++ python/trunk/Lib/test/test_socketserver.py Wed Jun 11 19:27:50 2008
> @@ -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):
>
> Modified: python/trunk/Lib/test/test_threading.py
> ==============================================================================
> --- python/trunk/Lib/test/test_threading.py (original)
> +++ python/trunk/Lib/test/test_threading.py Wed Jun 11 19:27:50 2008
> @@ -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():
>
> Modified: python/trunk/Lib/test/threaded_import_hangers.py
> ==============================================================================
> --- python/trunk/Lib/test/threaded_import_hangers.py (original)
> +++ python/trunk/Lib/test/threaded_import_hangers.py Wed Jun 11 19:27:50 2008
> @@ -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)
>
> Modified: python/trunk/Lib/threading.py
> ==============================================================================
> --- python/trunk/Lib/threading.py (original)
> +++ python/trunk/Lib/threading.py Wed Jun 11 19:27:50 2008
> @@ -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)
>
>
>
> Modified: python/trunk/Misc/NEWS
> ==============================================================================
> --- python/trunk/Misc/NEWS (original)
> +++ python/trunk/Misc/NEWS Wed Jun 11 19:27:50 2008
> @@ -291,6 +291,7 @@
> - The bundled OSX-specific copy of libbffi is now in sync with the version
> shipped with PyObjC 2.0 and includes support for x86_64 and ppc64 platforms.
>
> +
> Build
> -----
>
> _______________________________________________
> Python-checkins mailing list
> Python-checkins at python.org
> http://mail.python.org/mailman/listinfo/python-checkins
>
--
--Guido van Rossum (home page: http://www.python.org/~guido/)
More information about the Python-checkins
mailing list