Python 跟踪范围内的子类

Question

我正在尝试编写一个跟踪器类，其中跟踪器类的实例跟踪跟踪器实例范围内的另一个类的子类。

更具体地说，以下是我想要实现的目标的示例:

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)。这将使跟踪它们变得非常容易，因为您只需将方法的每个调用者附加到列表中即可:

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 ，则可以跟踪它们。方法。装饰器语法使得它比在定义每个类后将其附加到列表中要好一些，但不是很多(您仍然重复自己相当多的内容，这可能很烦人，除非您使跟踪器和方法名称非常短) .

一个稍微棘手的版本可能会传递基类，以便它会自动检测子类(通过 Foo.__subclasses__ )。要限制它检测到的子类(而不是获取曾经存在的基类的所有子类)，您可以使其充当上下文管理器，并且仅跟踪 with 中定义的新子类。 block :

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)

如果您使用的是 Python 3.6 或更高版本，您可以通过注入(inject) __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内创建的 block ，该“孙子”类仍将被跟踪。我们可以将前面的 __subclasses__如果您愿意，基于版本也可以通过添加另一个函数来递归扩展我们找到的每个类的子类来以这种方式工作。

如果您确实想与现有的 __init_subclass__ 保持良好的关系方法，或者希望能够嵌套跟踪器，您需要使代码更复杂一些。注入(inject)一个表现良好的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