PyTransitions/transitions 状态机库常见问题解答-CSDN博客

本文链接：https://blog.csdn.net/gitblog_00373/article/details/148487790

PyTransitions/transitions 状态机库常见问题解答

transitions A lightweight, object-oriented finite state machine implementation in Python with many extensions 项目地址: https://gitcode.com/gh_mirrors/tr/transitions

前言

状态机是软件开发中常用的设计模式，用于管理对象的状态转换。PyTransitions/transitions 是一个轻量级但功能强大的 Python 状态机库，本文将针对开发者在使用过程中遇到的常见问题进行详细解答。

配置文件的加载与保存

JSON/YAML 配置加载

在实际项目中，我们经常需要将状态机配置外部化，以便灵活调整。transitions 支持通过 JSON 或 YAML 文件加载配置。

JSON 配置示例

from transitions import Machine
import json

class MyModel:
    def say_hello(self, name):
        print(f"Hello {name}!")

json_config = """
{
  "name": "MyMachine",
  "states": ["A", "B", {"name": "C", "on_enter": "say_hello"}],
  "transitions": [
    ["go", "A", "B"],
    {"trigger": "hello", "source": "*", "dest": "C"}
  ],
  "initial": "A"
}
"""

model = MyModel()
config = json.loads(json_config)
config['model'] = model
machine = Machine(**config)

YAML 配置示例

from transitions import Machine
import yaml

yaml_config = """
---
name: "MyMachine"
states:
  - "A"
  - "B"
  - name: "C"
    on_enter: "say_hello"
transitions:
  - ["go", "A", "B"]
  - {trigger: "hello", source: "*", dest: "C"}
initial: "A"
"""

model = MyModel()
config = yaml.safe_load(yaml_config)
config['model'] = model
machine = Machine(**config)

配置导出

标准 Machine 类不保存配置信息，但可以使用 MarkupMachine 进行导出：

from transitions.extensions.markup import MarkupMachine

machine = MarkupMachine(model=None, name="ExportedMachine")
# 添加状态和转换...
print(json.dumps(machine.markup, indent=2))  # 导出为JSON
print(yaml.dump(machine.markup))  # 导出为YAML

Django 集成方案

基础集成

在 Django 项目中使用 transitions 时，可以通过信号机制初始化状态机：

from django.db import models
from django.db.models.signals import post_init
from transitions import Machine

class Order(models.Model):
    DRAFT = 'draft'
    CONFIRMED = 'confirmed'
    SHIPPED = 'shipped'
    STATES = [(DRAFT, '草稿'), (CONFIRMED, '已确认'), (SHIPPED, '已发货')]
    
    state = models.CharField(max_length=20, choices=STATES, default=DRAFT)

@receiver(post_init, sender=Order)
def init_state_machine(sender, instance, **kwargs):
    states = [state for state, _ in Order.STATES]
    machine = Machine(
        model=instance, 
        states=states, 
        initial=instance.state
    )
    machine.add_transition('confirm', Order.DRAFT, Order.CONFIRMED)
    machine.add_transition('ship', Order.CONFIRMED, Order.SHIPPED)

内存优化方案

当需要处理大量模型时，可以采用静态机器方案减少内存占用：

from transitions import Machine
from functools import partial

class Order(models.Model):
    # ...状态定义同上...
    
    machine = Machine(model=None, states=[state for state, _ in STATES], initial=None)
    machine.add_transition('confirm', DRAFT, CONFIRMED)
    machine.add_transition('ship', CONFIRMED, SHIPPED)
    
    def __getattribute__(self, item):
        try:
            return super().__getattribute__(item)
        except AttributeError:
            if item in self.machine.events:
                return partial(self.machine.events[item].trigger, self)
            raise

高级功能实现

动态状态回调

通过自定义 State 类实现动态回调解析：

from transitions import State

class DynamicState(State):
    def enter(self, event_data):
        model = event_data.model
        callback = getattr(model, f'on_enter_{self.name}', None)
        if callback:
            event_data.machine.callback(callback, event_data)

无转换时的回调

当没有成功转换时触发回调：

from transitions.core import Machine, State, Event

class DuringState(State):
    dynamic_methods = State.dynamic_methods + ['on_during']
    
    def __init__(self, *args, **kwargs):
        during = kwargs.pop('during', [])
        self.on_during = during
        super().__init__(*args, **kwargs)

class DuringMachine(Machine):
    state_cls = DuringState

动态目标状态

根据条件函数返回值决定目标状态：

from transitions import Transition

class DependingTransition(Transition):
    def __init__(self, source, dest, conditions=None, **kwargs):
        if isinstance(dest, dict):
            self._func = kwargs.pop('depends_on')
            self._dest_map = dest
        super().__init__(source, dest, conditions, **kwargs)
        
    def execute(self, event_data):
        if hasattr(self, '_func'):
            key = getattr(event_data.model, self._func)()
            self.dest = self._dest_map[key]
        return super().execute(event_data)