[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:37:28 CEST 2008
Also looks like you didn't add actually anything to the NEWS file. Sloppy work!
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