Mailman 3 February 2012 - Python-checkins

cpython (2.7): #14089: increase coverage of the fractions module. Patch by Oleg Plakhotnyuk.
by ezio.melotti 29 Feb '12

29 Feb '12

http://hg.python.org/cpython/rev/8e00de3acb44 changeset: 75345:8e00de3acb44 branch: 2.7 parent: 75342:3958121a027f user: Ezio Melotti <ezio.melotti(a)gmail.com> date: Wed Feb 29 14:04:02 2012 +0200 summary: #14089: increase coverage of the fractions module. Patch by Oleg Plakhotnyuk. files: Lib/test/test_fractions.py | 20 +++++++++++++++++++- 1 files changed, 19 insertions(+), 1 deletions(-) diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py --- a/Lib/test/test_fractions.py +++ b/Lib/test/test_fractions.py @@ -6,6 +6,7 @@ import numbers import operator import fractions +import sys import unittest from copy import copy, deepcopy from cPickle import dumps, loads @@ -88,6 +89,9 @@ __hash__ = None +class DummyFraction(fractions.Fraction): + """Dummy Fraction subclass for copy and deepcopy testing.""" + class GcdTest(unittest.TestCase): def testMisc(self): @@ -301,11 +305,15 @@ self.assertEqual(F(201, 200).limit_denominator(100), F(1)) self.assertEqual(F(201, 200).limit_denominator(101), F(102, 101)) self.assertEqual(F(0).limit_denominator(10000), F(0)) + for i in (0, -1): + self.assertRaisesMessage( + ValueError, "max_denominator should be at least 1", + F(1).limit_denominator, i) def testConversions(self): self.assertTypedEquals(-1, math.trunc(F(-11, 10))) self.assertTypedEquals(-1, int(F(-11, 10))) - + self.assertTypedEquals(1, math.trunc(F(11, 10))) self.assertEqual(False, bool(F(0, 1))) self.assertEqual(True, bool(F(3, 2))) self.assertTypedEquals(0.1, float(F(1, 10))) @@ -330,6 +338,7 @@ self.assertEqual(F(8, 27), F(2, 3) ** F(3)) self.assertEqual(F(27, 8), F(2, 3) ** F(-3)) self.assertTypedEquals(2.0, F(4) ** F(1, 2)) + self.assertEqual(F(1, 1), +F(1, 1)) # Will return 1j in 3.0: self.assertRaises(ValueError, pow, F(-1), F(1, 2)) @@ -394,6 +403,10 @@ TypeError, "unsupported operand type(s) for +: 'Fraction' and 'Decimal'", operator.add, F(3,11), Decimal('3.1415926')) + self.assertRaisesMessage( + TypeError, + "unsupported operand type(s) for +: 'Decimal' and 'Fraction'", + operator.add, Decimal('3.1415926'), F(3,11)) self.assertNotEqual(F(5, 2), Decimal('2.5')) def testComparisons(self): @@ -571,9 +584,14 @@ def test_copy_deepcopy_pickle(self): r = F(13, 7) + dr = DummyFraction(13, 7) self.assertEqual(r, loads(dumps(r))) self.assertEqual(id(r), id(copy(r))) self.assertEqual(id(r), id(deepcopy(r))) + self.assertNotEqual(id(dr), id(copy(dr))) + self.assertNotEqual(id(dr), id(deepcopy(dr))) + self.assertTypedEquals(dr, copy(dr)) + self.assertTypedEquals(dr, deepcopy(dr)) def test_slots(self): # Issue 4998 -- Repository URL: http://hg.python.org/cpython

1 0

cpython (3.2): #14089: increase coverage of the fractions module. Patch by Oleg Plakhotnyuk.
by ezio.melotti 29 Feb '12

29 Feb '12

http://hg.python.org/cpython/rev/0bbc2549e1ee changeset: 75346:0bbc2549e1ee branch: 3.2 parent: 75343:4114e816a71b user: Ezio Melotti <ezio.melotti(a)gmail.com> date: Wed Feb 29 14:05:53 2012 +0200 summary: #14089: increase coverage of the fractions module. Patch by Oleg Plakhotnyuk. files: Lib/test/test_fractions.py | 22 ++++++++++++++++++++++ 1 files changed, 22 insertions(+), 0 deletions(-) diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py --- a/Lib/test/test_fractions.py +++ b/Lib/test/test_fractions.py @@ -6,6 +6,7 @@ import numbers import operator import fractions +import sys import unittest from copy import copy, deepcopy from pickle import dumps, loads @@ -76,6 +77,9 @@ def __float__(self): assert False, "__float__ should not be invoked" +class DummyFraction(fractions.Fraction): + """Dummy Fraction subclass for copy and deepcopy testing.""" + class GcdTest(unittest.TestCase): def testMisc(self): @@ -286,9 +290,14 @@ self.assertEqual(F(201, 200).limit_denominator(100), F(1)) self.assertEqual(F(201, 200).limit_denominator(101), F(102, 101)) self.assertEqual(F(0).limit_denominator(10000), F(0)) + for i in (0, -1): + self.assertRaisesMessage( + ValueError, "max_denominator should be at least 1", + F(1).limit_denominator, i) def testConversions(self): self.assertTypedEquals(-1, math.trunc(F(-11, 10))) + self.assertTypedEquals(1, math.trunc(F(11, 10))) self.assertTypedEquals(-2, math.floor(F(-11, 10))) self.assertTypedEquals(-1, math.ceil(F(-11, 10))) self.assertTypedEquals(-1, math.ceil(F(-10, 10))) @@ -329,6 +338,7 @@ self.assertEqual(F(8, 27), F(2, 3) ** F(3)) self.assertEqual(F(27, 8), F(2, 3) ** F(-3)) self.assertTypedEquals(2.0, F(4) ** F(1, 2)) + self.assertEqual(F(1, 1), +F(1, 1)) z = pow(F(-1), F(1, 2)) self.assertAlmostEqual(z.real, 0) self.assertEqual(z.imag, 1) @@ -395,6 +405,10 @@ TypeError, "unsupported operand type(s) for +: 'Fraction' and 'Decimal'", operator.add, F(3,11), Decimal('3.1415926')) + self.assertRaisesMessage( + TypeError, + "unsupported operand type(s) for +: 'Decimal' and 'Fraction'", + operator.add, Decimal('3.1415926'), F(3,11)) def testComparisons(self): self.assertTrue(F(1, 2) < F(2, 3)) @@ -538,9 +552,12 @@ self.assertEqual("7", str(F(7, 1))) def testHash(self): + hmod = sys.hash_info.modulus + hinf = sys.hash_info.inf self.assertEqual(hash(2.5), hash(F(5, 2))) self.assertEqual(hash(10**50), hash(F(10**50))) self.assertNotEqual(hash(float(10**23)), hash(F(10**23))) + self.assertEqual(hinf, hash(F(1, hmod))) # Check that __hash__ produces the same value as hash(), for # consistency with int and Decimal. (See issue #10356.) self.assertEqual(hash(F(-1)), F(-1).__hash__()) @@ -574,9 +591,14 @@ def test_copy_deepcopy_pickle(self): r = F(13, 7) + dr = DummyFraction(13, 7) self.assertEqual(r, loads(dumps(r))) self.assertEqual(id(r), id(copy(r))) self.assertEqual(id(r), id(deepcopy(r))) + self.assertNotEqual(id(dr), id(copy(dr))) + self.assertNotEqual(id(dr), id(deepcopy(dr))) + self.assertTypedEquals(dr, copy(dr)) + self.assertTypedEquals(dr, deepcopy(dr)) def test_slots(self): # Issue 4998 -- Repository URL: http://hg.python.org/cpython

1 0

cpython (merge 3.2 -> default): #14155: merge with 3.2.
by ezio.melotti 29 Feb '12

29 Feb '12

http://hg.python.org/cpython/rev/457c3c0cb0a0 changeset: 75344:457c3c0cb0a0 parent: 75341:b78ca038e468 parent: 75343:4114e816a71b user: Ezio Melotti <ezio.melotti(a)gmail.com> date: Wed Feb 29 13:40:11 2012 +0200 summary: #14155: merge with 3.2. files: Doc/library/re.rst | 81 ++++++++++++--------------------- 1 files changed, 29 insertions(+), 52 deletions(-) diff --git a/Doc/library/re.rst b/Doc/library/re.rst --- a/Doc/library/re.rst +++ b/Doc/library/re.rst @@ -423,31 +423,6 @@ three digits in length. -.. _matching-searching: - -Matching vs. Searching ----------------------- - -.. sectionauthor:: Fred L. Drake, Jr. <fdrake(a)acm.org> - - -Python offers two different primitive operations based on regular expressions: -**match** checks for a match only at the beginning of the string, while -**search** checks for a match anywhere in the string (this is what Perl does -by default). - -Note that match may differ from search even when using a regular expression -beginning with ``'^'``: ``'^'`` matches only at the start of the string, or in -:const:`MULTILINE` mode also immediately following a newline. The "match" -operation succeeds only if the pattern matches at the start of the string -regardless of mode, or at the starting position given by the optional *pos* -argument regardless of whether a newline precedes it. - - >>> re.match("c", "abcdef") # No match - >>> re.search("c", "abcdef") # Match - <_sre.SRE_Match object at ...> - - .. _contents-of-module-re: Module Contents @@ -581,10 +556,11 @@ <match-objects>`. Return ``None`` if the string does not match the pattern; note that this is different from a zero-length match. - .. note:: + Note that even in :const:`MULTILINE` mode, :func:`re.match` will only match + at the beginning of the string and not at the beginning of each line. - If you want to locate a match anywhere in *string*, use :func:`search` - instead. + If you want to locate a match anywhere in *string*, use :func:`search` + instead (see also :ref:`search-vs-match`). .. function:: split(pattern, string, maxsplit=0, flags=0) @@ -771,16 +747,14 @@ The optional *pos* and *endpos* parameters have the same meaning as for the :meth:`~regex.search` method. - .. note:: - - If you want to locate a match anywhere in *string*, use - :meth:`~regex.search` instead. - >>> pattern = re.compile("o") >>> pattern.match("dog") # No match as "o" is not at the start of "dog". >>> pattern.match("dog", 1) # Match as "o" is the 2nd character of "dog". <_sre.SRE_Match object at ...> + If you want to locate a match anywhere in *string*, use + :meth:`~regex.search` instead (see also :ref:`search-vs-match`). + .. method:: regex.split(string, maxsplit=0) @@ -1142,37 +1116,39 @@ [a-zA-Z0-9_ ]*?end``. As a further benefit, such regular expressions will run faster than their recursive equivalents. +.. _search-vs-match: search() vs. match() ^^^^^^^^^^^^^^^^^^^^ -In a nutshell, :func:`match` only attempts to match a pattern at the beginning -of a string where :func:`search` will match a pattern anywhere in a string. -For example: +.. sectionauthor:: Fred L. Drake, Jr. <fdrake(a)acm.org> - >>> re.match("o", "dog") # No match as "o" is not the first letter of "dog". - >>> re.search("o", "dog") # Match as search() looks everywhere in the string. +Python offers two different primitive operations based on regular expressions: +:func:`re.match` checks for a match only at the beginning of the string, while +:func:`re.search` checks for a match anywhere in the string (this is what Perl +does by default). + +For example:: + + >>> re.match("c", "abcdef") # No match + >>> re.search("c", "abcdef") # Match <_sre.SRE_Match object at ...> -.. note:: +Regular expressions beginning with ``'^'`` can be used with :func:`search` to +restrict the match at the beginning of the string:: - The following applies only to regular expression objects like those created - with ``re.compile("pattern")``, not the primitives ``re.match(pattern, - string)`` or ``re.search(pattern, string)``. + >>> re.match("c", "abcdef") # No match + >>> re.search("^c", "abcdef") # No match + >>> re.search("^a", "abcdef") # Match + <_sre.SRE_Match object at ...> -:func:`match` has an optional second parameter that gives an index in the string -where the search is to start:: +Note however that in :const:`MULTILINE` mode :func:`match` only matches at the +beginning of the string, whereas using :func:`search` with a regular expression +beginning with ``'^'`` will match at the beginning of each line. - >>> pattern = re.compile("o") - >>> pattern.match("dog") # No match as "o" is not at the start of "dog." - - # Equivalent to the above expression as 0 is the default starting index: - >>> pattern.match("dog", 0) - - # Match as "o" is the 2nd character of "dog" (index 0 is the first): - >>> pattern.match("dog", 1) + >>> re.match('X', 'A\nB\nX', re.MULTILINE) # No match + >>> re.search('^X', 'A\nB\nX', re.MULTILINE) # Match <_sre.SRE_Match object at ...> - >>> pattern.match("dog", 2) # No match as "o" is not the 3rd character of "dog." Making a Phonebook -- Repository URL: http://hg.python.org/cpython

1 0

cpython (3.2): #14155: remove duplication about search vs match in re doc.
by ezio.melotti 29 Feb '12

29 Feb '12

http://hg.python.org/cpython/rev/4114e816a71b changeset: 75343:4114e816a71b branch: 3.2 parent: 75340:cde7fa40b289 user: Ezio Melotti <ezio.melotti(a)gmail.com> date: Wed Feb 29 13:39:05 2012 +0200 summary: #14155: remove duplication about search vs match in re doc. files: Doc/library/re.rst | 81 ++++++++++++--------------------- 1 files changed, 29 insertions(+), 52 deletions(-) diff --git a/Doc/library/re.rst b/Doc/library/re.rst --- a/Doc/library/re.rst +++ b/Doc/library/re.rst @@ -423,31 +423,6 @@ three digits in length. -.. _matching-searching: - -Matching vs. Searching ----------------------- - -.. sectionauthor:: Fred L. Drake, Jr. <fdrake(a)acm.org> - - -Python offers two different primitive operations based on regular expressions: -**match** checks for a match only at the beginning of the string, while -**search** checks for a match anywhere in the string (this is what Perl does -by default). - -Note that match may differ from search even when using a regular expression -beginning with ``'^'``: ``'^'`` matches only at the start of the string, or in -:const:`MULTILINE` mode also immediately following a newline. The "match" -operation succeeds only if the pattern matches at the start of the string -regardless of mode, or at the starting position given by the optional *pos* -argument regardless of whether a newline precedes it. - - >>> re.match("c", "abcdef") # No match - >>> re.search("c", "abcdef") # Match - <_sre.SRE_Match object at ...> - - .. _contents-of-module-re: Module Contents @@ -581,10 +556,11 @@ <match-objects>`. Return ``None`` if the string does not match the pattern; note that this is different from a zero-length match. - .. note:: + Note that even in :const:`MULTILINE` mode, :func:`re.match` will only match + at the beginning of the string and not at the beginning of each line. - If you want to locate a match anywhere in *string*, use :func:`search` - instead. + If you want to locate a match anywhere in *string*, use :func:`search` + instead (see also :ref:`search-vs-match`). .. function:: split(pattern, string, maxsplit=0, flags=0) @@ -768,16 +744,14 @@ The optional *pos* and *endpos* parameters have the same meaning as for the :meth:`~regex.search` method. - .. note:: - - If you want to locate a match anywhere in *string*, use - :meth:`~regex.search` instead. - >>> pattern = re.compile("o") >>> pattern.match("dog") # No match as "o" is not at the start of "dog". >>> pattern.match("dog", 1) # Match as "o" is the 2nd character of "dog". <_sre.SRE_Match object at ...> + If you want to locate a match anywhere in *string*, use + :meth:`~regex.search` instead (see also :ref:`search-vs-match`). + .. method:: regex.split(string, maxsplit=0) @@ -1139,37 +1113,39 @@ [a-zA-Z0-9_ ]*?end``. As a further benefit, such regular expressions will run faster than their recursive equivalents. +.. _search-vs-match: search() vs. match() ^^^^^^^^^^^^^^^^^^^^ -In a nutshell, :func:`match` only attempts to match a pattern at the beginning -of a string where :func:`search` will match a pattern anywhere in a string. -For example: +.. sectionauthor:: Fred L. Drake, Jr. <fdrake(a)acm.org> - >>> re.match("o", "dog") # No match as "o" is not the first letter of "dog". - >>> re.search("o", "dog") # Match as search() looks everywhere in the string. +Python offers two different primitive operations based on regular expressions: +:func:`re.match` checks for a match only at the beginning of the string, while +:func:`re.search` checks for a match anywhere in the string (this is what Perl +does by default). + +For example:: + + >>> re.match("c", "abcdef") # No match + >>> re.search("c", "abcdef") # Match <_sre.SRE_Match object at ...> -.. note:: +Regular expressions beginning with ``'^'`` can be used with :func:`search` to +restrict the match at the beginning of the string:: - The following applies only to regular expression objects like those created - with ``re.compile("pattern")``, not the primitives ``re.match(pattern, - string)`` or ``re.search(pattern, string)``. + >>> re.match("c", "abcdef") # No match + >>> re.search("^c", "abcdef") # No match + >>> re.search("^a", "abcdef") # Match + <_sre.SRE_Match object at ...> -:func:`match` has an optional second parameter that gives an index in the string -where the search is to start:: +Note however that in :const:`MULTILINE` mode :func:`match` only matches at the +beginning of the string, whereas using :func:`search` with a regular expression +beginning with ``'^'`` will match at the beginning of each line. - >>> pattern = re.compile("o") - >>> pattern.match("dog") # No match as "o" is not at the start of "dog." - - # Equivalent to the above expression as 0 is the default starting index: - >>> pattern.match("dog", 0) - - # Match as "o" is the 2nd character of "dog" (index 0 is the first): - >>> pattern.match("dog", 1) + >>> re.match('X', 'A\nB\nX', re.MULTILINE) # No match + >>> re.search('^X', 'A\nB\nX', re.MULTILINE) # Match <_sre.SRE_Match object at ...> - >>> pattern.match("dog", 2) # No match as "o" is not the 3rd character of "dog." Making a Phonebook -- Repository URL: http://hg.python.org/cpython

1 0

cpython (2.7): #14155: remove duplication about search vs match in re doc.
by ezio.melotti 29 Feb '12

29 Feb '12

http://hg.python.org/cpython/rev/3958121a027f changeset: 75342:3958121a027f branch: 2.7 parent: 75339:fc89e09ca2fc user: Ezio Melotti <ezio.melotti(a)gmail.com> date: Wed Feb 29 13:37:07 2012 +0200 summary: #14155: remove duplication about search vs match in re doc. files: Doc/library/re.rst | 81 ++++++++++++--------------------- 1 files changed, 29 insertions(+), 52 deletions(-) diff --git a/Doc/library/re.rst b/Doc/library/re.rst --- a/Doc/library/re.rst +++ b/Doc/library/re.rst @@ -400,31 +400,6 @@ three digits in length. -.. _matching-searching: - -Matching vs Searching ---------------------- - -.. sectionauthor:: Fred L. Drake, Jr. <fdrake(a)acm.org> - - -Python offers two different primitive operations based on regular expressions: -**match** checks for a match only at the beginning of the string, while -**search** checks for a match anywhere in the string (this is what Perl does -by default). - -Note that match may differ from search even when using a regular expression -beginning with ``'^'``: ``'^'`` matches only at the start of the string, or in -:const:`MULTILINE` mode also immediately following a newline. The "match" -operation succeeds only if the pattern matches at the start of the string -regardless of mode, or at the starting position given by the optional *pos* -argument regardless of whether a newline precedes it. - - >>> re.match("c", "abcdef") # No match - >>> re.search("c", "abcdef") # Match - <_sre.SRE_Match object at ...> - - .. _contents-of-module-re: Module Contents @@ -547,10 +522,11 @@ Return ``None`` if the string does not match the pattern; note that this is different from a zero-length match. - .. note:: + Note that even in :const:`MULTILINE` mode, :func:`re.match` will only match + at the beginning of the string and not at the beginning of each line. - If you want to locate a match anywhere in *string*, use :func:`search` - instead. + If you want to locate a match anywhere in *string*, use :func:`search` + instead (see also :ref:`search-vs-match`). .. function:: split(pattern, string, maxsplit=0, flags=0) @@ -746,16 +722,14 @@ The optional *pos* and *endpos* parameters have the same meaning as for the :meth:`~RegexObject.search` method. - .. note:: - - If you want to locate a match anywhere in *string*, use - :meth:`~RegexObject.search` instead. - >>> pattern = re.compile("o") >>> pattern.match("dog") # No match as "o" is not at the start of "dog". >>> pattern.match("dog", 1) # Match as "o" is the 2nd character of "dog". <_sre.SRE_Match object at ...> + If you want to locate a match anywhere in *string*, use + :meth:`~RegexObject.search` instead (see also :ref:`search-vs-match`). + .. method:: RegexObject.split(string, maxsplit=0) @@ -1121,37 +1095,39 @@ being recast as ``Begin [a-zA-Z0-9_ ]*?end``. As a further benefit, such regular expressions will run faster than their recursive equivalents. +.. _search-vs-match: search() vs. match() ^^^^^^^^^^^^^^^^^^^^ -In a nutshell, :func:`match` only attempts to match a pattern at the beginning -of a string where :func:`search` will match a pattern anywhere in a string. -For example: +.. sectionauthor:: Fred L. Drake, Jr. <fdrake(a)acm.org> - >>> re.match("o", "dog") # No match as "o" is not the first letter of "dog". - >>> re.search("o", "dog") # Match as search() looks everywhere in the string. +Python offers two different primitive operations based on regular expressions: +:func:`re.match` checks for a match only at the beginning of the string, while +:func:`re.search` checks for a match anywhere in the string (this is what Perl +does by default). + +For example:: + + >>> re.match("c", "abcdef") # No match + >>> re.search("c", "abcdef") # Match <_sre.SRE_Match object at ...> -.. note:: +Regular expressions beginning with ``'^'`` can be used with :func:`search` to +restrict the match at the beginning of the string:: - The following applies only to regular expression objects like those created - with ``re.compile("pattern")``, not the primitives ``re.match(pattern, - string)`` or ``re.search(pattern, string)``. + >>> re.match("c", "abcdef") # No match + >>> re.search("^c", "abcdef") # No match + >>> re.search("^a", "abcdef") # Match + <_sre.SRE_Match object at ...> -:func:`match` has an optional second parameter that gives an index in the string -where the search is to start:: +Note however that in :const:`MULTILINE` mode :func:`match` only matches at the +beginning of the string, whereas using :func:`search` with a regular expression +beginning with ``'^'`` will match at the beginning of each line. - >>> pattern = re.compile("o") - >>> pattern.match("dog") # No match as "o" is not at the start of "dog." - - # Equivalent to the above expression as 0 is the default starting index: - >>> pattern.match("dog", 0) - - # Match as "o" is the 2nd character of "dog" (index 0 is the first): - >>> pattern.match("dog", 1) + >>> re.match('X', 'A\nB\nX', re.MULTILINE) # No match + >>> re.search('^X', 'A\nB\nX', re.MULTILINE) # Match <_sre.SRE_Match object at ...> - >>> pattern.match("dog", 2) # No match as "o" is not the 3rd character of "dog." Making a Phonebook -- Repository URL: http://hg.python.org/cpython

1 0

cpython (merge 3.2 -> default): #10713: merge with 3.2.
by ezio.melotti 29 Feb '12

29 Feb '12

http://hg.python.org/cpython/rev/b78ca038e468 changeset: 75341:b78ca038e468 parent: 75338:c316e8a4a5e2 parent: 75340:cde7fa40b289 user: Ezio Melotti <ezio.melotti(a)gmail.com> date: Wed Feb 29 11:49:45 2012 +0200 summary: #10713: merge with 3.2. files: Doc/library/re.rst | 22 ++++++++++++++-------- Lib/test/test_re.py | 26 ++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 8 deletions(-) diff --git a/Doc/library/re.rst b/Doc/library/re.rst --- a/Doc/library/re.rst +++ b/Doc/library/re.rst @@ -330,16 +330,22 @@ Matches the empty string, but only at the beginning or end of a word. A word is defined as a sequence of Unicode alphanumeric or underscore characters, so the end of a word is indicated by whitespace or a - non-alphanumeric, non-underscore Unicode character. Note that - formally, ``\b`` is defined as the boundary between a ``\w`` and a - ``\W`` character (or vice versa). By default Unicode alphanumerics - are the ones used, but this can be changed by using the :const:`ASCII` - flag. Inside a character range, ``\b`` represents the backspace - character, for compatibility with Python's string literals. + non-alphanumeric, non-underscore Unicode character. Note that formally, + ``\b`` is defined as the boundary between a ``\w`` and a ``\W`` character + (or vice versa), or between ``\w`` and the beginning/end of the string. + This means that ``r'\bfoo\b'`` matches ``'foo'``, ``'foo.'``, ``'(foo)'``, + ``'bar foo baz'`` but not ``'foobar'`` or ``'foo3'``. + + By default Unicode alphanumerics are the ones used, but this can be changed + by using the :const:`ASCII` flag. Inside a character range, ``\b`` + represents the backspace character, for compatibility with Python's string + literals. ``\B`` - Matches the empty string, but only when it is *not* at the beginning or end of a - word. This is just the opposite of ``\b``, so word characters are + Matches the empty string, but only when it is *not* at the beginning or end + of a word. This means that ``r'py\B'`` matches ``'python'``, ``'py3'``, + ``'py2'``, but not ``'py'``, ``'py.'``, or ``'py!'``. + ``\B`` is just the opposite of ``\b``, so word characters are Unicode alphanumerics or the underscore, although this can be changed by using the :const:`ASCII` flag. diff --git a/Lib/test/test_re.py b/Lib/test/test_re.py --- a/Lib/test/test_re.py +++ b/Lib/test/test_re.py @@ -355,6 +355,32 @@ self.assertEqual(re.search(r"\d\D\w\W\s\S", "1aa! a", re.UNICODE).group(0), "1aa! a") + def test_string_boundaries(self): + # See http://bugs.python.org/issue10713 + self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1), + "abc") + # There's a word boundary at the start of a string. + self.assertTrue(re.match(r"\b", "abc")) + # A non-empty string includes a non-boundary zero-length match. + self.assertTrue(re.search(r"\B", "abc")) + # There is no non-boundary match at the start of a string. + self.assertFalse(re.match(r"\B", "abc")) + # However, an empty string contains no word boundaries, and also no + # non-boundaries. + self.assertEqual(re.search(r"\B", ""), None) + # This one is questionable and different from the perlre behaviour, + # but describes current behavior. + self.assertEqual(re.search(r"\b", ""), None) + # A single word-character string has two boundaries, but no + # non-boundary gaps. + self.assertEqual(len(re.findall(r"\b", "a")), 2) + self.assertEqual(len(re.findall(r"\B", "a")), 0) + # If there are no words, there are no boundaries + self.assertEqual(len(re.findall(r"\b", " ")), 0) + self.assertEqual(len(re.findall(r"\b", " ")), 0) + # Can match around the whitespace. + self.assertEqual(len(re.findall(r"\B", " ")), 2) + def test_bigcharset(self): self.assertEqual(re.match("([\u2222\u2223])", "\u2222").group(1), "\u2222") -- Repository URL: http://hg.python.org/cpython

1 0

cpython (3.2): #10713: Improve documentation for \b and \B and add a few tests. Initial patch
by ezio.melotti 29 Feb '12

29 Feb '12

http://hg.python.org/cpython/rev/cde7fa40b289 changeset: 75340:cde7fa40b289 branch: 3.2 parent: 75337:28849d00a41e user: Ezio Melotti <ezio.melotti(a)gmail.com> date: Wed Feb 29 11:48:44 2012 +0200 summary: #10713: Improve documentation for \b and \B and add a few tests. Initial patch and tests by Martin Pool. files: Doc/library/re.rst | 22 ++++++++++++++-------- Lib/test/test_re.py | 26 ++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 8 deletions(-) diff --git a/Doc/library/re.rst b/Doc/library/re.rst --- a/Doc/library/re.rst +++ b/Doc/library/re.rst @@ -330,16 +330,22 @@ Matches the empty string, but only at the beginning or end of a word. A word is defined as a sequence of Unicode alphanumeric or underscore characters, so the end of a word is indicated by whitespace or a - non-alphanumeric, non-underscore Unicode character. Note that - formally, ``\b`` is defined as the boundary between a ``\w`` and a - ``\W`` character (or vice versa). By default Unicode alphanumerics - are the ones used, but this can be changed by using the :const:`ASCII` - flag. Inside a character range, ``\b`` represents the backspace - character, for compatibility with Python's string literals. + non-alphanumeric, non-underscore Unicode character. Note that formally, + ``\b`` is defined as the boundary between a ``\w`` and a ``\W`` character + (or vice versa), or between ``\w`` and the beginning/end of the string. + This means that ``r'\bfoo\b'`` matches ``'foo'``, ``'foo.'``, ``'(foo)'``, + ``'bar foo baz'`` but not ``'foobar'`` or ``'foo3'``. + + By default Unicode alphanumerics are the ones used, but this can be changed + by using the :const:`ASCII` flag. Inside a character range, ``\b`` + represents the backspace character, for compatibility with Python's string + literals. ``\B`` - Matches the empty string, but only when it is *not* at the beginning or end of a - word. This is just the opposite of ``\b``, so word characters are + Matches the empty string, but only when it is *not* at the beginning or end + of a word. This means that ``r'py\B'`` matches ``'python'``, ``'py3'``, + ``'py2'``, but not ``'py'``, ``'py.'``, or ``'py!'``. + ``\B`` is just the opposite of ``\b``, so word characters are Unicode alphanumerics or the underscore, although this can be changed by using the :const:`ASCII` flag. diff --git a/Lib/test/test_re.py b/Lib/test/test_re.py --- a/Lib/test/test_re.py +++ b/Lib/test/test_re.py @@ -355,6 +355,32 @@ self.assertEqual(re.search(r"\d\D\w\W\s\S", "1aa! a", re.UNICODE).group(0), "1aa! a") + def test_string_boundaries(self): + # See http://bugs.python.org/issue10713 + self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1), + "abc") + # There's a word boundary at the start of a string. + self.assertTrue(re.match(r"\b", "abc")) + # A non-empty string includes a non-boundary zero-length match. + self.assertTrue(re.search(r"\B", "abc")) + # There is no non-boundary match at the start of a string. + self.assertFalse(re.match(r"\B", "abc")) + # However, an empty string contains no word boundaries, and also no + # non-boundaries. + self.assertEqual(re.search(r"\B", ""), None) + # This one is questionable and different from the perlre behaviour, + # but describes current behavior. + self.assertEqual(re.search(r"\b", ""), None) + # A single word-character string has two boundaries, but no + # non-boundary gaps. + self.assertEqual(len(re.findall(r"\b", "a")), 2) + self.assertEqual(len(re.findall(r"\B", "a")), 0) + # If there are no words, there are no boundaries + self.assertEqual(len(re.findall(r"\b", " ")), 0) + self.assertEqual(len(re.findall(r"\b", " ")), 0) + # Can match around the whitespace. + self.assertEqual(len(re.findall(r"\B", " ")), 2) + def test_bigcharset(self): self.assertEqual(re.match("([\u2222\u2223])", "\u2222").group(1), "\u2222") -- Repository URL: http://hg.python.org/cpython

1 0

cpython (2.7): #10713: Improve documentation for \b and \B and add a few tests. Initial patch
by ezio.melotti 29 Feb '12

29 Feb '12

http://hg.python.org/cpython/rev/fc89e09ca2fc changeset: 75339:fc89e09ca2fc branch: 2.7 parent: 75336:eb88cc90cc56 user: Ezio Melotti <ezio.melotti(a)gmail.com> date: Wed Feb 29 11:40:00 2012 +0200 summary: #10713: Improve documentation for \b and \B and add a few tests. Initial patch and tests by Martin Pool. files: Doc/library/re.rst | 15 ++++++++++----- Lib/test/test_re.py | 26 ++++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 5 deletions(-) diff --git a/Doc/library/re.rst b/Doc/library/re.rst --- a/Doc/library/re.rst +++ b/Doc/library/re.rst @@ -325,14 +325,19 @@ Matches the empty string, but only at the beginning or end of a word. A word is defined as a sequence of alphanumeric or underscore characters, so the end of a word is indicated by whitespace or a non-alphanumeric, non-underscore character. - Note that ``\b`` is defined as the boundary between ``\w`` and ``\W``, so the - precise set of characters deemed to be alphanumeric depends on the values of the - ``UNICODE`` and ``LOCALE`` flags. Inside a character range, ``\b`` represents - the backspace character, for compatibility with Python's string literals. + Note that formally, ``\b`` is defined as the boundary between a ``\w`` and + a ``\W`` character (or vice versa), or between ``\w`` and the beginning/end + of the string, so the precise set of characters deemed to be alphanumeric + depends on the values of the ``UNICODE`` and ``LOCALE`` flags. + For example, ``r'\bfoo\b'`` matches ``'foo'``, ``'foo.'``, ``'(foo)'``, + ``'bar foo baz'`` but not ``'foobar'`` or ``'foo3'``. + Inside a character range, ``\b`` represents the backspace character, for compatibility with Python's string literals. ``\B`` Matches the empty string, but only when it is *not* at the beginning or end of a - word. This is just the opposite of ``\b``, so is also subject to the settings + word. This means that ``r'py\B'`` matches ``'python'``, ``'py3'``, ``'py2'``, + but not ``'py'``, ``'py.'``, or ``'py!'``. + ``\B`` is just the opposite of ``\b``, so is also subject to the settings of ``LOCALE`` and ``UNICODE``. ``\d`` diff --git a/Lib/test/test_re.py b/Lib/test/test_re.py --- a/Lib/test/test_re.py +++ b/Lib/test/test_re.py @@ -373,6 +373,32 @@ self.assertEqual(re.search(r"\d\D\w\W\s\S", "1aa! a", re.UNICODE).group(0), "1aa! a") + def test_string_boundaries(self): + # See http://bugs.python.org/issue10713 + self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1), + "abc") + # There's a word boundary at the start of a string. + self.assertTrue(re.match(r"\b", "abc")) + # A non-empty string includes a non-boundary zero-length match. + self.assertTrue(re.search(r"\B", "abc")) + # There is no non-boundary match at the start of a string. + self.assertFalse(re.match(r"\B", "abc")) + # However, an empty string contains no word boundaries, and also no + # non-boundaries. + self.assertEqual(re.search(r"\B", ""), None) + # This one is questionable and different from the perlre behaviour, + # but describes current behavior. + self.assertEqual(re.search(r"\b", ""), None) + # A single word-character string has two boundaries, but no + # non-boundary gaps. + self.assertEqual(len(re.findall(r"\b", "a")), 2) + self.assertEqual(len(re.findall(r"\B", "a")), 0) + # If there are no words, there are no boundaries + self.assertEqual(len(re.findall(r"\b", " ")), 0) + self.assertEqual(len(re.findall(r"\b", " ")), 0) + # Can match around the whitespace. + self.assertEqual(len(re.findall(r"\B", " ")), 2) + def test_bigcharset(self): self.assertEqual(re.match(u"([\u2222\u2223])", u"\u2222").group(1), u"\u2222") -- Repository URL: http://hg.python.org/cpython

1 0

peps: Remove strange wording.
by eric.araujo 29 Feb '12

29 Feb '12

http://hg.python.org/peps/rev/1cba60d9977b changeset: 4099:1cba60d9977b user: Éric Araujo <merwok(a)netwok.org> date: Wed Feb 29 07:29:36 2012 +0100 summary: Remove strange wording. (“direct access” to the hg repo uses the same protocol than public browsing, so the distinction does not make sense anymore.) files: pep-0001.txt | 3 +-- 1 files changed, 1 insertions(+), 2 deletions(-) diff --git a/pep-0001.txt b/pep-0001.txt --- a/pep-0001.txt +++ b/pep-0001.txt @@ -461,8 +461,7 @@ ======================== .. [1] This historical record is available by the normal hg commands - for retrieving older revisions. For those without direct access to - the hg repo, you can browse the current and past PEP revisions here: + for retrieving older revisions, and can also be browsed via HTTP here: http://hg.python.org/peps/ .. [2] PEP 2, Procedure for Adding New Modules, Faassen -- Repository URL: http://hg.python.org/peps

1 0

peps: Add header required for Standard Tracks PEPs
by eric.araujo 29 Feb '12

29 Feb '12

http://hg.python.org/peps/rev/70bee9e3c5b9 changeset: 4098:70bee9e3c5b9 user: Éric Araujo <merwok(a)netwok.org> date: Wed Feb 29 07:28:24 2012 +0100 summary: Add header required for Standard Tracks PEPs files: pep-0410.txt | 1 + pep-0414.txt | 1 + 2 files changed, 2 insertions(+), 0 deletions(-) diff --git a/pep-0410.txt b/pep-0410.txt --- a/pep-0410.txt +++ b/pep-0410.txt @@ -8,6 +8,7 @@ Content-Type: text/x-rst Created: 01-February-2012 Python-Version: 3.3 +Resolution: http://mail.python.org/pipermail/python-dev/2012-February/116837.html Rejection Notice diff --git a/pep-0414.txt b/pep-0414.txt --- a/pep-0414.txt +++ b/pep-0414.txt @@ -8,6 +8,7 @@ Content-Type: text/x-rst Created: 15-Feb-2012 Post-History: 28-Feb-2012 +Resolution: http://mail.python.org/pipermail/python-dev/2012-February/116995.html Abstract -- Repository URL: http://hg.python.org/peps

1 0