Mailman 3 April 2013 - Python-checkins

cpython: refactor traceback.py to reduce code duplication (closes #17646)
by benjamin.peterson April 29, 2013

April 29, 2013

http://hg.python.org/cpython/rev/84cef4f1999a changeset: 83553:84cef4f1999a user: Benjamin Peterson <benjamin(a)python.org> date: Mon Apr 29 16:09:39 2013 -0400 summary: refactor traceback.py to reduce code duplication (closes #17646) Patch by Martin Morrison. files: Lib/test/test_traceback.py | 28 ++ Lib/traceback.py | 247 ++++++++++-------------- 2 files changed, 132 insertions(+), 143 deletions(-) diff --git a/Lib/test/test_traceback.py b/Lib/test/test_traceback.py --- a/Lib/test/test_traceback.py +++ b/Lib/test/test_traceback.py @@ -160,11 +160,26 @@ file_ = StringIO() traceback_print(tb, file_) python_fmt = file_.getvalue() + # Call all _tb and _exc functions + with captured_output("stderr") as tbstderr: + traceback.print_tb(tb) + tbfile = StringIO() + traceback.print_tb(tb, file=tbfile) + with captured_output("stderr") as excstderr: + traceback.print_exc() + excfmt = traceback.format_exc() + excfile = StringIO() + traceback.print_exc(file=excfile) else: raise Error("unable to create test traceback string") # Make sure that Python and the traceback module format the same thing self.assertEqual(traceback_fmt, python_fmt) + # Now verify the _tb func output + self.assertEqual(tbstderr.getvalue(), tbfile.getvalue()) + # Now verify the _exc func output + self.assertEqual(excstderr.getvalue(), excfile.getvalue()) + self.assertEqual(excfmt, excfile.getvalue()) # Make sure that the traceback is properly indented. tb_lines = python_fmt.splitlines() @@ -174,6 +189,19 @@ self.assertTrue(location.startswith(' File')) self.assertTrue(source_line.startswith(' raise')) + def test_stack_format(self): + # Verify _stack functions. Note we have to use _getframe(1) to + # compare them without this frame appearing in the output + with captured_output("stderr") as ststderr: + traceback.print_stack(sys._getframe(1)) + stfile = StringIO() + traceback.print_stack(sys._getframe(1), file=stfile) + self.assertEqual(ststderr.getvalue(), stfile.getvalue()) + + stfmt = traceback.format_stack(sys._getframe(1)) + + self.assertEqual(ststderr.getvalue(), "".join(stfmt)) + cause_message = ( "\nThe above exception was the direct cause " diff --git a/Lib/traceback.py b/Lib/traceback.py --- a/Lib/traceback.py +++ b/Lib/traceback.py @@ -2,26 +2,31 @@ import linecache import sys +import operator __all__ = ['extract_stack', 'extract_tb', 'format_exception', 'format_exception_only', 'format_list', 'format_stack', 'format_tb', 'print_exc', 'format_exc', 'print_exception', 'print_last', 'print_stack', 'print_tb'] -def _print(file, str='', terminator='\n'): - file.write(str+terminator) +# +# Formatting and printing lists of traceback lines. +# +def _format_list_iter(extracted_list): + for filename, lineno, name, line in extracted_list: + item = ' File "{}", line {}, in {}\n'.format(filename, lineno, name) + if line: + item = item + ' {}\n'.format(line.strip()) + yield item def print_list(extracted_list, file=None): """Print the list of tuples as returned by extract_tb() or extract_stack() as a formatted stack trace to the given file.""" if file is None: file = sys.stderr - for filename, lineno, name, line in extracted_list: - _print(file, - ' File "%s", line %d, in %s' % (filename,lineno,name)) - if line: - _print(file, ' %s' % line.strip()) + for item in _format_list_iter(extracted_list): + print(item, file=file, end="") def format_list(extracted_list): """Format a list of traceback entry tuples for printing. @@ -33,14 +38,44 @@ the strings may contain internal newlines as well, for those items whose source text line is not None. """ - list = [] - for filename, lineno, name, line in extracted_list: - item = ' File "%s", line %d, in %s\n' % (filename,lineno,name) + return list(_format_list_iter(extracted_list)) + +# +# Printing and Extracting Tracebacks. +# + +# extractor takes curr and needs to return a tuple of: +# - Frame object +# - Line number +# - Next item (same type as curr) +# In practice, curr is either a traceback or a frame. +def _extract_tb_or_stack_iter(curr, limit, extractor): + if limit is None: + limit = getattr(sys, 'tracebacklimit', None) + + n = 0 + while curr is not None and (limit is None or n < limit): + f, lineno, next_item = extractor(curr) + co = f.f_code + filename = co.co_filename + name = co.co_name + + linecache.checkcache(filename) + line = linecache.getline(filename, lineno, f.f_globals) + if line: - item = item + ' %s\n' % line.strip() - list.append(item) - return list + line = line.strip() + else: + line = None + yield (filename, lineno, name, line) + curr = next_item + n += 1 + +def _extract_tb_iter(tb, limit): + return _extract_tb_or_stack_iter( + tb, limit, + operator.attrgetter("tb_frame", "tb_lineno", "tb_next")) def print_tb(tb, limit=None, file=None): """Print up to 'limit' stack trace entries from the traceback 'tb'. @@ -50,29 +85,11 @@ 'file' should be an open file or file-like object with a write() method. """ - if file is None: - file = sys.stderr - if limit is None: - if hasattr(sys, 'tracebacklimit'): - limit = sys.tracebacklimit - n = 0 - while tb is not None and (limit is None or n < limit): - f = tb.tb_frame - lineno = tb.tb_lineno - co = f.f_code - filename = co.co_filename - name = co.co_name - _print(file, - ' File "%s", line %d, in %s' % (filename, lineno, name)) - linecache.checkcache(filename) - line = linecache.getline(filename, lineno, f.f_globals) - if line: _print(file, ' ' + line.strip()) - tb = tb.tb_next - n = n+1 + print_list(extract_tb(tb, limit=limit), file=file) def format_tb(tb, limit=None): - """A shorthand for 'format_list(extract_stack(f, limit)).""" - return format_list(extract_tb(tb, limit)) + """A shorthand for 'format_list(extract_tb(tb, limit)).""" + return format_list(extract_tb(tb, limit=limit)) def extract_tb(tb, limit=None): """Return list of up to limit pre-processed entries from traceback. @@ -85,26 +102,11 @@ leading and trailing whitespace stripped; if the source is not available it is None. """ - if limit is None: - if hasattr(sys, 'tracebacklimit'): - limit = sys.tracebacklimit - list = [] - n = 0 - while tb is not None and (limit is None or n < limit): - f = tb.tb_frame - lineno = tb.tb_lineno - co = f.f_code - filename = co.co_filename - name = co.co_name - linecache.checkcache(filename) - line = linecache.getline(filename, lineno, f.f_globals) - if line: line = line.strip() - else: line = None - list.append((filename, lineno, name, line)) - tb = tb.tb_next - n = n+1 - return list + return list(_extract_tb_iter(tb, limit=limit)) +# +# Exception formatting and output. +# _cause_message = ( "\nThe above exception was the direct cause " @@ -134,6 +136,21 @@ for it in its: yield from it +def _format_exception_iter(etype, value, tb, limit, chain): + if chain: + values = _iter_chain(value, tb) + else: + values = [(value, tb)] + + for value, tb in values: + if isinstance(value, str): + # This is a cause/context message line + yield value + '\n' + continue + if tb: + yield 'Traceback (most recent call last):\n' + yield from _format_list_iter(_extract_tb_iter(tb, limit=limit)) + yield from _format_exception_only_iter(type(value), value) def print_exception(etype, value, tb, limit=None, file=None, chain=True): """Print exception up to 'limit' stack trace entries from 'tb' to 'file'. @@ -148,20 +165,8 @@ """ if file is None: file = sys.stderr - if chain: - values = _iter_chain(value, tb) - else: - values = [(value, tb)] - for value, tb in values: - if isinstance(value, str): - _print(file, value) - continue - if tb: - _print(file, 'Traceback (most recent call last):') - print_tb(tb, limit, file) - lines = format_exception_only(type(value), value) - for line in lines: - _print(file, line, '') + for line in _format_exception_iter(etype, value, tb, limit, chain): + print(line, file=file, end="") def format_exception(etype, value, tb, limit=None, chain=True): """Format a stack trace and the exception information. @@ -172,20 +177,7 @@ these lines are concatenated and printed, exactly the same text is printed as does print_exception(). """ - list = [] - if chain: - values = _iter_chain(value, tb) - else: - values = [(value, tb)] - for value, tb in values: - if isinstance(value, str): - list.append(value + '\n') - continue - if tb: - list.append('Traceback (most recent call last):\n') - list.extend(format_tb(tb, limit)) - list.extend(format_exception_only(type(value), value)) - return list + return list(_format_exception_iter(etype, value, tb, limit, chain)) def format_exception_only(etype, value): """Format the exception part of a traceback. @@ -203,10 +195,14 @@ string in the list. """ + return list(_format_exception_only_iter(etype, value)) + +def _format_exception_only_iter(etype, value): # Gracefully handle (the way Python 2.4 and earlier did) the case of # being called with (None, None). if etype is None: - return [_format_final_exc_line(etype, value)] + yield _format_final_exc_line(etype, value) + return stype = etype.__name__ smod = etype.__module__ @@ -214,26 +210,26 @@ stype = smod + '.' + stype if not issubclass(etype, SyntaxError): - return [_format_final_exc_line(stype, value)] + yield _format_final_exc_line(stype, value) + return # It was a syntax error; show exactly where the problem was found. - lines = [] filename = value.filename or "<string>" lineno = str(value.lineno) or '?' - lines.append(' File "%s", line %s\n' % (filename, lineno)) + yield ' File "{}", line {}\n'.format(filename, lineno) + badline = value.text offset = value.offset if badline is not None: - lines.append(' %s\n' % badline.strip()) + yield ' {}\n'.format(badline.strip()) if offset is not None: caretspace = badline.rstrip('\n')[:offset].lstrip() # non-space whitespace (likes tabs) must be kept for alignment caretspace = ((c.isspace() and c or ' ') for c in caretspace) # only three spaces to account for offset1 == pos 0 - lines.append(' %s^\n' % ''.join(caretspace)) + yield ' {}^\n'.format(''.join(caretspace)) msg = value.msg or "<no detail available>" - lines.append("%s: %s\n" % (stype, msg)) - return lines + yield "{}: {}\n".format(stype, msg) def _format_final_exc_line(etype, value): valuestr = _some_str(value) @@ -249,38 +245,34 @@ except: return '<unprintable %s object>' % type(value).__name__ - def print_exc(limit=None, file=None, chain=True): """Shorthand for 'print_exception(*sys.exc_info(), limit, file)'.""" - if file is None: - file = sys.stderr - try: - etype, value, tb = sys.exc_info() - print_exception(etype, value, tb, limit, file, chain) - finally: - etype = value = tb = None - + print_exception(*sys.exc_info(), limit=limit, file=file, chain=chain) def format_exc(limit=None, chain=True): """Like print_exc() but return a string.""" - try: - etype, value, tb = sys.exc_info() - return ''.join( - format_exception(etype, value, tb, limit, chain)) - finally: - etype = value = tb = None - + return "".join(format_exception(*sys.exc_info(), limit=limit, chain=chain)) def print_last(limit=None, file=None, chain=True): """This is a shorthand for 'print_exception(sys.last_type, sys.last_value, sys.last_traceback, limit, file)'.""" if not hasattr(sys, "last_type"): raise ValueError("no last exception") - if file is None: - file = sys.stderr print_exception(sys.last_type, sys.last_value, sys.last_traceback, limit, file, chain) +# +# Printing and Extracting Stacks. +# + +def _extract_stack_iter(f, limit=None): + return _extract_tb_or_stack_iter( + f, limit, lambda f: (f, f.f_lineno, f.f_back)) + +def _get_stack(f): + if f is None: + f = sys._getframe().f_back.f_back + return f def print_stack(f=None, limit=None, file=None): """Print a stack trace from its invocation point. @@ -289,21 +281,11 @@ stack frame at which to start. The optional 'limit' and 'file' arguments have the same meaning as for print_exception(). """ - if f is None: - try: - raise ZeroDivisionError - except ZeroDivisionError: - f = sys.exc_info()[2].tb_frame.f_back - print_list(extract_stack(f, limit), file) + print_list(extract_stack(_get_stack(f), limit=limit), file=file) def format_stack(f=None, limit=None): """Shorthand for 'format_list(extract_stack(f, limit))'.""" - if f is None: - try: - raise ZeroDivisionError - except ZeroDivisionError: - f = sys.exc_info()[2].tb_frame.f_back - return format_list(extract_stack(f, limit)) + return format_list(extract_stack(_get_stack(f), limit=limit)) def extract_stack(f=None, limit=None): """Extract the raw traceback from the current stack frame. @@ -314,27 +296,6 @@ line number, function name, text), and the entries are in order from oldest to newest stack frame. """ - if f is None: - try: - raise ZeroDivisionError - except ZeroDivisionError: - f = sys.exc_info()[2].tb_frame.f_back - if limit is None: - if hasattr(sys, 'tracebacklimit'): - limit = sys.tracebacklimit - list = [] - n = 0 - while f is not None and (limit is None or n < limit): - lineno = f.f_lineno - co = f.f_code - filename = co.co_filename - name = co.co_name - linecache.checkcache(filename) - line = linecache.getline(filename, lineno, f.f_globals) - if line: line = line.strip() - else: line = None - list.append((filename, lineno, name, line)) - f = f.f_back - n = n+1 - list.reverse() - return list + stack = list(_extract_stack_iter(_get_stack(f), limit=limit)) + stack.reverse() + return stack -- Repository URL: http://hg.python.org/cpython

1 0

peps: Retract most of public Handle API. Fix server-side ssl. Clean up open issues.
by guido.van.rossum April 29, 2013

April 29, 2013

http://hg.python.org/peps/rev/5fa96fe9e291 changeset: 4866:5fa96fe9e291 user: Guido van Rossum <guido(a)python.org> date: Mon Apr 29 11:49:58 2013 -0700 summary: Retract most of public Handle API. Fix server-side ssl. Clean up open issues. files: pep-3156.txt | 178 ++++++++++++++++---------------------- 1 files changed, 74 insertions(+), 104 deletions(-) diff --git a/pep-3156.txt b/pep-3156.txt --- a/pep-3156.txt +++ b/pep-3156.txt @@ -225,14 +225,6 @@ accuracy and precision of the clock are up to the implementation; the default implementation uses ``time.monotonic()``. -A note about callbacks and Handles: any function in the API described -below that takes a callback and a variable number of arguments for it -can also be given a Handle object instead of the callback. Then no -arguments should be given, and the Handle should represent an -immediate callback (as returned from ``call_soon()``), not a delayed -callback (as returned from ``call_later()``). If the Handle has -been cancelled, the call is a no-op. - Event Loop Classes ------------------ @@ -366,16 +358,15 @@ - ``call_later(delay, callback, *args)``. Arrange for ``callback(*args)`` to be called approximately ``delay`` seconds in - the future, once, unless cancelled. Returns - a ``Handle`` object representing the callback, whose - ``cancel()`` method can be used to cancel the callback. - If ``delay`` is <= 0, this acts like ``call_soon()`` instead. - Otherwise, callbacks scheduled for exactly the same time will be - called in an undefined order. + the future, once, unless cancelled. Returns a Handle representing + the callback, whose ``cancel()`` method can be used to cancel the + callback. If ``delay`` is <= 0, this acts like ``call_soon()`` + instead. Otherwise, callbacks scheduled for exactly the same time + will be called in an undefined order. - ``call_repeatedly(interval, callback, **args)``. Like ``call_later()`` but calls the callback repeatedly, every (approximately) - ``interval`` seconds, until the ``Handle`` returned is cancelled or + ``interval`` seconds, until the Handle returned is cancelled or the callback raises an exception. The first call is in approximately ``interval`` seconds. If for whatever reason the callback happens later than scheduled, subsequent callbacks will be @@ -390,8 +381,10 @@ loop. This is the *only* method that is safe to call from another thread. (To schedule a callback for a later time in a threadsafe manner, you can use ``loop.call_soon_threadsafe(loop.call_later, - when, callback, *args)``.) This is not safe to call from a signal - handler (since it may use locks). + when, callback, *args)``.) Note: this is not safe to call from a + signal handler (since it may use locks). In fact, no API is + signal-safe; if you want to handle signals, use + ``add_signal_handler()`` described below. - ``wrap_future(future)``. This takes a PEP 3148 Future (i.e., an instance of ``concurrent.futures.Future``) and returns a Future @@ -435,6 +428,13 @@ implement their own DNS lookup. The optional arguments *must* be specified as keyword arguments. + Note: implementations are required to implement a subset of the full + socket.getaddrinfo() interface; e.g. they may not support symbolic + port names, or they may ignore or incompletely implement the type, + proto and flags arguments. However, if ``type`` and ``proto`` are + ignored, the argument values should be reflected unchanged in the + return tuples' ``socket_type`` and ``socket_protocol`` elements. + - ``getnameinfo(sockaddr, flags=0)``. Similar to ``socket.getnameinfo()`` but returns a Future. The Future's result on success will be a tuple ``(host, port)``. Same implementation @@ -512,9 +512,10 @@ Optional keyword arguments: - - ``ssl``: Pass ``True`` to create an SSL transport (by default a - plain TCP transport is created). Or pass an ``ssl.SSLContext`` - object to override the default SSL context object to be used. + - ``ssl``: Pass an ``ssl.SSLContext`` object to override the default + SSL context object to be used. (Unlike ``create_connection()``, + passing ``True`` does not make sense -- the ``SSLContext`` object + is required to specify the certificate and key.) - ``backlog``: Backlog value to be passed to the ``listen()`` call. Defaults to ``100``. @@ -538,7 +539,10 @@ - ``stop_serving(sock)``. The argument should be a socket from the list returned by ``start_serving()``. The serving loop associated with that socket will be stopped. Connections that have already - been accepted will not be affected. + been accepted will not be affected. (TBD: What if + ``start_serving()`` doesn't use sockets? Then it should probably + return a list of opaque objects that can be passed to + ``stop_serving()``.) - ``create_datagram_endpoint(protocol_factory, local_addr, remote_addr, **kwds)``. Creates an endpoint for sending and @@ -645,14 +649,12 @@ - ``add_reader(fd, callback, *args)``. Arrange for ``callback(*args)`` to be called whenever file descriptor ``fd`` is - deemed ready for reading. Returns a ``Handle`` object which can be - used to cancel the callback. Note that, unlike ``call_later()``, - the callback may be called many times. Calling ``add_reader()`` - again for the same file descriptor implies a call to - ``remove_reader()`` for the same file descriptor. Note that, - although cancelling the ``Handle`` returned is nearly equivalent to - calling ``remove_reader()``, it is strongly preferred to call - ``remove_reader()``. + deemed ready for reading. Returns a Handle object which can be used + to cancel the callback. (However, it is strongly preferred to use + ``remove_reader()`` instead.) Calling ``add_reader()`` again for + the same file descriptor implies a call to ``remove_reader()`` for + the same file descriptor. (TBD: Since cancelling the Handle is not + recommended, perhaps we should return None instead?) - ``add_writer(fd, callback, *args)``. Like ``add_reader()``, but registers the callback for writing instead of for reading. @@ -661,7 +663,7 @@ descriptor ``fd``, if one is set. If no callback is currently set for the file descriptor, this is a no-op and returns ``False``. Otherwise, it removes the callback arrangement, cancels the - corresponding ``Handle``, and returns ``True``. + corresponding Handle, and returns ``True``. - ``remove_writer(fd)``. This is to ``add_writer()`` as ``remove_reader()`` is to ``add_reader()``. @@ -669,6 +671,10 @@ Pipes and Subprocesses '''''''''''''''''''''' +TBD: Should these really take stream objects? The stream objects are +not useful for reading or writing because they would cause blocking +I/O. This section of the API is clearly not yet ready for review. + - ``connect_read_pipe(protocol_factory, pipe)``: Create a unidrectional stream connection from a file-like object wrapping the read end of a UNIX pipe. The protocol/transport interface is the @@ -692,7 +698,7 @@ - ``add_signal_handler(sig, callback, *args). Whenever signal ``sig`` is received, arrange for ``callback(*args)`` to be called. Returns - a ``Handle`` which can be used to cancel the signal callback. + a Handle which can be used to cancel the signal callback. (Cancelling the handle causes ``remove_signal_handler()`` to be called the next time the signal arrives. Explicitly calling ``remove_signal_handler()`` is preferred.) @@ -761,48 +767,17 @@ and ``SystemExit``; it is usually unwise to treat these the same as most other exceptions.) -The Handle Class ----------------- +Handles +------- -The various methods for registering callbacks (e.g. ``call_later()``) -all return an object representing the registration that can be used to -cancel the callback. For want of a better name this object is called -a ``Handle``, although the user never needs to instantiate -instances of this class. There is one public method: +The various methods for registering callbacks (e.g. ``call_soon()`` +and ``add_reader()``) all return an object representing the +registration that can be used to cancel the callback. This object is +called a Handle (although its class name is not necessarily +``Handle``). Handles are opaque and have only one public method: -- ``cancel()``. Cancel the callback. This just sets the - ``cancelled`` attribute. The event loop must check this. +- ``cancel()``. Cancel the callback. -- ``run()``. Call the callback with the specified arguments. If this - raises an exception, it is logged and the function returns normally. - This always returns None. Note that this ignores the ``cancelled`` - attribute (i.e., a cancelled ``Handle`` can still be called). - -Read-only public attributes: - -- ``callback``. The callback function to be called. - -- ``args``. The argument tuple with which to call the callback function. - -- ``cancelled``. True if ``cancel()`` has been called. - -Note that some callbacks (e.g. those registered with ``call_later()``) -are meant to be called only once. Others (e.g. those registered with -``call_repeatedly()`` or ``add_reader()``) are meant to be called -multiple times. - -The Timer Subclass -'''''''''''''''''' - -``Timer`` is a subclass of ``Handle`` returned by ``call_later()`` and -``call_repeatedly()``. - -It has one additional read-only public attribute: - -- ``when``, the real time when the callback is next scheduled to be - called. - -``Timer`` objects are ordered by their ``when`` field. Futures ------- @@ -989,7 +964,9 @@ *which* end is closed.) - ``can_write_eof()``. Return ``True`` if the protocol supports - ``write_eof()``, ``False`` if it does not. (This method is needed + ``write_eof()``, ``False`` if it does not. (This method typically + returns a fixed value that depends only on the specific Transport + class, not on the state of the Transport object. It is needed because some protocols need to change their behavior when ``write_eof()`` is unavailable. For example, in HTTP, to send data whose size is not known ahead of time, the end of the data is @@ -1079,6 +1056,8 @@ Protocols --------- +XXX This is about where I left off. + TBD Describe different kinds of protocols (bidrectional stream, unidirectional stream, datagram). @@ -1332,41 +1311,38 @@ Open Issues =========== +- A ``time()`` method that returns the time according to the function + used by the scheduler (e.g. ``time.monotonic()`` in Tulip's case)? + What's the use case? + +- A fuller public API for Handle? What's the use case? + +- Should we require all event loops to implement ``sock_recv()`` and + friends? Is the use case strong enough? (Maybe some transports + usable with both ``SelectorEventLoop`` and ``ProactorEventLoop`` use + them? That'd be a good enough use case for me.) + +- Should we require callers of ``create_connection()`` to create and + pass an ``SSLContext`` explicitly, instead of allowing ssl=True? + (For ``start_serving()`` we already require an ``SSLContext``.) + - A debugging API? E.g. something that logs a lot of stuff, or logs unusual conditions (like queues filling up faster than they drain) or even callbacks taking too much time... - Do we need introspection APIs? E.g. asking for the read callback given a file descriptor. Or when the next scheduled call is. Or - the list of file descriptors registered with callbacks. + the list of file descriptors registered with callbacks. Right now + these would all require using Tulip internals. -- Transports may need a method that tries to return the address of the - socket (and another for the peer address). Although these depend on - the socket type and there may not always be a socket; then it should - return None. (Alternatively, there could be a method to return the - socket itself -- but it is conceivable that a transport implements - IP connections without using sockets, and what should it do then?) +- Locks and queues? The Tulip implementation contains implementations + of most types of locks and queues modeled after the stdlib + ``threading`` and ``queue`` modules. Should we incorporate these in + the PEP? -- Need to handle os.fork(). (This may be up to the selector classes - in Tulip's case.) - -- Perhaps start_serving() needs a way to pass in an existing socket - (e.g. gunicorn would need this). Ditto for create_connection(). - -- We might introduce explicit locks, though these will be a bit of a - pain to use, as we can't use the ``with lock: block`` syntax - (because to wait for a lock we'd have to use ``yield from``, which - the ``with`` statement can't do). - -- Support for datagram protocols, "connected" or otherwise. Probably - need more socket I/O methods, e.g. ``sock_sendto()`` and - ``sock_recvfrom()``. Or users can write their own (it's not rocket - science). Is it reasonable to map ``write()``, ``writelines()``, - ``data_received()`` to single datagrams? Or should we have a - different ``datagram_received()`` method on datagram protocols? - (Glyph recommends the latter.) And then what instead of ``write()``? - Finally, do we need support for unconnected datagram protocols? - (That would mean wrappers for ``sendto()`` and ``recvfrom()``.) +- Probably need more socket I/O methods, e.g. ``sock_sendto()`` and + ``sock_recvfrom()``, and perhaps others like ``pipe_read()``. Or + users can write their own (it's not rocket science). - We may need APIs to control various timeouts. E.g. we may want to limit the time spent in DNS resolution, connecting, ssl handshake, @@ -1377,12 +1353,6 @@ operations need default timeouts, and we may want to change the default for a specific operation globally (i.e., per event loop). -- An EventEmitter in the style of NodeJS? Or make this a separate - PEP? It's easy enough to do in user space, though it may benefit - from standardization. (See - https://github.com/mnot/thor/blob/master/thor/events.py and - https://github.com/mnot/thor/blob/master/doc/events.md for examples.) - References ========== -- Repository URL: http://hg.python.org/peps

1 0

cpython (merge 3.3 -> default): merge 3.3 (#17863)
by benjamin.peterson April 29, 2013

April 29, 2013

http://hg.python.org/cpython/rev/97522b189c79 changeset: 83552:97522b189c79 parent: 83550:393723b646a4 parent: 83551:68d1ac152b5d user: Benjamin Peterson <benjamin(a)python.org> date: Mon Apr 29 10:23:31 2013 -0400 summary: merge 3.3 (#17863) files: Misc/NEWS | 3 +++ Python/pythonrun.c | 17 ++++++++--------- 2 files changed, 11 insertions(+), 9 deletions(-) diff --git a/Misc/NEWS b/Misc/NEWS --- a/Misc/NEWS +++ b/Misc/NEWS @@ -10,6 +10,9 @@ Core and Builtins ----------------- +- Issue #17863: In the interactive console, don't loop forever if the encoding + can't be fetched from stdin. + - Issue #17867: Raise an ImportError if __import__ is not found in __builtins__. - Issue #17857: Prevent build failures with pre-3.5.0 versions of sqlite3, diff --git a/Python/pythonrun.c b/Python/pythonrun.c --- a/Python/pythonrun.c +++ b/Python/pythonrun.c @@ -1255,16 +1255,15 @@ _Py_IDENTIFIER(encoding); if (fp == stdin) { - /* Fetch encoding from sys.stdin */ + /* Fetch encoding from sys.stdin if possible. */ v = PySys_GetObject("stdin"); - if (v == NULL || v == Py_None) - return -1; - oenc = _PyObject_GetAttrId(v, &PyId_encoding); - if (!oenc) - return -1; - enc = _PyUnicode_AsString(oenc); - if (enc == NULL) - return -1; + if (v && v != Py_None) { + oenc = _PyObject_GetAttrId(v, &PyId_encoding); + if (oenc) + enc = _PyUnicode_AsString(oenc); + if (!enc) + PyErr_Clear(); + } } v = PySys_GetObject("ps1"); if (v != NULL) { -- Repository URL: http://hg.python.org/cpython

1 0

cpython (3.3): ignore errors when trying to fetch sys.stdin.encoding (closes #17863)
by benjamin.peterson April 29, 2013

April 29, 2013

http://hg.python.org/cpython/rev/68d1ac152b5d changeset: 83551:68d1ac152b5d branch: 3.3 parent: 83549:08ce30768003 user: Benjamin Peterson <benjamin(a)python.org> date: Mon Apr 29 10:23:08 2013 -0400 summary: ignore errors when trying to fetch sys.stdin.encoding (closes #17863) files: Misc/NEWS | 3 +++ Python/pythonrun.c | 17 ++++++++--------- 2 files changed, 11 insertions(+), 9 deletions(-) diff --git a/Misc/NEWS b/Misc/NEWS --- a/Misc/NEWS +++ b/Misc/NEWS @@ -12,6 +12,9 @@ Core and Builtins ----------------- +- Issue #17863: In the interactive console, don't loop forever if the encoding + can't be fetched from stdin. + - Issue #17867: Raise an ImportError if __import__ is not found in __builtins__. - Issue #17857: Prevent build failures with pre-3.5.0 versions of sqlite3, diff --git a/Python/pythonrun.c b/Python/pythonrun.c --- a/Python/pythonrun.c +++ b/Python/pythonrun.c @@ -1237,16 +1237,15 @@ _Py_IDENTIFIER(encoding); if (fp == stdin) { - /* Fetch encoding from sys.stdin */ + /* Fetch encoding from sys.stdin if possible. */ v = PySys_GetObject("stdin"); - if (v == NULL || v == Py_None) - return -1; - oenc = _PyObject_GetAttrId(v, &PyId_encoding); - if (!oenc) - return -1; - enc = _PyUnicode_AsString(oenc); - if (enc == NULL) - return -1; + if (v && v != Py_None) { + oenc = _PyObject_GetAttrId(v, &PyId_encoding); + if (oenc) + enc = _PyUnicode_AsString(oenc); + if (!enc) + PyErr_Clear(); + } } v = PySys_GetObject("ps1"); if (v != NULL) { -- Repository URL: http://hg.python.org/cpython

1 0

cpython (merge 3.3 -> default): merge 3.3
by benjamin.peterson April 29, 2013

April 29, 2013

http://hg.python.org/cpython/rev/393723b646a4 changeset: 83550:393723b646a4 parent: 83547:7a45415956b9 parent: 83549:08ce30768003 user: Benjamin Peterson <benjamin(a)python.org> date: Mon Apr 29 09:08:33 2013 -0400 summary: merge 3.3 files: Lib/test/test_import.py | 7 +++++++ Misc/NEWS | 2 ++ Python/import.c | 3 ++- 3 files changed, 11 insertions(+), 1 deletions(-) diff --git a/Lib/test/test_import.py b/Lib/test/test_import.py --- a/Lib/test/test_import.py +++ b/Lib/test/test_import.py @@ -324,6 +324,13 @@ except ImportError: self.fail("fromlist must allow bogus names") + @cpython_only + def test_delete_builtins_import(self): + args = ["-c", "del __builtins__.__import__; import os"] + popen = script_helper.spawn_python(*args) + stdout, stderr = popen.communicate() + self.assertIn(b"ImportError", stdout) + @skip_if_dont_write_bytecode class FilePermissionTests(unittest.TestCase): diff --git a/Misc/NEWS b/Misc/NEWS --- a/Misc/NEWS +++ b/Misc/NEWS @@ -10,6 +10,8 @@ Core and Builtins ----------------- +- Issue #17867: Raise an ImportError if __import__ is not found in __builtins__. + - Issue #17857: Prevent build failures with pre-3.5.0 versions of sqlite3, such as was shipped with Centos 5 and Mac OS X 10.4. diff --git a/Python/import.c b/Python/import.c --- a/Python/import.c +++ b/Python/import.c @@ -1403,7 +1403,8 @@ if (builtins_import == NULL) { builtins_import = _PyDict_GetItemId(interp->builtins, &PyId___import__); if (builtins_import == NULL) { - Py_FatalError("__import__ missing"); + PyErr_SetString(PyExc_ImportError, "__import__ not found"); + goto error_with_unlock; } } Py_INCREF(builtins_import); -- Repository URL: http://hg.python.org/cpython

1 0

cpython (3.3): raise an ImportError (rather than fatal) when __import__ is not found in
by benjamin.peterson April 29, 2013

April 29, 2013

http://hg.python.org/cpython/rev/08ce30768003 changeset: 83549:08ce30768003 branch: 3.3 parent: 83546:122d42d5268e user: Benjamin Peterson <benjamin(a)python.org> date: Mon Apr 29 09:08:14 2013 -0400 summary: raise an ImportError (rather than fatal) when __import__ is not found in __builtins__ (closes #17867) files: Lib/test/test_import.py | 7 +++++++ Misc/NEWS | 2 ++ Python/import.c | 3 ++- 3 files changed, 11 insertions(+), 1 deletions(-) diff --git a/Lib/test/test_import.py b/Lib/test/test_import.py --- a/Lib/test/test_import.py +++ b/Lib/test/test_import.py @@ -324,6 +324,13 @@ except ImportError: self.fail("fromlist must allow bogus names") + @cpython_only + def test_delete_builtins_import(self): + args = ["-c", "del __builtins__.__import__; import os"] + popen = script_helper.spawn_python(*args) + stdout, stderr = popen.communicate() + self.assertIn(b"ImportError", stdout) + @skip_if_dont_write_bytecode class FilePermissionTests(unittest.TestCase): diff --git a/Misc/NEWS b/Misc/NEWS --- a/Misc/NEWS +++ b/Misc/NEWS @@ -12,6 +12,8 @@ Core and Builtins ----------------- +- Issue #17867: Raise an ImportError if __import__ is not found in __builtins__. + - Issue #17857: Prevent build failures with pre-3.5.0 versions of sqlite3, such as was shipped with Centos 5 and Mac OS X 10.4. diff --git a/Python/import.c b/Python/import.c --- a/Python/import.c +++ b/Python/import.c @@ -1389,7 +1389,8 @@ if (builtins_import == NULL) { builtins_import = _PyDict_GetItemId(interp->builtins, &PyId___import__); if (builtins_import == NULL) { - Py_FatalError("__import__ missing"); + PyErr_SetString(PyExc_ImportError, "__import__ not found"); + goto error_with_unlock; } } Py_INCREF(builtins_import); -- Repository URL: http://hg.python.org/cpython

1 0

cpython (2.7): #17866: mention that in Python 3, assertItemsEqual is named assertCountEqual.
by ezio.melotti April 29, 2013

April 29, 2013

http://hg.python.org/cpython/rev/d9921cb6e3cd changeset: 83548:d9921cb6e3cd branch: 2.7 parent: 83545:5da7bb478dd9 user: Ezio Melotti <ezio.melotti(a)gmail.com> date: Mon Apr 29 12:26:01 2013 +0300 summary: #17866: mention that in Python 3, assertItemsEqual is named assertCountEqual. files: Doc/library/unittest.rst | 2 ++ 1 files changed, 2 insertions(+), 0 deletions(-) diff --git a/Doc/library/unittest.rst b/Doc/library/unittest.rst --- a/Doc/library/unittest.rst +++ b/Doc/library/unittest.rst @@ -1075,6 +1075,8 @@ sorted(actual))`` but it works with sequences of unhashable objects as well. + In Python 3, this method is named ``assertCountEqual``. + .. versionadded:: 2.7 -- Repository URL: http://hg.python.org/cpython

1 0

Daily reference leaks (7a45415956b9): sum=0
by solipsis＠pitrou.net April 29, 2013

April 29, 2013

results for 7a45415956b9 on branch "default" -------------------------------------------- Command line was: ['./python', '-m', 'test.regrtest', '-uall', '-R', '3:3:/home/antoine/cpython/refleaks/reflogQXuvbG', '-x']

1 0

cpython (merge 3.3 -> default): Null merge, DataHandler exists in 3.4.
by r.david.murray April 28, 2013

April 28, 2013

http://hg.python.org/cpython/rev/7a45415956b9 changeset: 83547:7a45415956b9 parent: 83542:be6bbc9f0561 parent: 83546:122d42d5268e user: R David Murray <rdmurray(a)bitdance.com> date: Sun Apr 28 17:07:16 2013 -0400 summary: Null merge, DataHandler exists in 3.4. files: -- Repository URL: http://hg.python.org/cpython

1 0

cpython (3.3): #7152: Remove incorrectly added reference to DataHandler.
by r.david.murray April 28, 2013

April 28, 2013

http://hg.python.org/cpython/rev/122d42d5268e changeset: 83546:122d42d5268e branch: 3.3 parent: 83541:3dcc81c2eef5 user: R David Murray <rdmurray(a)bitdance.com> date: Sun Apr 28 17:06:01 2013 -0400 summary: #7152: Remove incorrectly added reference to DataHandler. files: Doc/howto/urllib2.rst | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/Doc/howto/urllib2.rst b/Doc/howto/urllib2.rst --- a/Doc/howto/urllib2.rst +++ b/Doc/howto/urllib2.rst @@ -507,7 +507,7 @@ -- ``ProxyHandler`` (if a proxy setting such as an :envvar:`http_proxy` environment variable is set), ``UnknownHandler``, ``HTTPHandler``, ``HTTPDefaultErrorHandler``, ``HTTPRedirectHandler``, ``FTPHandler``, - ``FileHandler``, ``DataHandler``, ``HTTPErrorProcessor``. + ``FileHandler``, ``HTTPErrorProcessor``. ``top_level_url`` is in fact *either* a full URL (including the 'http:' scheme component and the hostname and optionally the port number) -- Repository URL: http://hg.python.org/cpython

1 0