Exceptions and modules

Discussion in 'Python' started by sam, Jul 4, 2003.

  1. sam

    sam Guest

    Hello,

    consider the following code:

    <module1>
    import sys
    import threading

    class MyException(Exception):
    pass

    #from module1 import MyException

    class runner(threading.Thread):
    def __init__(self, callableObj):
    self.callableObject=callableObj
    threading.Thread.__init__(self)
    def run(self):
    try:
    self.callableObject.makeCall()
    except MyException, err:
    print "MyException"
    print sys.exc_type, err
    except Exception, err:
    print "Exception"
    print sys.exc_type, err

    if __name__ == '__main__':
    if len(sys.argv) != 3:
    print "Usage <module> <class>"
    else:
    callableObj = getattr(__import__(sys.argv[1]), sys.argv[2])()
    thread=runner(callableObj)
    thread.start()
    </module1>
    <module2>
    from module1 import MyException

    class Callable:
    def makeCall(self):
    raise MyException("MyException")
    </module2>

    Now I start the process:

    python module1.py module2 Callable

    And the result is:

    Exception
    module1.MyException MyException

    So the Exception isn't recognised even though it has the same
    namespace and name as the exception defined in the module. I have to
    uncomment the 7th line to get my example to behave as I would like it
    to.

    Is this a bug/feature? Is there any reason why it shouldn't work the
    way I expect it to?

    Regards,

    Sam Owen
    sam, Jul 4, 2003
    #1
    1. Advertising

  2. sam

    Duncan Booth Guest

    (sam) wrote in
    news::

    > So the Exception isn't recognised even though it has the same
    > namespace and name as the exception defined in the module. I have to
    > uncomment the 7th line to get my example to behave as I would like it
    > to.
    >
    > Is this a bug/feature? Is there any reason why it shouldn't work the
    > way I expect it to?


    It's a feature, and it probably ought to be in the FAQ in some form.

    When you run 'python module1.py' the code in the source file module1.py is
    compiled into a module called __main__. That means that the line:

    except MyException, err:

    is actually short for:

    except __main__.MyException, err:

    When module2 imports module1 the code is recompiled into a new module. Same
    source code, but otherwise no relation. You then raise module1.MyException
    which doesn't match __main__.MyException.

    --
    Duncan Booth
    int month(char *p){return(124864/((p[0]+p[1]-p[2]&0x1f)+1)%12)["\5\x8\3"
    "\6\7\xb\1\x9\xa\2\0\4"];} // Who said my code was obscure?
    Duncan Booth, Jul 4, 2003
    #2
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Ahmed Moustafa
    Replies:
    5
    Views:
    30,022
    Chris Smith
    Jul 14, 2004
  2. Paul Miller
    Replies:
    3
    Views:
    1,017
    Alex Martelli
    Nov 12, 2003
  3. Replies:
    3
    Views:
    608
    Sherm Pendley
    Apr 16, 2007
  4. Lie
    Replies:
    3
    Views:
    629
  5. ImpalerCore
    Replies:
    0
    Views:
    834
    ImpalerCore
    Mar 10, 2011
Loading...

Share This Page