Python事件类别映射设计

如何解决Python事件类别映射设计

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

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.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

有几件事我我不喜欢： 在EventRegistry类中，我存储了两次存储，一次是在Event Dictionary键中作为名称，并为类别列表赋值。第二个是由类别名称和事件列表作为关键字的相对的“类别”字典。有没有更好的方法来实现这一目标？我基本上需要一种简单的方法来按名称或类别查找。 我应该只创建两个注册表吗？一为类别一为活动？ 当使用事件时，我们这样做：

self.subscribe(Event.MyComponent.Useful)

 

self.subscribe(Category.MyComponent.Useful)

然后，我们使用注册表来验证事件是否存在以及传递消息。有没有更简单的方法来实现类似名称空间的包？ 只是寻找一些更好的方法来反馈或遵循一种模式。我到处搜寻，找不到任何东西。即使您知道某些模块，我也可以研究一下，并获得更好的感觉，找到更好的方法，但也很高兴对此进行研究。     

解决方法

为什么不选择更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,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始终运行，这些对象就可能存在。