python namespace: __main__.Class not isinstance of package.Class

Question

Consider you have two python files as defined below. Say one is a general package (class2), and the other one does specific overrides and serves as the executab

Answer 1

You could use the type() function (you'll find this invocation fairly common, in fact!):

#!/usr/bin/python
class Test(object):
    pass

class Verificator():
    def check(self, myObject):
        if not isinstance( type(myObject), type(Test) ):
            print "%s is no instance of %s" % (type(myObject),Test)
        else:
            print "OK!"

if __name__ == '__main__':
    from class2 import getTest

    v = Verificator()
    t = Test()
    v.check(t)
    s = getTest()
    v.check(s)

The perhaps worse solution:

if not isinstance( myObject.__class__, Test.__class__ ):  # Use __class__ here.

They're of course equivalent, but it's considered bad form to need to use double-underscore members unless you desperately need to! It's worth knowing of their existence, though, hence why I've included this one in my answer.

Note that this happens, to the best of my knowledge, because when you run python class1.py, class1.py would have no module. As such, python places everything into the __main__ module for you. This isn't the case when you import it from any other script, so seeing something as part of the __main__ module is actually the special case!

Answer 2

If you plan to import class1.py from elsewhere, move the top-level code (if __name__ == '__main__': ... to a separate file altogether. That way both the main file and class2 work with the same class1.Test class.

Doing almost anything else opens a can of worms. While you can work around the immediate problem by switching isinstance to type(myObject).__name__ == ..., the fact remains that your Python process contains two Test classes where there should be only one. The otherwise indistinguishable classes know nothing of each other and fail each other's issubclass tests. This practically guarantees hard-to-diagnose bugs further down the line.

EDIT
Another option is to explicitly import the classes from class1 when executing as main, as in your answer. It would be advisable to go one step further and make sure that the classes aren't defined in double. For example, you can move the if __name__ == '__main__' block to the beginning of the file, and end it with sys.exit(0):

if __name__ == '__main__':
    import class1, class2
    ... use only the public API with module prefixes ...
    sys.exit(0)

# the rest of the module follows here

Answer 3

Thanks for the hints, which finally helped me to experiment in the right direction. The solution I just found in this toy model, is to fix the namespace issue using an import. In order to rule out the issue user4815162342 pointed out, I added another class to class1. The following code for class1.py appears to do, what I want:

#!/usr/bin/python
class Test(object):
    pass

class Toast(object):
    pass

class Verificator():
    def check(self, myObject):
        if not isinstance( myObject, Test ):
            print "NOPE: %s is no instance of %s" % (type(myObject),Test)
        else:
            print "OK: %s is instance of %s" % (type(myObject),Test)

if __name__ == '__main__':
    from class2 import getTest
    from class1 import Test, Toast

    v = Verificator()
    t = Test()
    v.check(t)
    t = getTest()
    v.check(t)
    t = Toast()
    v.check(t)