Python事件类别映射设计

Question

我正在编写一些代码来组织我们的事件定义/类别映射。我们的目标是能够定义“事件名称”以及关联类别，这几乎是一个静态过程。我们想要的是人们使用常量，而不是到处都是字符串。我们还需要某个地方来验证事件/类别，以及执行一些查找操作，如按类别获取事件，反之亦然。在

class EventMapping(object)
    def __init__(self, name, categories):
        self.name =  name
        self.categories=  categories
        EventRegistry.register(self)

    def __eq__(self, obj):
        if(isinstance(obj, str)):
            return obj==self.name
        if(isinstance(obj, EventMapping)):
            return obj.name ==self.name 
               and obj.categories==self.categories
        return False

    def __repr__(self):
        return self.name   

class Event():
    class MyCompontent():
        ComponentEvent = EventMapping("ComponentEvent", None)
        ComponentEventWCategory = EventMapping("ComponentEvent"
             , [Category.MyComponent.Useful])
    class Data():
         Created =EventMapping("Created", [Category.Data.All, Category.Data.Count]
         Updated= EventMapping("Updated", [Category.Data.All]
         Deleted= EventMapping("Deleted", [Category.Data.All, Category.Data.Count]

class Category():
    class MyComponent():
        Useful = "Useful"
    class Data():
        All= "All" 
        Count= "Count" 

class EventRegistry():
    @staticmethod
    def register( eventMapping):
        eventName= eventMapping.name
        #store locally...

    @staticmethod
    def events(category):
        #retreive events by category

    @staticmethod
    def category(event_name):
        #retreive categories by event name

有几件事我不喜欢：

1. 在EventRegistry类中，我将它们存储两次，一次存储在事件字典键中作为名称，并为类别列表赋值。第二个是由类别名称和事件列表键控的相反类别字典。有没有更好的方法来实现这一点？我基本上需要一个简单的方法来查找名称或类别。

2. 我应该只创建两个注册表吗？一个用于分类一个用于事件？

3. 在使用我们喜欢的活动时：

   self.subscribe(Event.MyComponent.Useful)self.subscribe(Category.MyComponent.Useful)

然后我们使用注册表来验证事件是否存在，并传递消息。有没有更简单的方法来实现类似包的名称空间？在

只是在寻找一些更好的方法的反馈，或者一个遵循的模式。我到处找了找，什么也没找到。即使你知道一些模块，我可以看看，并得到一个更好的方式来做它，我也很高兴看到它。在

Answer 1

你为什么不选something more pythonic？在

from collections import defaultdict


_linked = defaultdict(set)


class Linkable(object):

    def link(self, *others):
        _linked[self].update(others)
        for each in others:
            _linked[each].add(self)

    def unlink(self, *others):
        _linked[self].difference_update(others)
        for each in others:
            _linked[each].discard(self)

    def links(self):
        return set(_linked[self])


class NameHierarchy(object):

    def __init__(self, name, parent=None):
        self.name = name
        self.parent = parent or self
        self.path = parent.path + [self] if parent else [self]

    def __str__(self):
        return '.'.join(each.name for each in self.path)

    def add(self, name):
        if name not in self.__dict__:
            setattr(self, name, self.__class__(name, self))


class LinkedNameHierarchy(Linkable, NameHierarchy):
    pass


Category = LinkedNameHierarchy('Category')

Category.add('MyComponent')
Category.MyComponent.add('Useful')

Category.add('Data')
Category.Data.add('All')
Category.Data.add('Count')

Event = LinkedNameHierarchy('Event')

Event.add('MyComponent')
Event.MyComponent.add('ComponentEvent')
Event.MyComponent.add('ComponentEventWCategory')

Event.MyComponent.ComponentEventWCategory.link(Category.MyComponent.Useful)

Event.add('Data')
Event.Data.add('Created')
Event.Data.add('Updated')
Event.Data.add('Deleted')

Event.Data.Created.link(Category.Data.All, Category.Data.Count)
Event.Data.Updated.link(Category.Data.All)
Event.Data.Deleted.link(Category.Data.All, Category.Data.Count)


def show_links():
    print
    print '  8<    8<    8<    8<    8<    8<  '
    for k, v in sorted(_linked.iteritems(), key=lambda x:str(x[0])):
        print
        print k
        for each in sorted(v, key=str):
            print '        ', each

show_links()

Event.Data.Created.unlink(Category.Data.Count)

show_links()

存在循环引用，这通常会导致内存泄漏。不过，在这种情况下，这是可以的，因为这些对象可能会在proram运行期间存在。在