Python跟踪scop中的子类

Question

我试图编写一个tracker类，其中tracker类的实例跟踪tracker实例范围内另一个类的子类。你知道吗

更具体地说，以下是我努力实现的一个例子：

class Foo(object): pass

class FooTracker(object):
     def __init__(self):

          # use Foo.__subclasses__() or a metaclass to track subclasses 
          # - but how do I filter this to only get the ones in scope?

          self.inscope = <something magic goes here>

ft1 = FooTracker()
assert ft1.inscope == []

class Bar(Foo): pass
ft2 = FooTracker()
assert ft2.inscope == [<class '__main__.Bar'>]

def afunction():
    class Baz(Foo): pass    # the global definition of Bar is now hidden
    class Bar(Foo): pass
    ft3 = FooTracker()

    assert (set(ft3.inscope) == set([<class '__main__.afunction.<locals>.Baz'>,
                                     <class '__main__.afunction.<locals>.Bar'>])

ft4 = FooTracker()   # afunction.Baz and afunction.Bar are no longer in scope
assert ft4.inscope == [<class '__main__.Bar'>]

所以我希望FooTracker的实例跟踪Foo的子类，这些子类在创建FooTracker对象时在作用域中。你知道吗

我尝试了一些不同的方法，比如解析Foo子类的限定名，并使用exec()进行名称解析，但根本的问题是，它总是计算出相对于FooTracker.__init__()范围的子类，而不是它被调用的位置。你知道吗

我唯一的另一个想法是用inspect.currentframe()尝试一些东西，但即使这是可能的，也可能是太多的黑客行为，并且会使代码变得太脆弱（例如，文档中有一条注释，不是所有的Python实现在解释器中都有框架支持）。你知道吗

Answer 1

没有简单的方法可以完全按照你的要求去做。但是，您可以使用一些Python特性来获得具有大致相似的API的东西，而不需要太多麻烦。你知道吗

一种选择是要求每个子类用Tracker类的方法修饰。这将使跟踪它们变得非常容易，因为您只需将方法的每个调用方附加到一个列表中：

class Tracker:
    def __init__(self):
        self.subclasses = []

    def register(self, cls):
        self.subclasses.append(cls)
        return cls

class Foo(): pass

foo_tracker = Tracker()

@foo_tracker.register
class FooSubclass1(Foo): pass

@foo_tracker.register
class FooSubclass2(Foo): pass

print(foo_tracker.subclasses)

这实际上并不要求被跟踪的类是Foo的子类，如果将所有类（甚至非类对象）传递给register方法，就可以跟踪它们。Decorator语法使它比在定义之后将每个类附加到一个列表要好一点，但不是全部（您仍然会大量重复自己，除非您使tracker和方法名非常短，否则这可能会很烦人）。你知道吗

稍微复杂一点的版本可能会传递给基类，因此它会自动检测子类（通过Foo.__subclasses__）。要限制它检测到的子类（而不是获取曾经存在过的基的所有子类），可以让它充当上下文管理器，并且只跟踪在with块中定义的新子类：

class Tracker:
    def __init__(self, base):
        self.base = base
        self._exclude = set()
        self.subclasses = set()

    def __enter__(self):
        self._exclude = set(self.base.__subclasses__())
        return self

    def __exit__(self, *args):
        self.subclasses = set(self.base.__subclasses__()) - self._exclude
        return False

class Foo(): pass
class UntrackedSubclass1(Foo): pass

with Tracker(Foo) as foo_tracker:
    class TrackedSubclass1(Foo): pass
    class TrackedSubclass2(Foo): pass

class UntrackedSubclass2(Foo): pass

print(foo_tracker.subclasses)

如果您使用的是python3.6或更高版本，则可以通过将__init_subclass__类方法注入被跟踪的基类，而不是依赖于__subclasses__来执行跟踪。如果您不需要支持已经在使用__init_subclass__的类层次结构（并且不需要支持嵌套的跟踪器），那么它可以非常优雅：

class Tracker:
    def __init__(self, base):
        self.base = base
        self.subclasses = []

    def __enter__(self):
        @classmethod
        def __init_subclass__(cls, **kwargs):
            self.subclasses.append(cls)

        self.base.__init_subclass__ = __init_subclass__
        return self

    def __exit__(self, *args):
        del self.base.__init_subclass__
        return False

class Foo(): pass
class UntrackedSubclass1(Foo): pass

with Tracker(Foo) as foo_tracker:
    class TrackedSubclass1(Foo): pass
    class TrackedSubclass2(Foo): pass

class UntrackedSubclass2(Foo): pass

print(foo_tracker.subclasses)

这个版本的一个很好的特性是它自动跟踪更深层的继承层次结构。如果在with块中创建了子类的子类，则仍将跟踪该“孙子”类。如果您愿意，我们也可以通过添加另一个函数来递归地扩展我们找到的每个类的子类，从而使以前基于__subclasses__的版本以这种方式工作。你知道吗

如果您确实想更好地使用现有的__init_subclass__方法，或者希望能够嵌套跟踪器，那么您需要使代码更复杂一些。以可逆的方式注入一个行为良好的classmethod是很棘手的，因为您需要同时处理基类有自己方法的情况，以及它从其父类继承版本的情况。你知道吗

class Tracker:
    def __init__(self, base):
        self.base = base
        self.subclasses = []

    def __enter__(self):
        if '__init_subclass__' in self.base.__dict__:
            self.old_init_subclass = self.base.__dict__['__init_subclass__']
        else:
            self.old_init_subclass = None

        @classmethod
        def __init_subclass__(cls, **kwargs):
            if self.old_init_subclass is not None:
                self.old_init_subclass.__get__(None, cls)(**kwargs)
            else:
                super(self.base, cls).__init_subclass__(**kwargs)
            self.subclasses.append(cls)

        self.base.__init_subclass__ = __init_subclass__
        return self

    def __exit__(self, *args):
        if self.old_init_subclass is not None:
            self.base.__init_subclass__ = self.old_init_subclass
        else:
            del self.base.__init_subclass__
        return False

class Foo:
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        print("Foo!")

class Bar(Foo): pass   # every class definition from here on prints "Foo!" when it runs

with Tracker(Bar) as tracker1:
    class Baz(Bar): pass

    with Tracker(Foo) as tracker2:
        class Quux(Foo): pass

        with Tracker(Bar) as tracker3:
            class Plop(Bar): pass

# four Foo! lines will have be printed by now by Foo.__init_subclass__
print(tracker1.subclasses) # will describe Baz and Plop, but not Quux
print(tracker2.subclasses) # will describe Quux and Plop
print(tracker3.subclasses) # will describe only Plop