[Hiisi]

Do you have any ideas to handle unexpected errors raised by functions which are called by users? Here is a simple example.

import sys
import e32
import appuifw

def raise_nameerror():
    """Raise NameError"""
    # foo = u'bar'
    foo

def main():
    """Main thread."""
    script_lock = e32.Ao_lock()
    appuifw.app.title = u'RaiseErrorTest'
    appuifw.app.body = appuifw.Text()
    appuifw.app.menu = [(u'Raise NameError', raise_nameerror),
                        (u'Exit', script_lock.signal)]
    appuifw.app.exit_key_handler = script_lock.signal
    script_lock.wait()

if __name__ == '__main__':
    try:
        main()
    except:
        appuifw.note(unicode(str(sys.exc_info()[0])), 'error')

I intend to catch exceptions with the last line, but as a result, I can't. (this script just keeps running) The only thing I can get is a traceback displayed in Python Script Shell AFTER stopping this script.

Meanwhile, if the functions containing error are called by script itself (not by users), error handling works fine.

import sys
import e32
import appuifw

def raise_nameerror():
    """Raise NameError"""
    # foo = u'bar'
    foo

def main():
    """Main thread."""
    raise_nameerror()

if __name__ == '__main__':
    try:
        main()
    except:
        appuifw.note(unicode(str(sys.exc_info()[0])), 'error')

If I can expect a function to raise exceptions, I can add "try and except" statement to such function in advance. (e.g. handling file may raise IOError etc.) But at the debugging stage, I can not expect which function may raise exceptions because of a lot of coding errors

I've referred to the article below, but this doesn't help me. So, if you have any good ideas to debug scripts quickly and efficiently, please let me know.

Python debugging techniques [Forum Nokia Wiki]

[jethro.fn]

Exceptions from callbacks are not propagated to the "main thread" (in quotes because no real threading is going on in the background, only Symbian active objects).

You can wrap each callback in a function that collects the exception in a global list and signals the lock you're waiting. You can then handle exceptions collected in the list sequentially when the lock is signalled.

Here's the concept in code. It's crude and I have not tested it myself.

import traceback

# Exceptions from callbacks are collected here.
exceptions = []

# Decorator for callback functions
def collect_exception(func):
  # Using Python (>v2.2) nested scopes.
  def callit(*args, **kwds):
    global script_lock
    try:
      return func(*args, **kwds)
    except:
      excstr = "\n".join(traceback.format_exception(*sys.exc_info()))
      exceptions.append(excstr)  # Store exception string in a list.
      script_lock.signal()       # Notify main function about exception.
      raise                      # Re-raise exception, just in case.
  return callit

...

def main():
  global exceptions, script_lock

  script_lock = e32.Ao_lock()

  ...

  appuifw.app.menu = [(u'Raise NameError',
                       collect_exception(raise_nameerror)),
                      (u'Exit', 
                       script_lock.signal)]

  ...

  script_lock.wait()

  # Report exceptions. Could be more than one, in theory.
  for excstr in exceptions:
    appuifw.note(unicode(excstr), 'error')
  exceptions = []  # All exceptions accounted for, clear list.

EDIT: Whoops, there's no push() method on Lists. Changed to append().

[cyke64]

Originally Posted by Hiisi

Do you have any ideas to handle unexpected errors raised by functions which are called by users? Here is a simple example.

import sys
import e32
import appuifw

def raise_nameerror():
    """Raise NameError"""
    # foo = u'bar'
    foo

def main():
    """Main thread."""
    script_lock = e32.Ao_lock()
    appuifw.app.title = u'RaiseErrorTest'
    appuifw.app.body = appuifw.Text()
    appuifw.app.menu = [(u'Raise NameError', raise_nameerror),
                        (u'Exit', script_lock.signal)]
    appuifw.app.exit_key_handler = script_lock.signal
    script_lock.wait()

if __name__ == '__main__':
    try:
        main()
    except:
        appuifw.note(unicode(str(sys.exc_info()[0])), 'error')

I intend to catch exceptions with the last line, but as a result, I can't. (this script just keeps running) The only thing I can get is a traceback displayed in Python Script Shell AFTER stopping this script.

Meanwhile, if the functions containing error are called by script itself (not by users), error handling works fine.

import sys
import e32
import appuifw

def raise_nameerror():
    """Raise NameError"""
    # foo = u'bar'
    foo

def main():
    """Main thread."""
    raise_nameerror()

if __name__ == '__main__':
    try:
        main()
    except:
        appuifw.note(unicode(str(sys.exc_info()[0])), 'error')

If I can expect a function to raise exceptions, I can add "try and except" statement to such function in advance. (e.g. handling file may raise IOError etc.) But at the debugging stage, I can not expect which function may raise exceptions because of a lot of coding errors

I've referred to the article below, but this doesn't help me. So, if you have any good ideas to debug scripts quickly and efficiently, please let me know.

Python debugging techniques [Forum Nokia Wiki]

Hello ,

Try this little module HERE and follow this method
I hope you have success with it :-)

BR
Cyke64

[Hiisi]

Thank you for your quick replies.

I've integrated your two approaches into my sample script. (in order to show you a whole script)

import sys
import e32
import appuifw
import linecache

# Dubugging Level (0: Release, 1: Show Traceback, 2: Trace All)
debuglevel = 1

# Exceptions from callbacks are stored here.
exceptions = []

class Trace:
    """Class for tracing script
    
    This class is developed by cyke64.
    Lisenced under GNU GPL.
    """
    def __init__(self, runfile, f_all=u'E:\\Python\\traceit.txt',
                 f_main=u'E:\\Python\\traceitmain.txt'):
        self.out_all=open(f_all, 'w')
        self.out_main=open(f_main, 'w')
        self.runfile = runfile
      
    def go(self):
        sys.settrace(self.traceit)
    
    def stop(self):    
        sys.settrace(None)
        self.out_all.close()
        self.out_main.close()

    def traceit(self, frame, event, arg):
        lineno = frame.f_lineno
        name = frame.f_globals['__name__']
        if (frame.f_globals).has_key('__file__'):
            file_trace=frame.f_globals['__file__']
            line = linecache.getline(file_trace, lineno)
        else:
            file_trace = self.runfile
            line = linecache.getline(file_trace, lineno)
            self.out_main.write('%s*%s*\n*%s*\n' \
              % (event, lineno, line.rstrip()))
            self.out_all.write('%s*%s*of %s(%s)\n*%s*\n' \
              %(event, lineno, name, file_trace, line.rstrip()))
            e32.ao_sleep(0)
        return self.traceit

def call_callback(func):
    """Catch exeption
    
    This function is developed by jethro.fn.
    """
    def call_func(*args, **kwds):
        import traceback
        global exceptions
        global script_lock
        try:
            return func(*args, **kwds)
        except:
            # Collect Exceptions
            exception = ''.join(traceback.format_exception(*sys.exc_info()))
            exceptions.append(exception)
            
            # Signal lock in main thread (immediate termination)
            if debuglevel == 2: script_lock.signal()
    return call_func

def raise_nameerror():
    """Raise NameError"""
    # foo = u'bar'
    foo

def main():
    """Main thread"""
    global script_lock
    global exceptions
    
    # main UI
    script_lock = e32.Ao_lock()
    appuifw.app.title = u'RaiseErrorTest'
    appuifw.app.body = appuifw.Text()
    appuifw.app.menu = [(u'Raise NameError',
                           call_callback(raise_nameerror)),
                        (u'Exit', script_lock.signal)]
    appuifw.app.exit_key_handler = script_lock.signal
    script_lock.wait()
    
    # Handling exception
    if debuglevel and exceptions:
        show_traceback(exceptions)
        exceptions = []

def show_traceback(exceptions):
    """Show traceback"""
    appuifw.app.title = u'Traceback'
    traceback = '%d error(s) occurred.\n\n' % len(exceptions)
    for exception in  exceptions:
        traceback += '%s\n' % exception
    body = appuifw.Text(unicode(traceback))
    body.set_pos(0)
    appuifw.app.body = body
    appuifw.app.menu = [(u'Exit', script_lock.signal)]
    script_lock.wait()

if __name__ == '__main__':
    try:
        if debuglevel == 2:
            trace = Trace('E:\\Python\\RaiseErrorTest.py')
            trace.go()
            main()
            trace.stop()
        else:
            main()
    except:
        raise

It works lovely and surely helps me develop my applications.

Thank you again for your advices! Maybe I have to learn more and more about Python

[jethro.fn]

Originally Posted by Hiisi

I've integrated your two approaches into my sample script. (in order to show you a whole script)

...

It works lovely and surely helps me develop my applications.

Wow. Seems pretty thorough. You wont miss a single exception with that thing...

[cyke64]

Originally Posted by jethro.fn

Wow. Seems pretty thorough. You wont miss a single exception with that thing...

YES !
Now we have a complete debugging tool because of Hiisi
You have a great blog on PyS60
Could you announce your most useful free applications(PyTask Server,PyBSLog and WAPlib) on DiBo ?
You could also add them to wiki application
I have added both debugging method + your very useful mixed method to the python debugging technics wiki page !

Happy debugging
Cyke64

[Hiisi]

Originally Posted by cyke64

You have a great blog on PyS60
Could you announce your most useful free applications(PyTask Server,PyBSLog and WAPlib) on DiBo ?
You could also add them to wiki application

I've prepared a new simple Web page for distributing my free software: PyTaskServer, PyReboot, PyTwitterS60, and waplib module. (As for PyBSLog, I'm now preparing a document for it and can't announce it officially.) I'm new to Python language, so codes may be primitive. But at least, I'm trying to follow PEP 8.

I don't know how to announce my applications on this discussion board. (I'm also new to this community.) Could you tell me how to do that?

Thank you for your encouragement, cyke64

[gaba88]

Originally Posted by Hiisi

I don't know how to announce my applications on this discussion board. (I'm also new to this community.) Could you tell me how to do that?

Hi Hiisi
first of all congrats for your so nice applications.
and its very easy to announce something in the discussion boards. Just start a new thread with the title of your new application and thats all.

Enjoy Pythoning
Gaba88

[cyke64]

Originally Posted by gaba88

Hi Hiisi
first of all congrats for your so nice applications.
and its very easy to announce something in the discussion boards. Just start a new thread with the title of your new application and thats all.

Enjoy Pythoning
Gaba88

As Gaba88 said to you just add in the the announce something like this (don't forget to add [announce] header !)

[announce] PyTwitterS60 0.0.2 : simplest Twitter client on PyS60

You could also add these applications in the new application page of PyS60 wiki

Happy pythoning
Cyke64

[Hiisi]

Thank you, gaba88 and cyke64.
I will try it later

[gaba88]

Originally Posted by Hiisi

Thank you, gaba88 and cyke64.
I will try it later

hi hiisi
we all will be waiting for your application

Enjoy Pythoning
Gaba88