[Python-checkins] r73128 - in python/branches/py3k: Doc/howto/regex.rst Lib/multiprocessing/synchronize.py Lib/test/support.py

Tue Jun 2 01:14:51 CEST 2009

Author: benjamin.peterson
Date: Tue Jun 2 01:14:51 2009
New Revision: 73128
Log:
Merged revisions 73073-73074,73089 via svnmerge from 
svn+ssh://pythondev@svn.python.org/python/trunk
........
 r73073 | benjamin.peterson | 2009年05月31日 09:43:00 -0500 (2009年5月31日) | 1 line
 
 remove function import
........
 r73074 | benjamin.peterson | 2009年05月31日 10:00:27 -0500 (2009年5月31日) | 1 line
 
 __enter__ and __exit__ must be on the class
........
 r73089 | andrew.kuchling | 2009年05月31日 19:14:19 -0500 (2009年5月31日) | 1 line
 
 The class for regexes isn't called RegexObject any more; correct the text
........
Modified:
 python/branches/py3k/ (props changed)
 python/branches/py3k/Doc/howto/regex.rst
 python/branches/py3k/Lib/multiprocessing/synchronize.py
 python/branches/py3k/Lib/test/support.py
Modified: python/branches/py3k/Doc/howto/regex.rst
==============================================================================

--- python/branches/py3k/Doc/howto/regex.rst	(original)
+++ python/branches/py3k/Doc/howto/regex.rst	Tue Jun 2 01:14:51 2009
@@ -257,7 +257,7 @@
 Compiling Regular Expressions
 -----------------------------
 
-Regular expressions are compiled into :class:`RegexObject` instances, which have
+Regular expressions are compiled into pattern objects, which have
 methods for various operations such as searching for pattern matches or
 performing string substitutions. ::
 
@@ -336,7 +336,7 @@
 ------------------
 
 Once you have an object representing a compiled regular expression, what do you
-do with it? :class:`RegexObject` instances have several methods and attributes.
+do with it? Pattern objects have several methods and attributes.
 Only the most significant ones will be covered here; consult the :mod:`re` docs
 for a complete listing.
 
@@ -427,8 +427,8 @@
 and :meth:`end` return the starting and ending index of the match. :meth:`span`
 returns both start and end indexes in a single tuple. Since the :meth:`match`
 method only checks if the RE matches at the start of a string, :meth:`start`
-will always be zero. However, the :meth:`search` method of :class:`RegexObject`
-instances scans through the string, so the match may not start at zero in that
+will always be zero. However, the :meth:`search` method of patterns
+scans through the string, so the match may not start at zero in that
 case. ::
 
 >>> print(p.match('::: message'))
@@ -450,7 +450,7 @@
 else:
 print('No match')
 
-Two :class:`RegexObject` methods return all of the matches for a pattern.
+Two pattern methods return all of the matches for a pattern.
 :meth:`findall` returns a list of matching strings::
 
 >>> p = re.compile('\d+')
@@ -475,10 +475,10 @@
 Module-Level Functions
 ----------------------
 
-You don't have to create a :class:`RegexObject` and call its methods; the
+You don't have to create a pattern object and call its methods; the
 :mod:`re` module also provides top-level functions called :func:`match`,
 :func:`search`, :func:`findall`, :func:`sub`, and so forth. These functions
-take the same arguments as the corresponding :class:`RegexObject` method, with
+take the same arguments as the corresponding pattern method, with
 the RE string added as the first argument, and still return either ``None`` or a
 :class:`MatchObject` instance. ::
 
@@ -487,12 +487,12 @@
 >>> re.match(r'From\s+', 'From amk Thu May 14 19:12:10 1998')
 <re.MatchObject instance at 80c5978>
 
-Under the hood, these functions simply produce a :class:`RegexObject` for you
+Under the hood, these functions simply create a pattern object for you
 and call the appropriate method on it. They also store the compiled object in a
 cache, so future calls using the same RE are faster.
 
 Should you use these module-level functions, or should you get the
-:class:`RegexObject` and call its methods yourself? That choice depends on how
+pattern and call its methods yourself? That choice depends on how
 frequently the RE will be used, and on your personal coding style. If the RE is
 being used at only one point in the code, then the module functions are probably
 more convenient. If a program contains a lot of regular expressions, or re-uses
@@ -1031,7 +1031,7 @@
 
 Up to this point, we've simply performed searches against a static string.
 Regular expressions are also commonly used to modify strings in various ways,
-using the following :class:`RegexObject` methods:
+using the following pattern methods:
 
 +------------------+-----------------------------------------------+
 | Method/Attribute | Purpose |
@@ -1051,7 +1051,7 @@
 Splitting Strings
 -----------------
 
-The :meth:`split` method of a :class:`RegexObject` splits a string apart
+The :meth:`split` method of a pattern splits a string apart
 wherever the RE matches, returning a list of the pieces. It's similar to the
 :meth:`split` method of strings but provides much more generality in the
 delimiters that you can split by; :meth:`split` only supports splitting by
@@ -1196,10 +1196,10 @@
 'Call 0xffd2 for printing, 0xc000 for user code.'
 
 When using the module-level :func:`re.sub` function, the pattern is passed as
-the first argument. The pattern may be a string or a :class:`RegexObject`; if
+the first argument. The pattern may be provided as an object or as a string; if
 you need to specify regular expression flags, you must either use a
-:class:`RegexObject` as the first parameter, or use embedded modifiers in the
-pattern, e.g. ``sub("(?i)b+", "x", "bbbb BBBB")`` returns ``'x x'``.
+pattern object as the first parameter, or use embedded modifiers in the
+pattern string, e.g. ``sub("(?i)b+", "x", "bbbb BBBB")`` returns ``'x x'``.
 
 
 Common Problems
Modified: python/branches/py3k/Lib/multiprocessing/synchronize.py
==============================================================================
--- python/branches/py3k/Lib/multiprocessing/synchronize.py	(original)
+++ python/branches/py3k/Lib/multiprocessing/synchronize.py	Tue Jun 2 01:14:51 2009
@@ -58,8 +58,12 @@
 def _make_methods(self):
 self.acquire = self._semlock.acquire
 self.release = self._semlock.release
- self.__enter__ = self._semlock.__enter__
- self.__exit__ = self._semlock.__exit__
+
+ def __enter__(self):
+ return self._semlock.__enter__()
+
+ def __exit__(self, *args):
+ return self._semlock.__exit__(*args)
 
 def __getstate__(self):
 assert_spawning(self)
@@ -181,11 +185,15 @@
 self._woken_count, self._wait_semaphore) = state
 self._make_methods()
 
+ def __enter__(self):
+ return self._lock.__enter__()
+
+ def __exit__(self, *args):
+ return self._lock.__exit__(*args)
+
 def _make_methods(self):
 self.acquire = self._lock.acquire
 self.release = self._lock.release
- self.__enter__ = self._lock.__enter__
- self.__exit__ = self._lock.__exit__
 
 def __repr__(self):
 try:
Modified: python/branches/py3k/Lib/test/support.py
==============================================================================
--- python/branches/py3k/Lib/test/support.py	(original)
+++ python/branches/py3k/Lib/test/support.py	Tue Jun 2 01:14:51 2009
@@ -6,6 +6,7 @@
 import contextlib
 import errno
 import functools
+import gc
 import socket
 import sys
 import os
@@ -630,7 +631,6 @@
 longer than expected. This function tries its best to force all garbage
 objects to disappear.
 """
- import gc
 gc.collect()
 gc.collect()
 gc.collect()
