Что такое FSM?

FSM (Finite State Machine)

FSM или конечный автомат — это математическая модель вычисления, которая может находиться в одном из ограниченного количества состояний в конкретный момент времени. Это фундаментальная концепция в компьютерной науке и программировании, используемая для моделирования поведения систем, которые меняют своё состояние в ответ на события или входные данные.

Основные компоненты FSM

Состояния (States) — дискретные конфигурации системы, в которых она может находиться. Например, в приложении авторизации: "неавторизован", "авторизован", "ожидание подтверждения".

Переходы (Transitions) — правила перемещения из одного состояния в другое при наступлении определённого события. Каждый переход активируется по определённому условию или срабатыванию события.

События (Events) — триггеры, которые вызывают переходы. Например, нажатие кнопки, получение данных, истечение таймера.

Начальное состояние (Initial State) — состояние, в котором находится система при запуске.

Конечные состояния (Final States) — состояния, в которых система может завершить работу.

Практический пример на Python

Рассмотрим простую FSM для управления состоянием заказа:

from enum import Enum

class OrderState(Enum):
    PENDING = "pending"
    PAID = "paid"
    SHIPPED = "shipped"
    DELIVERED = "delivered"
    CANCELLED = "cancelled"

class Order:
    def __init__(self, order_id: str):
        self.order_id = order_id
        self.state = OrderState.PENDING
    
    def pay(self):
        """Переход из PENDING в PAID"""
        if self.state == OrderState.PENDING:
            self.state = OrderState.PAID
            print(f"Order {self.order_id}: payment accepted")
        else:
            raise ValueError(f"Cannot pay order in state {self.state}")
    
    def ship(self):
        """Переход из PAID в SHIPPED"""
        if self.state == OrderState.PAID:
            self.state = OrderState.SHIPPED
            print(f"Order {self.order_id}: shipped")
        else:
            raise ValueError(f"Cannot ship order in state {self.state}")
    
    def deliver(self):
        """Переход из SHIPPED в DELIVERED"""
        if self.state == OrderState.SHIPPED:
            self.state = OrderState.DELIVERED
            print(f"Order {self.order_id}: delivered")
        else:
            raise ValueError(f"Cannot deliver order in state {self.state}")
    
    def cancel(self):
        """Отмена заказа из состояния PENDING или PAID"""
        if self.state in (OrderState.PENDING, OrderState.PAID):
            self.state = OrderState.CANCELLED
            print(f"Order {self.order_id}: cancelled")
        else:
            raise ValueError(f"Cannot cancel order in state {self.state}")

# Использование
order = Order("ORD-001")
order.pay()      # PENDING -> PAID
order.ship()     # PAID -> SHIPPED
order.deliver()  # SHIPPED -> DELIVERED

Более сложный пример с использованием словарей

from typing import Dict, Callable, Any

class StateMachine:
    def __init__(self, states: Dict[str, Dict[str, Callable]]):
        self.states = states
        self.current_state = list(states.keys())[0]  # первое состояние
    
    def trigger(self, event: str, *args, **kwargs) -> Any:
        """Триггерить событие в текущем состоянии"""
        if event in self.states[self.current_state]:
            handler = self.states[self.current_state][event]
            result = handler(self, *args, **kwargs)
            return result
        else:
            raise ValueError(f"Event {event} not available in state {self.current_state}")
    
    def change_state(self, new_state: str):
        """Изменить состояние"""
        if new_state in self.states:
            self.current_state = new_state
        else:
            raise ValueError(f"Unknown state: {new_state}")

# Определяем обработчики событий
def on_start(machine):
    print("Starting...")
    machine.change_state("running")

def on_stop(machine):
    print("Stopping...")
    machine.change_state("stopped")

def on_pause(machine):
    print("Pausing...")
    machine.change_state("paused")

def on_resume(machine):
    print("Resuming...")
    machine.change_state("running")

# Создаём FSM
fsm_config = {
    "stopped": {
        "start": on_start
    },
    "running": {
        "pause": on_pause,
        "stop": on_stop
    },
    "paused": {
        "resume": on_resume,
        "stop": on_stop
    }
}

machine = StateMachine(fsm_config)
print(f"Current state: {machine.current_state}")  # stopped
machine.trigger("start")  # Переходит в running
print(f"Current state: {machine.current_state}")  # running
machine.trigger("pause")  # Переходит в paused
print(f"Current state: {machine.current_state}")  # paused

Использование внешних библиотек

В Python существуют специализированные библиотеки для работы с FSM:

transitions — популярная библиотека:

from transitions import Machine

states = [solid, liquid, gas]
transitions = [
    {trigger: melt, source: solid, dest: liquid},
    {trigger: evaporate, source: liquid, dest: gas},
    {trigger: sublimate, source: solid, dest: gas},
    {trigger: ionize, source: gas, dest: plasma},
    {trigger: deionize, source: plasma, dest: gas},
    {trigger: condense, source: gas, dest: liquid},
    {trigger: freeze, source: liquid, dest: solid},
]

class Matter:
    pass

matter = Matter()
machine = Machine(
    model=matter,
    states=states,
    transitions=transitions,
    initial=solid
)

print(matter.state)  # solid
matter.melt()
print(matter.state)  # liquid
matter.evaporate()
print(matter.state)  # gas

Практическое применение FSM

• Управление состоянием приложения — навигация между экранами, управление UI
• Обработка запросов — HTTP状態машины в веб-приложениях
• Телеграм боты — управление диалоговым потоком через FSM (как упоминается в контексте проекта с aiogram)
• Парсеры и лексеры — анализ входных данных
• Игровая логика — управление состояниями игровых объектов
• Протоколы связи — управление этапами взаимодействия

FSM — это мощный инструмент для создания понятного и предсказуемого кода, особенно когда система имеет чётко определённые состояния и переходы между ними.