svn+ssh://pythondev@svn.python.org/python/trunk
........
r65012 | jesse.noller | 2008-07-16 15:24:06 +0200 (Wed, 16 Jul 2008) | 2 lines
Apply patch for issue 3090: ARCHFLAGS parsing incorrect
........
r65035 | georg.brandl | 2008-07-16 23:19:28 +0200 (Wed, 16 Jul 2008) | 2 lines
#3045: fix pydoc behavior for TEMP path with spaces.
........
r65037 | georg.brandl | 2008-07-16 23:31:41 +0200 (Wed, 16 Jul 2008) | 2 lines
#
1608818: errno can get set by every call to readdir().
........
r65038 | georg.brandl | 2008-07-17 00:04:20 +0200 (Thu, 17 Jul 2008) | 2 lines
#3305: self->stream can be NULL.
........
r65039 | georg.brandl | 2008-07-17 00:09:17 +0200 (Thu, 17 Jul 2008) | 2 lines
#3345: fix docstring.
........
r65040 | georg.brandl | 2008-07-17 00:33:18 +0200 (Thu, 17 Jul 2008) | 2 lines
#3312: fix two sqlite3 crashes.
........
r65048 | georg.brandl | 2008-07-17 01:35:54 +0200 (Thu, 17 Jul 2008) | 2 lines
#3388: add a paragraph about using "with" for file objects.
........
r65057 | gregory.p.smith | 2008-07-17 05:13:05 +0200 (Thu, 17 Jul 2008) | 2 lines
news note for r63052
........
r65077 | jesse.noller | 2008-07-17 23:01:05 +0200 (Thu, 17 Jul 2008) | 3 lines
Fix issue 3395, update _debugInfo to be _debug_info
........
r65091 | ronald.oussoren | 2008-07-18 07:48:03 +0200 (Fri, 18 Jul 2008) | 2 lines
Last bit of a fix for issue3381 (addon for my patch in r65061)
........
r65092 | vinay.sajip | 2008-07-18 10:59:06 +0200 (Fri, 18 Jul 2008) | 1 line
Issue #3389: Allow resolving dotted names for handlers in logging configuration files. Thanks to Philip Jenvey for the patch.
........
r65093 | vinay.sajip | 2008-07-18 11:00:00 +0200 (Fri, 18 Jul 2008) | 1 line
Issue #3389: Allow resolving dotted names for handlers in logging configuration files. Thanks to Philip Jenvey for the patch.
........
r65094 | vinay.sajip | 2008-07-18 11:00:35 +0200 (Fri, 18 Jul 2008) | 1 line
Issue #3389: Allow resolving dotted names for handlers in logging configuration files. Thanks to Philip Jenvey for the patch.
........
r65095 | vinay.sajip | 2008-07-18 11:01:10 +0200 (Fri, 18 Jul 2008) | 1 line
Issue #3389: Allow resolving dotted names for handlers in logging configuration files. Thanks to Philip Jenvey for the patch.
........
r65097 | georg.brandl | 2008-07-18 12:20:59 +0200 (Fri, 18 Jul 2008) | 2 lines
Remove duplicate entry in __all__.
........
r65098 | georg.brandl | 2008-07-18 12:29:30 +0200 (Fri, 18 Jul 2008) | 2 lines
Correct attribute name.
........
r65099 | georg.brandl | 2008-07-18 13:15:06 +0200 (Fri, 18 Jul 2008) | 3 lines
Document the different meaning of precision for {:f} and {:g}.
Also document how inf and nan are formatted. #3404.
........
r65127 | raymond.hettinger | 2008-07-19 02:42:03 +0200 (Sat, 19 Jul 2008) | 1 line
Improve accuracy of gamma test function
........
r65128 | raymond.hettinger | 2008-07-19 02:43:00 +0200 (Sat, 19 Jul 2008) | 1 line
Add recipe to the itertools docs.
........
r65131 | georg.brandl | 2008-07-19 12:08:55 +0200 (Sat, 19 Jul 2008) | 2 lines
#3378: in case of no memory, don't leak even more memory. :)
........
r65133 | georg.brandl | 2008-07-19 14:39:10 +0200 (Sat, 19 Jul 2008) | 3 lines
#3302: fix segfaults when passing None for arguments that can't
be NULL for the C functions.
........
r65134 | georg.brandl | 2008-07-19 14:46:12 +0200 (Sat, 19 Jul 2008) | 2 lines
#3303: fix crash with invalid Py_DECREF in strcoll().
........
r65135 | georg.brandl | 2008-07-19 15:00:22 +0200 (Sat, 19 Jul 2008) | 3 lines
#3319: don't raise ZeroDivisionError if number of rounds is so
low that benchtime is zero.
........
r65136 | georg.brandl | 2008-07-19 15:09:42 +0200 (Sat, 19 Jul 2008) | 3 lines
#3323: mention that if inheriting from a class without __slots__,
the subclass will have a __dict__ available too.
........
r65139 | georg.brandl | 2008-07-19 15:48:44 +0200 (Sat, 19 Jul 2008) | 2 lines
Add ordering info for findall and finditer.
........
r65149 | raymond.hettinger | 2008-07-20 01:21:57 +0200 (Sun, 20 Jul 2008) | 1 line
Fix compress() recipe in docs to use itertools.
........
r65150 | raymond.hettinger | 2008-07-20 01:58:47 +0200 (Sun, 20 Jul 2008) | 1 line
Clean-up itertools docs and recipes.
........
r65151 | gregory.p.smith | 2008-07-20 02:22:08 +0200 (Sun, 20 Jul 2008) | 9 lines
fix issue3120 - don't truncate handles on 64-bit Windows.
This is still messy, realistically PC/_subprocess.c should never cast pointers
to python numbers and back at all.
I don't have a 64-bit windows build environment because microsoft apparently
thinks that should cost money. Time to watch the buildbots. It builds and
passes tests on 32-bit windows.
........
r65155 | georg.brandl | 2008-07-20 13:50:29 +0200 (Sun, 20 Jul 2008) | 2 lines
#926501: add info where to put the docstring.
........
r65158 | neal.norwitz | 2008-07-20 21:35:23 +0200 (Sun, 20 Jul 2008) | 1 line
Fix a couple of names in error messages that were wrong
........
r65159 | neal.norwitz | 2008-07-20 22:39:36 +0200 (Sun, 20 Jul 2008) | 1 line
Fix misspeeld method name (negative)
........
r65176 | amaury.forgeotdarc | 2008-07-21 23:36:24 +0200 (Mon, 21 Jul 2008) | 4 lines
Increment version number in NEWS file, and move items that were added after 2.6b2.
(I thought there was a script to automate this kind of updates)
........
r65177 | amaury.forgeotdarc | 2008-07-22 00:00:38 +0200 (Tue, 22 Jul 2008) | 5 lines
Issue2378: pdb would delete free variables when stepping into a class statement.
The problem was introduced by r53954, the correction is to restore the symmetry between
PyFrame_FastToLocals and PyFrame_LocalsToFast
........
r65178 | benjamin.peterson | 2008-07-22 00:05:34 +0200 (Tue, 22 Jul 2008) | 1 line
don't use assert statement
........
r65183 | ronald.oussoren | 2008-07-22 09:06:00 +0200 (Tue, 22 Jul 2008) | 2 lines
Fix buglet in fix for issue3381
........
r65184 | ronald.oussoren | 2008-07-22 09:06:33 +0200 (Tue, 22 Jul 2008) | 2 lines
Fix build issue on OSX 10.4, somehow this wasn't committed before.
........
r65187 | raymond.hettinger | 2008-07-22 20:54:02 +0200 (Tue, 22 Jul 2008) | 1 line
Remove out-of-date section on Exact/Inexact.
........
r65188 | raymond.hettinger | 2008-07-22 21:00:47 +0200 (Tue, 22 Jul 2008) | 1 line
Tuples now have both count() and index().
........
r65189 | raymond.hettinger | 2008-07-22 21:03:05 +0200 (Tue, 22 Jul 2008) | 1 line
Fix credits for math.sum()
........
r65190 | raymond.hettinger | 2008-07-22 21:18:50 +0200 (Tue, 22 Jul 2008) | 1 line
One more attribution.
........
r65192 | benjamin.peterson | 2008-07-23 01:44:37 +0200 (Wed, 23 Jul 2008) | 1 line
remove unneeded import
........
r65194 | benjamin.peterson | 2008-07-23 15:25:06 +0200 (Wed, 23 Jul 2008) | 1 line
use isinstance
........
of :class:`dict` much resembles that for :class:`list`, but the keys can
be any object with a :meth:`__hash__` function, not just integers starting
from zero. Called a hash in Perl.
+
+ docstring
+ A docstring ("documentation string") is a string literal that appears as
+ the first thing in a class or function suite. While ignored when the
+ suite is executed, it is recognized by the compiler and put into the
+ :attr:`__doc__` attribute of the class or function. Since it is available
+ via introspection, it is the canonical place for documentation of the
+ object.
duck-typing
Pythonic programming style that determines an object's type by inspection
Likewise, the functional tools are designed to work well with the high-speed
functions provided by the :mod:`operator` module.
-The module author welcomes suggestions for other basic building blocks to be
-added to future versions of the module.
-
Whether cast in pure python form or compiled code, tools that use iterators are
-more memory efficient (and faster) than their list based counterparts. Adopting
+more memory efficient (and often faster) than their list based counterparts. Adopting
the principles of just-in-time manufacturing, they create data when and where
needed instead of consuming memory with the computer equivalent of "inventory".
-The performance advantage of iterators becomes more acute as the number of
-elements increases -- at some point, lists grow large enough to severely impact
-memory cache performance and start running slowly.
-
.. seealso::
.. testcode::
- def take(n, seq):
- return list(islice(seq, n))
+ def take(n, iterable):
+ "Return first n items of the iterable as a list"
+ return list(islice(iterable, n))
- def enumerate(iterable):
- return zip(count(), iterable)
+ def enumerate(iterable, start=0):
+ return zip(count(start), iterable)
- def tabulate(function):
+ def tabulate(function, start=0):
"Return function(0), function(1), ..."
- return map(function, count())
-
- def items(mapping):
- return zip(mapping.keys(), mapping.values())
+ return map(function, count(start))
def nth(iterable, n):
- "Returns the nth item or raise StopIteration"
- return next(islice(iterable, n, None))
-
- def all(seq, pred=None):
- "Returns True if pred(x) is true for every element in the iterable"
- for elem in filterfalse(pred, seq):
- return False
- return True
-
- def any(seq, pred=None):
- "Returns True if pred(x) is true for at least one element in the iterable"
- for elem in filter(pred, seq):
- return True
- return False
-
- def no(seq, pred=None):
- "Returns True if pred(x) is false for every element in the iterable"
- for elem in filter(pred, seq):
- return False
- return True
-
- def quantify(seq, pred=None):
- "Count how many times the predicate is true in the sequence"
- return sum(map(pred, seq))
-
- def padnone(seq):
+ "Returns the nth item or empty list"
+ return list(islice(iterable, n, n+1))
+
+ def quantify(iterable, pred=bool):
+ "Count how many times the predicate is true"
+ return sum(map(pred, iterable))
+
+ def padnone(iterable):
"""Returns the sequence elements and then returns None indefinitely.
Useful for emulating the behavior of the built-in map() function.
"""
- return chain(seq, repeat(None))
+ return chain(iterable, repeat(None))
- def ncycles(seq, n):
+ def ncycles(iterable, n):
"Returns the sequence elements n times"
- return chain.from_iterable(repeat(seq, n))
+ return chain.from_iterable(repeat(iterable, n))
def dotproduct(vec1, vec2):
return sum(map(operator.mul, vec1, vec2))
def compress(data, selectors):
"compress('abcdef', [1,0,1,0,1,1]) --> a c e f"
- for d, s in zip(data, selectors):
- if s:
- yield d
-
+ decorated = zip(data, selectors)
+ filtered = filter(operator.itemgetter(1), decorated)
+ return map(operator.itemgetter(0), filtered)
+
+ def combinations_with_replacement(iterable, r):
+ "combinations_with_replacement('ABC', 3) --> AA AB AC BB BC CC"
+ pool = tuple(iterable)
+ n = len(pool)
+ indices = [0] * r
+ yield tuple(pool[i] for i in indices)
+ while True:
+ for i in reversed(range(r)):
+ if indices[i] != n - 1:
+ break
+ else:
+ return
+ indices[i:] = [indices[i] + 1] * (r - i)
+ yield tuple(pool[i] for i in indices)
The system will save old log files by appending extensions to the filename.
The extensions are date-and-time based, using the strftime format
``%Y-%m-%d_%H-%M-%S`` or a leading portion thereof, depending on the
- rollover interval.
+ rollover interval.
If the *utc* argument is true, times in UTC will be used; otherwise
local time is used.
in the ``logging`` package's namespace). The ``level`` is interpreted as for
loggers, and ``NOTSET`` is taken to mean "log everything".
+.. versionchanged:: 2.6
+ Added support for resolving the handler's class as a dotted module and class
+ name.
+
The ``formatter`` entry indicates the key name of the formatter for this
handler. If blank, a default formatter (``logging._defaultFormatter``) is used.
If a name is specified, it must appear in the ``[formatters]`` section and have
.. function:: findall(pattern, string[, flags])
Return all non-overlapping matches of *pattern* in *string*, as a list of
- strings. If one or more groups are present in the pattern, return a list of
- groups; this will be a list of tuples if the pattern has more than one group.
- Empty matches are included in the result unless they touch the beginning of
- another match.
+ strings. The *string* is scanned left-to-right, and matches are returned in
+ the order found. If one or more groups are present in the pattern, return a
+ list of groups; this will be a list of tuples if the pattern has more than
+ one group. Empty matches are included in the result unless they touch the
+ beginning of another match.
.. function:: finditer(pattern, string[, flags])
Return an :term:`iterator` yielding :class:`MatchObject` instances over all
- non-overlapping matches for the RE *pattern* in *string*. Empty matches are
- included in the result unless they touch the beginning of another match.
+ non-overlapping matches for the RE *pattern* in *string*. The *string* is
+ scanned left-to-right, and matches are returned in the order found. Empty
+ matches are included in the result unless they touch the beginning of another
+ match.
.. function:: sub(pattern, repl, string[, count])
character of ``'0'``.
The *precision* is a decimal number indicating how many digits should be
-displayed after the decimal point for a floating point value. For non-number
-types the field indicates the maximum field size - in other words, how many
-characters will be used from the field content. The *precision* is ignored for
-integer values.
+displayed after the decimal point for a floating point value formatted with
+``'f'`` and ``'F'``, or before and after the decimal point for a floating point
+value formatted with ``'g'`` or ``'G'``. For non-number types the field
+indicates the maximum field size - in other words, how many characters will be
+used from the field content. The *precision* is ignored for integer values.
Finally, the *type* determines how the data should be presented.
| | the current locale setting to insert the appropriate |
| | number separator characters. |
+---------+----------------------------------------------------------+
- | None | the same as ``'d'`` |
+ | None | The same as ``'d'``. |
+---------+----------------------------------------------------------+
The available presentation types for floating point and decimal values are:
+---------+----------------------------------------------------------+
| ``'g'`` | General format. This prints the number as a fixed-point |
| | number, unless the number is too large, in which case |
- | | it switches to ``'e'`` exponent notation. |
+ | | it switches to ``'e'`` exponent notation. Infinity and |
+ | | NaN values are formatted as ``inf``, ``-inf`` and |
+ | | ``nan``, respectively. |
+---------+----------------------------------------------------------+
| ``'G'`` | General format. Same as ``'g'`` except switches to |
- | | ``'E'`` if the number gets to large. |
+ | | ``'E'`` if the number gets to large. The representations |
+ | | of infinity and NaN are uppercased, too. |
+---------+----------------------------------------------------------+
| ``'n'`` | Number. This is the same as ``'g'``, except that it uses |
| | the current locale setting to insert the appropriate |
| ``'%'`` | Percentage. Multiplies the number by 100 and displays |
| | in fixed (``'f'``) format, followed by a percent sign. |
+---------+----------------------------------------------------------+
- | None | the same as ``'g'`` |
+ | None | The same as ``'g'``. |
+---------+----------------------------------------------------------+
when the function is called.
The function definition does not execute the function body; this gets executed
-only when the function is called.
+only when the function is called. [#]_
.. index::
statement: @
pair: name; binding
pair: execution; frame
single: inheritance
+ single: docstring
A class definition defines a class object (see section :ref:`types`):
then executed in a new execution frame (see section :ref:`naming`), using a
newly created local namespace and the original global namespace. (Usually, the
suite contains only function definitions.) When the class's suite finishes
-execution, its execution frame is discarded but its local namespace is saved. A
-class object is then created using the inheritance list for the base classes and
-the saved local namespace for the attribute dictionary. The class name is bound
-to this class object in the original local namespace.
+execution, its execution frame is discarded but its local namespace is
+saved. [#]_ A class object is then created using the inheritance list for the
+base classes and the saved local namespace for the attribute dictionary. The
+class name is bound to this class object in the original local namespace.
Classes can also be decorated; as with functions, ::
.. [#] Currently, control "flows off the end" except in the case of an exception or the
execution of a :keyword:`return`, :keyword:`continue`, or :keyword:`break`
statement.
+
+.. [#] A string literal appearing as the first statement in the function body is
+ transformed into the function's ``__doc__`` attribute and therefore the
+ function's :term:`docstring`.
+
+.. [#] A string literal appearing as the first statement in the class body is
+ transformed into the namespace's ``__doc__`` item and therefore the class's
+ :term:`docstring`.
Notes on using *__slots__*
""""""""""""""""""""""""""
+* When inheriting from a class without *__slots__*, the *__dict__* attribute of
+ that class will always be accessible, so a *__slots__* definition in the
+ subclass is meaningless.
+
* Without a *__dict__* variable, instances cannot be assigned new variables not
listed in the *__slots__* definition. Attempts to assign to an unlisted
variable name raises :exc:`AttributeError`. If dynamic assignment of new
File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file
+It is good practice to use the :keyword:`with` keyword when dealing with file
+objects. This has the advantage that the file is properly closed after its
+suite finishes, even if an exception is raised on the way. It is also much
+shorter than writing equivalent :keyword:`try`\ -\ :keyword:`finally` blocks::
+
+ >>> with open('/tmp/workfile', 'r') as f:
+ ... read_data = f.read()
+ >>> f.closed
+ True
+
File objects have some additional methods, such as :meth:`isatty` and
:meth:`truncate` which are less frequently used; consult the Library Reference
for a complete guide to file objects.
all, and only exists to allow checking if an object is a number by
doing ``isinstance(obj, Number)``.
-Numbers are further divided into :class:`Exact` and :class:`Inexact`.
-Exact numbers can represent values precisely and operations never
-round off the results or introduce tiny errors that may break the
-commutativity and associativity properties; inexact numbers may
-perform such rounding or introduce small errors. Integers, long
-integers, and rational numbers are exact, while floating-point
-and complex numbers are inexact.
-
:class:`Complex` is a subclass of :class:`Number`. Complex numbers
can undergo the basic operations of addition, subtraction,
multiplication, division, and exponentiation, and you can retrieve the
it will be returned if *iterator* has been exhausted; otherwise,
the :exc:`StopIteration` exception will be raised. (:issue:`2719`)
-* Tuples now have an :meth:`index` method matching the list type's
- :meth:`index` method::
+* Tuples now have :meth:`index` and :meth:`count` methods matching the
+ list type's :meth:`index` and :meth:`count` methods::
>>> t = (0,1,2,3,4)
>>> t.index(3)
3
+ (Contributed by Raymond Hettinger)
+
* The built-in types now have improved support for extended slicing syntax,
where various combinations of ``(start, stop, step)`` are supplied.
Previously, the support was partial and certain corner cases wouldn't work.
* :func:`~math.sum` adds up the stream of numbers from an iterable,
and is careful to avoid loss of precision by calculating partial sums.
- (Contributed by Jean Brouwers; :issue:`2819`.)
+ (Contributed by Jean Brouwers, Raymond Hettinger, and Mark Dickinson;
+ :issue:`2819`.)
* The inverse hyperbolic functions :func:`~math.acosh`, :func:`~math.asinh`
and :func:`~math.atanh`.
* The string :meth:`translate` method now accepts ``None`` as the
translation table parameter, which is treated as the identity
transformation. This makes it easier to carry out operations
- that only delete characters. (Contributed by Bengt Richter;
- :issue:`1193128`.)
+ that only delete characters. (Contributed by Bengt Richter and
+ implemented by Raymond Hettinger; :issue:`1193128`.)
* The built-in :func:`dir` function now checks for a :meth:`__dir__`
method on the objects it receives. This method must return a list
if 'ARCHFLAGS' in os.environ and not stripArch:
# User specified different -arch flags in the environ,
# see also distutils.sysconfig
- compiler_so = compiler_so + ' ' + os.environ['ARCHFLAGS']
-
+ compiler_so = compiler_so + os.environ['ARCHFLAGS'].split()
if stripSysroot:
try:
def what(file, h=None):
if h is None:
- if type(file) == type(''):
+ if isinstance(file, str):
f = open(file, 'rb')
h = f.read(32)
else:
fmt = cp.get(sectname, "formatter")
else:
fmt = ""
- klass = eval(klass, vars(logging))
+ try:
+ klass = eval(klass, vars(logging))
+ except (AttributeError, NameError):
+ klass = _resolve(klass)
args = cp.get(sectname, "args")
args = eval(args, vars(logging))
h = klass(*args)
(fd, filename) = tempfile.mkstemp()
os.close(fd)
try:
- if hasattr(os, 'system') and os.system('more %s' % filename) == 0:
+ if hasattr(os, 'system') and os.system('more "%s"' % filename) == 0:
return lambda text: pipepager(text, 'more')
else:
return ttypager
file.write(text)
file.close()
try:
- os.system(cmd + ' ' + filename)
+ os.system(cmd + ' "' + filename + '"')
finally:
os.unlink(filename)
# decoding errors disappeared. This verifies they're back again.
failure = None
try:
- self.con.execute("select 'xxx' || ? || 'yyy' colname", (bytes(bytearray([250])),)).fetchone()
+ self.con.execute("select 'xxx' || ? || 'yyy' colname",
+ (bytes(bytearray([250])),)).fetchone()
failure = "should have raised an OperationalError with detailed description"
except sqlite.OperationalError as e:
msg = e.args[0]
if failure:
self.fail(failure)
+ def CheckRegisterAdapter(self):
+ """
+ See issue 3312.
+ """
+ self.assertRaises(TypeError, sqlite.register_adapter, {}, None)
+
+ def CheckSetIsolationLevel(self):
+ """
+ See issue 3312.
+ """
+ con = sqlite.connect(":memory:")
+ setattr(con, "isolation_level", "\xe9")
+
+
def suite():
regression_suite = unittest.makeSuite(RegressionTests, "Check")
return unittest.TestSuite((regression_suite,))
IntLoc1 = Proc2(IntLoc1)
benchtime = clock() - starttime - nulltime
- return benchtime, (loops / benchtime)
+ if benchtime == 0.0:
+ loopsPerBenchtime = 0.0
+ else:
+ loopsPerBenchtime = (loops / benchtime)
+ return benchtime, loopsPerBenchtime
def Proc1(PtrParIn):
PtrParIn.PtrComp = NextRecord = PtrGlb.copy()
self.assertEqual(audioop.getsample(data[1], 2, i), i)
self.assertEqual(audioop.getsample(data[2], 4, i), i)
- def test_negavitelen(self):
+ def test_negativelen(self):
# from issue 3306, previously it segfaulted
self.assertRaises(audioop.error,
audioop.findmax, ''.join(chr(x) for x in range(256)), -2392392)
[22]
[25, 26, 27, 28]
->>> def take(n, seq):
-... return list(islice(seq, n))
+>>> def take(n, iterable):
+... "Return first n items of the iterable as a list"
+... return list(islice(iterable, n))
->>> def enumerate(iterable):
-... return zip(count(), iterable)
+>>> def enumerate(iterable, start=0):
+... return zip(count(start), iterable)
->>> def tabulate(function):
+>>> def tabulate(function, start=0):
... "Return function(0), function(1), ..."
-... return map(function, count())
-
->>> def iteritems(mapping):
-... return zip(mapping.keys(), mapping.values())
+... return map(function, count(start))
>>> def nth(iterable, n):
-... "Returns the nth item"
+... "Returns the nth item or empty list"
... return list(islice(iterable, n, n+1))
->>> def all(seq, pred=None):
-... "Returns True if pred(x) is true for every element in the iterable"
-... for elem in filterfalse(pred, seq):
-... return False
-... return True
-
->>> def any(seq, pred=None):
-... "Returns True if pred(x) is true for at least one element in the iterable"
-... for elem in filter(pred, seq):
-... return True
-... return False
-
->>> def no(seq, pred=None):
-... "Returns True if pred(x) is false for every element in the iterable"
-... for elem in filter(pred, seq):
-... return False
-... return True
-
->>> def quantify(seq, pred=None):
-... "Count how many times the predicate is true in the sequence"
-... return sum(map(pred, seq))
-
->>> def padnone(seq):
+>>> def quantify(iterable, pred=bool):
+... "Count how many times the predicate is true"
+... return sum(map(pred, iterable))
+
+>>> def padnone(iterable):
... "Returns the sequence elements and then returns None indefinitely"
-... return chain(seq, repeat(None))
+... return chain(iterable, repeat(None))
->>> def ncycles(seq, n):
-... "Returns the sequence elements n times"
-... return chain(*repeat(seq, n))
+>>> def ncycles(iterable, n):
+... "Returns the seqeuence elements n times"
+... return chain(*repeat(iterable, n))
>>> def dotproduct(vec1, vec2):
... return sum(map(operator.mul, vec1, vec2))
>>> def compress(data, selectors):
... "compress('abcdef', [1,0,1,0,1,1]) --> a c e f"
-... for d, s in zip(data, selectors):
-... if s:
-... yield d
+... decorated = zip(data, selectors)
+... filtered = filter(operator.itemgetter(1), decorated)
+... return map(operator.itemgetter(0), filtered)
+
+>>> def combinations_with_replacement(iterable, r):
+... "combinations_with_replacement('ABC', 3) --> AA AB AC BB BC CC"
+... pool = tuple(iterable)
+... n = len(pool)
+... indices = [0] * r
+... yield tuple(pool[i] for i in indices)
+... while 1:
+... for i in reversed(range(r)):
+... if indices[i] != n - 1:
+... break
+... else:
+... return
+... indices[i:] = [indices[i] + 1] * (r - i)
+... yield tuple(pool[i] for i in indices)
This is not part of the examples but it tests to make sure the definitions
perform as purported.
>>> nth('abcde', 3)
['d']
->>> all([2, 4, 6, 8], lambda x: x%2==0)
-True
-
->>> all([2, 3, 6, 8], lambda x: x%2==0)
-False
-
->>> any([2, 4, 6, 8], lambda x: x%2==0)
-True
-
->>> any([1, 3, 5, 9], lambda x: x%2==0,)
-False
-
->>> no([1, 3, 5, 9], lambda x: x%2==0)
-True
-
->>> no([1, 2, 5, 9], lambda x: x%2==0)
-False
-
>>> quantify(range(99), lambda x: x%2==0)
50
>>> list(compress('abcdef', [1,0,1,0,1,1]))
['a', 'c', 'e', 'f']
+>>> list(combinations_with_replacement('abc', 2))
+[('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'b'), ('b', 'c'), ('c', 'c')]
+
"""
__test__ = {'libreftest' : libreftest}
-from test.support import verbose, TestSkipped
+from test.support import verbose, TestSkipped, TestFailed
import locale
import sys
finally:
locale.setlocale(locale.LC_NUMERIC, oldlocale)
+
+if hasattr(locale, "strcoll"):
+ # test crasher from bug #3303
+ try:
+ locale.strcoll("a", None)
+ except TypeError:
+ pass
+ else:
+ raise TestFailed("TypeError not raised")
datefmt=
"""
+ # config5 specifies a custom handler class to be loaded
+ config5 = config1.replace('class=StreamHandler', 'class=logging.StreamHandler')
+
def apply_config(self, conf):
try:
fn = tempfile.mktemp(".ini")
# Original logger output is empty.
self.assert_log_lines([])
- def test_config1_ok(self):
+ def test_config1_ok(self, config=config1):
# A config file defining a sub-parser as well.
with captured_stdout() as output:
- self.apply_config(self.config1)
+ self.apply_config(config)
logger = logging.getLogger("compiler.parser")
# Both will output a message
logger.info(self.next_message())
# Original logger output is empty
self.assert_log_lines([])
+ def test_config5_ok(self):
+ self.test_config1_ok(config=self.config5)
class LogRecordStreamHandler(StreamRequestHandler):
from test import test_multibytecodec_support
from test.support import TESTFN
import unittest, io, codecs, sys, os
+import _multibytecodec
ALL_CJKENCODINGS = [
# _codecs_cn
finally:
support.unlink(TESTFN)
+ def test_init_segfault(self):
+ # bug #3305: this used to segfault
+ self.assertRaises(AttributeError,
+ _multibytecodec.MultibyteStreamReader, None)
+ self.assertRaises(AttributeError,
+ _multibytecodec.MultibyteStreamWriter, None)
+
+
class Test_IncrementalEncoder(unittest.TestCase):
def test_stateless(self):
gc.collect() # do garbage collection
refs = self.manager._number_of_objects()
if refs != EXPECTED_NUMBER:
- print(self.manager._debugInfo())
+ print(self.manager._debug_info())
self.assertEqual(refs, EXPECTED_NUMBER)
import time
import pickle
import warnings
-from math import log, exp, sqrt, pi
+from math import log, exp, sqrt, pi, sum as msum
from test import support
class TestBasicOps(unittest.TestCase):
def gamma(z, cof=_gammacoeff, g=7):
z -= 1.0
- sum = cof[0]
- for i in range(1,len(cof)):
- sum += cof[i] / (z+i)
+ s = msum([cof[0]] + [cof[i] / (z+i) for i in range(1,len(cof))])
z += 0.5
- return (z+g)**z / exp(z+g) * sqrt(2*pi) * sum
+ return (z+g)**z / exp(z+g) * sqrt(2.0*pi) * s
class TestDistributions(unittest.TestCase):
def test_zeroinputs(self):
class NetworkTestCase(unittest.TestCase):
def testPasswordProtectedSite(self):
- support.requires('network')
+ if not support.is_resource_enabled('network'):
+ return
# whole site is password-protected.
url = 'http://mueblesmoraleda.com'
parser = urllib.robotparser.RobotFileParser()
self.assertEqual(parser.can_fetch("*", url+"/robots.txt"), False)
def testPythonOrg(self):
- support.requires('network')
+ if not support.is_resource_enabled('network'):
+ return
parser = urllib.robotparser.RobotFileParser(
"http://www.python.org/robots.txt")
parser.read()
support.run_unittest(tests)
if __name__=='__main__':
- support.Verbose = 1
+ support.verbose = 1
test_main()
self.assert_("x" not in varnames)
self.assert_("y" in varnames)
+ def testLocalsClass_WithTrace(self):
+ # Issue23728: after the trace function returns, the locals()
+ # dictionary is used to update all variables, this used to
+ # include free variables. But in class statements, free
+ # variables are not inserted...
+ import sys
+ sys.settrace(lambda a,b,c:None)
+ try:
+ x = 12
+
+ class C:
+ def f(self):
+ return x
+
+ self.assertEquals(x, 12) # Used to raise UnboundLocalError
+ finally:
+ sys.settrace(None)
+
def testBoundAndFree(self):
# var is bound and free in class
PyIntl_gettext(PyObject* self, PyObject *args)
{
char *in;
- if (!PyArg_ParseTuple(args, "z", &in))
+ if (!PyArg_ParseTuple(args, "s", &in))
return 0;
return str2uni(gettext(in));
}
PyIntl_dgettext(PyObject* self, PyObject *args)
{
char *domain, *in;
- if (!PyArg_ParseTuple(args, "zz", &domain, &in))
+ if (!PyArg_ParseTuple(args, "zs", &domain, &in))
return 0;
return str2uni(dgettext(domain, in));
}
{
char *domain, *msgid;
int category;
- if (!PyArg_ParseTuple(args, "zzi", &domain, &msgid, &category))
+ if (!PyArg_ParseTuple(args, "zsi", &domain, &msgid, &category))
return 0;
return str2uni(dcgettext(domain,msgid,category));
}
static PyObject*
PyIntl_bindtextdomain(PyObject* self,PyObject*args)
{
- char *domain,*dirname;
- if (!PyArg_ParseTuple(args, "zz", &domain, &dirname))
+ char *domain, *dirname;
+ if (!PyArg_ParseTuple(args, "sz", &domain, &dirname))
return 0;
+ if (!strlen(domain)) {
+ PyErr_SetString(Error, "domain must be a non-empty string");
+ return 0;
+ }
dirname = bindtextdomain(domain, dirname);
if (!dirname) {
PyErr_SetFromErrno(PyExc_OSError);
}
statement = PyUnicode_AsStringAndSize(begin_statement, &size);
+ if (!statement) {
+ Py_DECREF(statement);
+ return -1;
+ }
self->begin_statement = PyMem_Malloc(size + 2);
if (!self->begin_statement) {
+ Py_DECREF(begin_statement);
return -1;
}
{
PyTypeObject* type;
PyObject* caster;
+ int rc;
if (!PyArg_ParseTuple(args, "OO", &type, &caster)) {
return NULL;
pysqlite_BaseTypeAdapted = 1;
}
- microprotocols_add(type, (PyObject*)&pysqlite_PrepareProtocolType, caster);
+ rc = microprotocols_add(type, (PyObject*)&pysqlite_PrepareProtocolType, caster);
+ if (rc == -1)
+ return NULL;
Py_INCREF(Py_None);
return Py_None;
{
PyObject_GC_UnTrack(self);
ERROR_DECREF(self->errors);
- Py_DECREF(self->stream);
+ Py_XDECREF(self->stream);
Py_TYPE(self)->tp_free(self);
}
{
PyObject_GC_UnTrack(self);
ERROR_DECREF(self->errors);
- Py_DECREF(self->stream);
+ Py_XDECREF(self->stream);
Py_TYPE(self)->tp_free(self);
}
return NULL;
}
for (;;) {
+ errno = 0;
Py_BEGIN_ALLOW_THREADS
ep = readdir(dirp);
Py_END_ALLOW_THREADS
- if (ep == NULL)
- break;
+ if (ep == NULL) {
+ if (errno == 0) {
+ break;
+ } else {
+ closedir(dirp);
+ Py_DECREF(d);
+ return posix_error_with_allocated_filename(name);
+ }
+ }
if (ep->d_name[0] == '.' &&
(NAMLEN(ep) == 1 ||
(ep->d_name[1] == '.' && NAMLEN(ep) == 2)))
}
Py_DECREF(v);
}
- if (errno != 0 && d != NULL) {
- /* readdir() returned NULL and set errno */
- closedir(dirp);
- Py_DECREF(d);
- return posix_error_with_allocated_filename(name);
- }
closedir(dirp);
PyMem_Free(name);
else {
if (_getbuffer(values, &vbytes) < 0) {
PyErr_Format(PyExc_TypeError,
- "can't set bytes slice from %.100s",
+ "can't set bytearray slice from %.100s",
Py_TYPE(values)->tp_name);
return -1;
}
}
/* Parse arguments */
- if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oss:bytes", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oss:bytearray", kwlist,
&arg, &encoding, &errors))
return -1;
if (ncells || nfreevars) {
dict_to_map(co->co_cellvars, ncells,
locals, fast + co->co_nlocals, 1, clear);
- dict_to_map(co->co_freevars, nfreevars,
- locals, fast + co->co_nlocals + ncells, 1,
- clear);
+ /* Same test as in PyFrame_FastToLocals() above. */
+ if (co->co_flags & CO_OPTIMIZED) {
+ dict_to_map(co->co_freevars, nfreevars,
+ locals, fast + co->co_nlocals + ncells, 1,
+ clear);
+ }
}
PyErr_Restore(error_type, error_value, error_traceback);
}
return (PyObject*) self;
}
+#if defined(MS_WIN32) && !defined(MS_WIN64)
+#define HANDLE_TO_PYNUM(handle) PyLong_FromLong((long) handle)
+#define PY_HANDLE_PARAM "l"
+#else
+#define HANDLE_TO_PYNUM(handle) PyLong_FromLongLong((long long) handle)
+#define PY_HANDLE_PARAM "L"
+#endif
+
static PyObject*
sp_handle_detach(sp_handle_object* self, PyObject* args)
{
self->handle = NULL;
/* note: return the current handle, as an integer */
- return PyLong_FromLong((long) handle);
+ return HANDLE_TO_PYNUM(handle);
}
static PyObject*
static PyObject*
sp_handle_as_int(sp_handle_object* self)
{
- return PyLong_FromLong((long) self->handle);
+ return HANDLE_TO_PYNUM(self->handle);
}
static PyNumberMethods sp_handle_as_number;
}
/* note: returns integer, not handle object */
- return PyLong_FromLong((long) handle);
+ return HANDLE_TO_PYNUM(handle);
}
static PyObject *
HANDLE target_handle;
BOOL result;
- long source_process_handle;
- long source_handle;
- long target_process_handle;
+ HANDLE source_process_handle;
+ HANDLE source_handle;
+ HANDLE target_process_handle;
int desired_access;
int inherit_handle;
int options = 0;
- if (! PyArg_ParseTuple(args, "lllii|i:DuplicateHandle",
+ if (! PyArg_ParseTuple(args,
+ PY_HANDLE_PARAM PY_HANDLE_PARAM PY_HANDLE_PARAM
+ "ii|i:DuplicateHandle",
&source_process_handle,
&source_handle,
&target_process_handle,
Py_BEGIN_ALLOW_THREADS
result = DuplicateHandle(
- (HANDLE) source_process_handle,
- (HANDLE) source_handle,
- (HANDLE) target_process_handle,
+ source_process_handle,
+ source_handle,
+ target_process_handle,
&target_handle,
desired_access,
inherit_handle,
{
BOOL result;
- long process;
+ HANDLE process;
int exit_code;
- if (! PyArg_ParseTuple(args, "li:TerminateProcess", &process,
- &exit_code))
+ if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM "i:TerminateProcess",
+ &process, &exit_code))
return NULL;
- result = TerminateProcess((HANDLE) process, exit_code);
+ result = TerminateProcess(process, exit_code);
if (! result)
return PyErr_SetFromWindowsErr(GetLastError());
DWORD exit_code;
BOOL result;
- long process;
- if (! PyArg_ParseTuple(args, "l:GetExitCodeProcess", &process))
+ HANDLE process;
+ if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM ":GetExitCodeProcess", &process))
return NULL;
- result = GetExitCodeProcess((HANDLE) process, &exit_code);
+ result = GetExitCodeProcess(process, &exit_code);
if (! result)
return PyErr_SetFromWindowsErr(GetLastError());
{
DWORD result;
- long handle;
+ HANDLE handle;
int milliseconds;
- if (! PyArg_ParseTuple(args, "li:WaitForSingleObject",
+ if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM "i:WaitForSingleObject",
&handle,
&milliseconds))
return NULL;
Py_BEGIN_ALLOW_THREADS
- result = WaitForSingleObject((HANDLE) handle, (DWORD) milliseconds);
+ result = WaitForSingleObject(handle, (DWORD) milliseconds);
Py_END_ALLOW_THREADS
if (result == WAIT_FAILED)
sp_GetModuleFileName(PyObject* self, PyObject* args)
{
BOOL result;
- long module;
+ HMODULE module;
WCHAR filename[MAX_PATH];
- if (! PyArg_ParseTuple(args, "l:GetModuleFileName", &module))
+ if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM ":GetModuleFileName",
+ &module))
return NULL;
- result = GetModuleFileNameW((HMODULE)module, filename, MAX_PATH);
+ result = GetModuleFileNameW(module, filename, MAX_PATH);
filename[MAX_PATH-1] = '\0';
if (! result)
case E_INTR:
if (!PyErr_Occurred())
PyErr_SetNone(PyExc_KeyboardInterrupt);
- return;
+ goto cleanup;
case E_NOMEM:
PyErr_NoMemory();
- return;
+ goto cleanup;
case E_EOF:
msg = "unexpected EOF while parsing";
break;
}
v = Py_BuildValue("(ziiN)", err->filename,
err->lineno, err->offset, errtext);
- if (err->text != NULL) {
- PyObject_FREE(err->text);
- err->text = NULL;
- }
w = NULL;
if (v != NULL)
w = Py_BuildValue("(sO)", msg, v);
Py_XDECREF(v);
PyErr_SetObject(errtype, w);
Py_XDECREF(w);
+cleanup:
+ if (err->text != NULL) {
+ PyObject_FREE(err->text);
+ err->text = NULL;
+ }
}
/* Print fatal error message and abort */
BASECFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
- tgt=`sw_vers -productVersion | sed 's/\(10\.0-9*\).*/\1/'`
+ tgt=`sw_vers -productVersion | sed 's/\(10\.[0-9]*\).*/\1/'`
if test "${UNIVERSALSDK}" != "/" -a "${tgt}" '>' '10.4' ; then
CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
fi
BASECFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
- tgt=`sw_vers -productVersion | sed 's/\(10\.[0-9]*\).*/\1/'`
+ tgt=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
if test "${UNIVERSALSDK}" != "/" -a "${tgt}" '>' '10.4' ; then
CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
fi
projects / python / commitdiff