traceback.print_exc

All Samples(8268) | Call(7727) | Derive(0) | Import(541)

Shorthand for 'print_exception(sys.exc_type, sys.exc_value, sys.exc_traceback, limit, file)'.
(In fact, it uses sys.exc_info() to retrieve the same information
in a thread-safe way.)

Show Implementation

        def print_exc(limit=None, file=None):
    """Shorthand for 'print_exception(sys.exc_type, sys.exc_value, sys.exc_traceback, limit, file)'.
    (In fact, it uses sys.exc_info() to retrieve the same information
    in a thread-safe way.)"""
    if file is None:
        file = sys.stderr
    try:
        etype, value, tb = sys.exc_info()
        print_exception(etype, value, tb, limit, file)
    finally:
        etype = value = tb = None

src/d/b/dbus-python-egg-HEAD/examples/example-client.py dbus-python-egg(Download)

# DEALINGS IN THE SOFTWARE.
 
import sys
from traceback import print_exc
 
import dbus

        hello_reply_list = remote_object.HelloWorld("Hello from example-client.py!",
            dbus_interface = "com.example.SampleInterface")
    except dbus.DBusException:
        print_exc()
        print usage
        sys.exit(1)

src/p/y/pycuda-0.94.1/examples/download-examples-from-wiki.py pycuda(Download)

 
    except Exception, e:
        print "Error when processing %s: %s" % (page, e)
        from traceback import print_exc
        print_exc()

src/p/l/plomino-HEAD/trunk/Plomino/Products/CMFPlomino/PlominoDesignManager.py plomino(Download)

 
from Products.CMFPlomino.config import *
 
from traceback import print_exc
from Acquisition import *
from index.PlominoIndex import PlominoIndex
from Products.CMFPlomino.exceptions import PlominoDesignException

    def traceErr(self, e, context, script_id, formula_getter):
        """trace errors from Scripts
        """
        if self.debugMode:
            #traceback
            f = StringIO()
            print_exc(limit=50, file=f)

    def traceRenderingErr(self, e, context):
        """trace rendering errors
        """
        if self.debugMode:
            #traceback
            f = StringIO()
            print_exc(limit=50, file=f)

src/p/l/plomino-HEAD/Plomino/Products/CMFPlomino/PlominoDesignManager.py plomino(Download)

 
from Products.CMFPlomino.config import *
 
from traceback import print_exc
from Acquisition import *
from index.PlominoIndex import PlominoIndex
from Products.CMFPlomino.exceptions import PlominoDesignException

    def traceErr(self, e, context, script_id, formula_getter):
        """trace errors from Scripts
        """
        if self.debugMode:
            #traceback
            f = StringIO()
            print_exc(limit=50, file=f)

    def traceRenderingErr(self, e, context):
        """trace rendering errors
        """
        if self.debugMode:
            #traceback
            f = StringIO()
            print_exc(limit=50, file=f)

src/p/l/Plomino-1.7.5/Products/CMFPlomino/PlominoDesignManager.py Plomino(Download)

 
from Products.CMFPlomino.config import *
 
from traceback import print_exc
from Acquisition import *
from index.PlominoIndex import PlominoIndex
from Products.CMFPlomino.exceptions import PlominoDesignException

    def traceErr(self, e, context, script_id, formula_getter):
        """trace errors from Scripts
        """
        if self.debugMode:
            #traceback
            f = StringIO()
            print_exc(limit=50, file=f)

    def traceRenderingErr(self, e, context):
        """trace rendering errors
        """
        if self.debugMode:
            #traceback
            f = StringIO()
            print_exc(limit=50, file=f)

src/s/i/sippy-HEAD/sippy/Timeout.py sippy(Download)

 
from datetime import datetime
from twisted.internet import task, reactor
from traceback import print_exc, format_list, extract_stack
from sys import stdout
 
class Timeout(object):

    def _run(self, *callback_arguments):
        try:
            self._timeout_callback(*callback_arguments)
        except:
            print datetime.now(), 'Timeout: unhandled exception in timeout callback'
            print '-' * 70
            print_exc(file = stdout)

    def _run_once(self, *callback_arguments):
        try:
            self._timeout_callback(*callback_arguments)
        except:
            print datetime.now(), 'Timeout: unhandled exception in timeout callback'
            print '-' * 70
            print_exc(file = stdout)

    def _run_once(self, *callback_arguments):
        try:
            self._timeout_callback(*callback_arguments)
        except:
            print datetime.now(), 'Timeout: unhandled exception in timeout callback'
            print '-' * 70
            print_exc(file = stdout)

src/o/r/orcatorrent-HEAD/Core/NATFirewall/ReturnConnHandler.py orcatorrent(Download)

from cStringIO import StringIO
from threading import currentThread
from socket import gethostbyname
from traceback import print_exc,print_stack
 
from Tribler.Core.BitTornado.__init__ import createPeerID
from Tribler.Core.BitTornado.BT1.MessageID import protocol_name,option_pattern,getMessageName

                callback(None,dns)
        except Exception,exc:
            if DEBUG:
                print_exc(file=sys.stderr)
            callback(exc,dns)
 
    def _send(self,dns,message,callback):

                callback(None,dns)
        except Exception,exc:
            if DEBUG:
                print_exc(file=sys.stderr)
            callback(exc,dns)

            else:
                oc.close()
        except Exception,e:
            print_exc(file=sys.stderr)
 
    #
    # Interface for SocketHandler

                    self.userconnhandler(None,(oc.get_ip(),oc.get_listen_port()),oc.is_locally_initiated())
                except:
                    # Catchall
                    print_exc(file=sys.stderr)
        return ret
 
    def local_close(self,oc):

            return ret
        except:
            # Catch all
            print_exc(file=sys.stderr)
            return False

            except:
                self.next_len, self.next_func = 1, self.read_dead
                if DEBUG:
                    print_exc(file=sys.stderr)
                raise
            if x is None:
                if DEBUG:

    def dequeue_callbacks(self):
        try:
            for callback in self.cb_queue:
                callback(None,self.specified_dns)
            self.cb_queue = []
        except Exception,e:
            print_exc(file=sys.stderr)

                   print >> sys.stderr,"dlbconn: cleanup_callbacks: callback is",callback
                callback(exc,self.specified_dns)
        except Exception,e:
            print_exc(file=sys.stderr)
 
    #
    # Internal methods

src/o/r/orcatorrent-HEAD/Core/BitTornado/BT1/Rerequester.py orcatorrent(Download)

from Tribler.Core.BitTornado.bencode import bdecode
from threading import Thread, Lock, currentThread
from cStringIO import StringIO
from traceback import print_exc,print_stack
from socket import error, gethostbyname, inet_aton, inet_ntoa
from random import shuffle
from sha import sha

            except (IOError, error), e:
                err = 'Problem connecting to tracker - ' + str(e)
                if DEBUG:
                    print_exc()
            except:
                err = 'Problem connecting to tracker'
                if DEBUG:
                    print_exc()

                check_peers(r)
            except ValueError, e:
                if DEBUG:
                    print_exc()
                if self.lock.trip(l):
                    self.errorcodes['bad_data'] = 'bad data from tracker - ' + str(e)
                    self.lock.unwait(l)

        except:
            print >>sys.stderr,"Rerequester: Error in postrequest"
            import traceback
            traceback.print_exc()
 
    def exception(self, callback):
        data = StringIO()
        print_exc(file = data)

src/k/a/kamaelia-HEAD/trunk/Sketches/RJL/bittorrent/BitTorrent/BitTorrent/RawServer.py kamaelia(Download)

import thread
from bisect import insort
from cStringIO import StringIO
from traceback import print_exc
from errno import EWOULDBLOCK, ENOBUFS, EINTR
 
from BitTorrent.platform import bttime

                code = e
            if code == ENOBUFS:
                # log the traceback so we can see where the exception is coming from
                print_exc(file = sys.stderr)
                self.errorfunc(CRITICAL,
                               _("Have to exit due to the TCP stack flaking "
                                 "out. Please see the FAQ at %s") % FAQ_URL)

                self.errorfunc(CRITICAL, str(e))
            return 0
        except KeyboardInterrupt:
            print_exc()
            return -1
        except:
            data = StringIO()
            print_exc(file=data)

                context = socket.context
            if self.noisy and context is None:
                data = StringIO()
                print_exc(file=data)
                self.errorfunc(CRITICAL, data.getvalue())
            if context is not None:
                context.got_exception(e)

src/k/a/kamaelia-HEAD/Sketches/RJL/bittorrent/BitTorrent/BitTorrent/RawServer.py kamaelia(Download)

import thread
from bisect import insort
from cStringIO import StringIO
from traceback import print_exc
from errno import EWOULDBLOCK, ENOBUFS, EINTR
 
from BitTorrent.platform import bttime

                code = e
            if code == ENOBUFS:
                # log the traceback so we can see where the exception is coming from
                print_exc(file = sys.stderr)
                self.errorfunc(CRITICAL,
                               _("Have to exit due to the TCP stack flaking "
                                 "out. Please see the FAQ at %s") % FAQ_URL)

                self.errorfunc(CRITICAL, str(e))
            return 0
        except KeyboardInterrupt:
            print_exc()
            return -1
        except:
            data = StringIO()
            print_exc(file=data)

                context = socket.context
            if self.noisy and context is None:
                data = StringIO()
                print_exc(file=data)
                self.errorfunc(CRITICAL, data.getvalue())
            if context is not None:
                context.got_exception(e)

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 Next