Python use alias for inner classes

Question

I have following code sample,

class Outer:
    class InnerException(Exception): pass
    def raise_inner(self):
        raise Outer.InnerException()
    def call_raise(self):
        try:
            self.raise_inner()
        except Outer.InnerException as e:
            print "Handle me"

 Outer().call_raise()

What I wish to do is instead of using Outer.InnerException just use InnerException inside the Outer class, in short something like this

class Outer:
    class InnerException(Exception): pass

    #InnerException = Outer.InnerException .. something like this, create some alias

    def raise_inner(self):
        raise InnerException()
    def call_raise(self):
        try:
            self.raise_inner()
        except InnerException as e:
            print "Handle me"

 Outer().call_raise()

Usual approach in Python: Put the exception class at module scope. — Sven Marnach, Oct 08 '13 at 16:23
See this answer regarding Python's [LEGB Scoping Rules](http://stackoverflow.com/a/292502/355230). — martineau, Oct 08 '13 at 18:08

Marcin · Accepted Answer · 2013-10-08T17:48:39.747

3

You can't just refer to things declared in class scope with a name (unless you are doing so also in class scope).

Either do:

class Outer:
    class InnerException(Exception): pass
    def raise_inner(self):
        raise self.InnerException()

or

class InnerException(Exception): pass
class Outer:
    def raise_inner(self):
        raise InnerException()

edited Oct 08 '13 at 17:48

answered Oct 08 '13 at 16:26

Marcin

46,667
17
117
197

score 1 · Answer 2 · answered Oct 08 '13 at 16:25

The name InnerException is looked up at the time the method is called, so the exception name is a non-local value. You could write

class Outer:
    class InnerException(Exception): pass

    # methods

InnerException = Outer.InnerException

but that mostly defeats the purpose of defining InnerException inside the class Outer in the first place. You could just as easily write

class Outer:
    # methods

class InnerException(Exception): pass

because both make the name InnerException refer to an exception in the module scope (although in the second case, InnerException is no longer a class attribute of Outer, of course).

martineau · Answer 3 · 2013-10-08T21:55:39.723

I suppose you could do something like this to define it within each function's enclosing scope, which creates a local variable that's an alias for it:

class Outer:
    class InnerException(Exception): pass
    def raise_inner(self, InnerException=InnerException):
        raise InnerException()
    def call_raise(self, InnerException=InnerException):
        try:
            self.raise_inner()
        except InnerException as e:
            print "Handle me"

Outer().call_raise()

Python use alias for inner classes

3 Answers3