python 初探状态机transitions库

版权声明:随意转载。 https://blog.csdn.net/xihuanqiqi/article/details/78185811

偶然接触一个python的关于状态机的库,简单demo如下:
# coding=utf-8
##############################################################
# 目标:"solid", "liquid", "gas", "plasma" 四种互相转换...
# 环境: pip install transitions
# 这个库简直碉堡了...
##############################################################
from transitions import Machine

class Matter(object):
    pass

model = Matter()

# 定义状态
states = ["solid", "liquid", "gas", "plasma"]
# 定义状态转移
transitions = [
    {'trigger':'melt', 'source': 'solid', 'dest': 'liquid'},
    {'trigger':'evaporate', 'source': 'solid', 'dest': 'gas'},
    {'trigger':'sublimate', 'source': 'liquid', 'dest': 'gas'},
    {'trigger':'ionize', 'source': 'gas', 'dest': 'plasma'},
]
# 初始化
machine = Machine(model=model, states=states, transitions=transitions, initial='solid')

print model.state
model.melt()
print model.state
对源代码一探究竟。发现看不懂的地方甚多,那就分解一步步去解析吧。
Machine
—————> States = {'s1':s1, 's2':s2, 's3': s3}
—————> Events = {e1, e2} e1—————>Transition = [t1,t2,t3...]
—————> models = [m1, m2] m1 —————> to_s1(), to_s2()
大概就是Machine这个类里面维护比较重要的三个元素,States={},Events={}, models= [],接下来先看怎么填充这3个元素。


0、
pip install transitions==0.6.1
python == 2.7.10

1、
按照demo来说,我们传入的States和transitions:
States = ["solid", "liquid", "gas", "plasma"]
transitions = [
    {'trigger':'melt', 'source': 'solid', 'dest': 'liquid'},
    {'trigger':'evaporate', 'source': 'solid', 'dest': 'gas'},
    {'trigger':'sublimate', 'source': 'liquid', 'dest': 'gas'},
    {'trigger':'ionize', 'source': 'gas', 'dest': 'plasma'},
]

2、
States
Machine的构造函数中,传入了一个状态list,触发self.add_states(states):
        if states is not None:
            self.add_states(states)
然后在add_states()中,用字符串state分别创建一个State实例,然后把这个实例加入到字典self.states中,key就是字符串state
        for state in states:
            if isinstance(state, string_types):
                state = self._create_state(state, on_enter=on_enter, on_exit=on_exit,
                   ignore_invalid_triggers=ignore, **kwargs)
            self.states[state.name] = state
所以到这里我们的Machine实例字典参数如下:
self.states = {
    'solid': <State('solid')@4516320272>, 
    'liquid': <State('liquid')@4516320336>, 
    'gas': <State('gas')@4516320400>, 
    'plasma': <State('plasma')@4516320464>
}
同样在add_states()中,最后来一句:
        if self.auto_transitions:
            for s in self.states.keys():
                self.add_transition('to_%s' % s, self.wildcard_all, s)
这就很有趣了,每一个状态,都触发一次add_transition(),比如我们四个状态中的solid,触发时名字为to_solid,self.wildcard_all就是*号,表示source源状态,solid表示desc目标状态。那么看下add_transiton()给我们带来什么呢?
        if trigger not in self.events:
            self.events[trigger] = self._create_event(trigger, self)
因为to_solid一定不在self.events={}中,所以if条件为True,先是用trigger=to_solid创建一个Event实例,然后加到self.events这个字典中。
所以到这里我们的Machine实例字典参数如下:
self.events = {
    'to_liquid': <Event('to_liquid')@4516320592>, 
    'to_gas': <Event('to_gas')@4516320912>, 
    'to_plasma': <Event('to_plasma')@4516321232>, 
    'to_solid': <Event('to_solid')@4516320528>
}
继续往下走,add_transition()接下来执行:
        if isinstance(source, string_types):
            source = list(self.states.keys()) if source == self.wildcard_all else [source]
        else:
            source = [s.name if self._has_state(s) else s for s in listify(source)]
这是算出source,如果我们进来的参数是self.wildcard_all,那么source=["solid", "liquid", "gas", "plasma"],否则source=["solid"],add_transition()接下来执行:
        for s in source:
            d = s if dest == self.wildcard_same else dest
            if self._has_state(d):
                d = d.name
            t = self._create_transition(s, d, conditions, unless, before,
                                        after, prepare, **kwargs)
            self.events[trigger].add_transition(t)
这是对于每一个source,我们都算出一对Source2Dest如:("solid", "solid"),用这一对去生成一个Transition实例t,然后self.events["to_solid"]这个event,添加这个t到event.transitions中。
所以到了这里我们的Machine实例参数如下:
self.events["to_solid"].transitions = {
    'solid': [<Transition('solid', 'solid')@4516320656>],
     'plasma': [<Transition('plasma', 'solid')@4516320848>], 
    'gas': [<Transition('gas', 'solid')@4516320784>], 
    'liquid': [<Transition('liquid', 'solid')@4516320720>]
}

self.events["to_liquid"].transitions = {
    'solid': [<Transition('solid', 'liquid')@4516320656>],
     'plasma': [<Transition('plasma', 'liquid')@4516320848>], 
    'gas': [<Transition('gas', 'liquid')@4516320784>], 
    'liquid': [<Transition('liquid', 'liquid')@4516320720>]
}

self.events["to_gas"].transitions = {
    'solid': [<Transition('solid', 'gas')@4516320656>],
     'plasma': [<Transition('plasma', 'gas')@4516320848>], 
    'gas': [<Transition('gas', 'gas')@4516320784>], 
    'liquid': [<Transition('liquid', 'gas')@4516320720>]
}

self.events["to_plasma"].transitions = {
    'solid': [<Transition('solid', 'plasma')@4516320656>],
     'plasma': [<Transition('plasma', 'plasma')@4516320848>], 
    'gas': [<Transition('gas', 'plasma')@4516320784>], 
    'liquid': [<Transition('liquid', 'plasma')@4516320720>]
}

3、
Events
Machine的构造函数中,传入了transitions的list,触发了add_transitions():
        if transitions is not None:
            self.add_transitions(transitions)
查看下add_transitions()发生了什么:
        for t in listify(transitions):
            if isinstance(t, list):
                self.add_transition(*t)
好的,是分别触发add_transition()函数,那么根据1中分析,我们自定义传入了4个trigger,那么此时此刻的self.events如下:
self.events = {
    'to_liquid': <Event('to_liquid')@4516320592>, 
    'to_gas': <Event('to_gas')@4516320912>, 
    'to_plasma': <Event('to_plasma')@4516321232>, 
    'to_solid': <Event('to_solid')@4516320528>,
    'sublimate': <Event('sublimate')@4516446608>,
    'evaporate': <Event('evaporate')@4516446480>,
    'melt': <Event('melt')@4516446416>, 
    'ionize': <Event('ionize')@4516446736>
}
然后除了to_liquid, to_gas, to_plasma, to_solid,其他的参数如下:
self.events["melt"].transitions = {
   'solid': [<Transition('solid', 'liquid')@4438964880>]
}

self.events["ionize"].transitions = {
  'gas': [<Transition('gas', 'plasma')@4438965264>] 
}

self.events["sublimate"].transitions = {
    'liquid': [<Transition('liquid', 'gas')@4438965136>]
}

self.events["evaporate"].transitions = {
    'solid': [<Transition('solid', 'gas')@4438965008>]
}

4、
model
Machine的构造函数中,传入了model这list,触发了add_model():
        if model:
            self.add_model(model)
在add_model()中,先是遍历model(没错,它被变成一个list,如果单个元素,就是[model])。这里我们就只看一个model。
        if hasattr(model, 'trigger'):
            logger.warning("%sModel already contains an attribute 'trigger'. Skip method binding ", self.name)
        else:
            model.trigger = partial(get_trigger, model)
这段代码是先给model加一个函数trigger(),以后就能够用model.trigger()调用啦。
实际上调用的是偏函数get_trigger(model, trigger_name).
    def get_trigger(model, trigger_name, *args, **kwargs):
        func = getattr(model, trigger_name, None)
        if func:
            return func(*args, **kwargs)
        raise AttributeError("Model has no trigger named '%s'" % trigger_name)
有意思,所以以后我们就能用model.trigger("melt"),来调用某一个触发函数。

接着继续在add_model()中:
    for trigger, _ in self.events.items():
        self._add_trigger_to_model(trigger, model)
这个是遍历我们Machine实例中的self.events的键值对,拿到每个触发名字:to_liquid, to_solid, to_gas, to_plasma, melt, ionize, sublimate, evaporate,遍历调用self._add_trigger_to_model(trigger, model):
    def _add_trigger_to_model(self, trigger, model):
        trig_func = partial(self.events[trigger].trigger, model)
        setattr(model, trigger, trig_func)
其实这个还是给model绑定偏函数,以后我们就能这么调用model.melt()。
所以到了这里我们Machine实例关于model参数如下:
model.trigger("xxx")
model.to_liquid()
model.to_solid()
model.to_gas()
model.to_plasma()
model.melt()
model.mionize()
model.sublimate()
model.evaporate()
接着继续在add_model()中:
    for _, state in self.states.items():
        self._add_model_to_state(state, model)
和上面差不多,遍历调用_add_model_to_state(state, model)
    def _add_model_to_state(self, state, model):
        setattr(model, 'is_%s' % state.name,
                partial(self.is_state, state.name, model))
所以到了这里我们Machine实例关于model参数如下:
model.is_solid
model.is_liquid
model.is_gas
model.is_plasms
model.state # 这个是model.setState()把初始化状态如solid设置过来生成的属性
好了,我们知道了model现在多了很多函数和属性。

好的,现在我们具体来看看调用model.melt()到底发生了什么呢?它其实是调用self.events['melt'].trigger(model),
好的,看看self.events['melt'].trigger(model)里面是啥?
    def trigger(self, model, *args, **kwargs):
        f = partial(self._trigger, model, *args, **kwargs)
        return self.machine._process(f)
好的,原来是调用self.events['melt']._trigger(model),那么这个实际处理函数_trigger()里面又是啥呢?
        state = self.machine.get_state(model.state)
        if state.name not in self.transitions:
            msg = "%sCan't trigger event %s from state %s!" % (self.machine.name, self.name,
                                                               state.name)
            if state.ignore_invalid_triggers:
                logger.warning(msg)
                return False
            else:
                raise MachineError(msg)
第一句就先找出当前model的状态是什么:<State('solid')@4372239248>.
然后判断state.name 在不在 当前event的transitions中:{'solid': [<Transition('solid', 'liquid')@4372347728>]}
好吧,确实存在,那么就不用if语句块啦。_trigger()继续往下:
event_data = EventData(state, self, self.machine, model, args=args, kwargs=kwargs)
这个生成一个event_data实例,顾名思义,它就是一放数据的,里面放了当前machine,当前state,当前event,当前的model,transitions,执行transition()的结果result,当然不仅仅是放数据而已,它还会update(),更新machine状态。好吧,_trigger()继续往下:
            for t in self.transitions[state.name]:
                event_data.transition = t
                if t.execute(event_data):
                    event_data.result = True
                    break
如上我们的self.transitions['solid']只有一个元素t:{'solid': [<Transition('solid', 'liquid')@4372347728>]},把这个元素t赋值给event_data后,开始执行t,等会执行结果还是要放到event_data中呢。
总结下,到这里我们执行model.melt(),其实就是执行self.events['melt'].transitions['solid'].execute().

好的,那我们继续看看这个t.execute(event_data)怎么个执行法。
因为我们没带什么prepare, conditions等高级参数,所以我们把这个execute()简化成:
    def execute(self, event_data):
        self._change_state(event_data)
        return True
好吧,继续看看transition._change_state(),顾名思义,它就是专门处理状态的更新:
    def _change_state(self, event_data):
        event_data.machine.get_state(self.source).exit(event_data)
        event_data.machine.set_state(self.dest, event_data.model)
        event_data.update(event_data.model)
        event_data.machine.get_state(self.dest).enter(event_data)
没什么好说的,就是单纯的处理前状态"solid"的exit(),把当前状态置成desc的状态="liquid", 返回True。


总结下,Machine就是有两个self.events={}, self.states=[]辅助围着self.model转,维护好这个model的状态,即可!
这个transitions库大量运用偏函数呀和动态生成属性函数什么的,不过这也正常,毕竟从demo上看来,demo越简单,底下的操作越复杂。

以上


没有更多推荐了,返回首页