State is a behavioral design pattern that lets an object alter its behavior when its internal state changes. It appears as if the object changed its class.

#State in Python

from __future__ import annotations
from abc import ABC, abstractmethod

class Context:
    The Context defines the interface of interest to clients. It also maintains
    a reference to an instance of a State subclass, which represents the current
    state of the Context.

    _state = None
    A reference to the current state of the Context.

    def __init__(self, state: State) -> None:

    def transition_to(self, state: State):
        The Context allows changing the State object at runtime.

        print(f"Context: Transition to {type(state).__name__}")
        self._state = state
        self._state.context = self

    The Context delegates part of its behavior to the current State object.

    def request1(self):

    def request2(self):

class State(ABC):
    The base State class declares methods that all Concrete State should
    implement and also provides a backreference to the Context object,
    associated with the State. This backreference can be used by States to
    transition the Context to another State.

    def context(self) -> Context:
        return self._context

    def context(self, context: Context) -> None:
        self._context = context

    def handle1(self) -> None:

    def handle2(self) -> None:

Concrete States implement various behaviors, associated with a state of the

class ConcreteStateA(State):
    def handle1(self) -> None:
        print("ConcreteStateA handles request1.")
        print("ConcreteStateA wants to change the state of the context.")

    def handle2(self) -> None:
        print("ConcreteStateA handles request2.")

class ConcreteStateB(State):
    def handle1(self) -> None:
        print("ConcreteStateB handles request1.")

    def handle2(self) -> None:
        print("ConcreteStateB handles request2.")
        print("ConcreteStateB wants to change the state of the context.")

if __name__ == "__main__":
    # The client code.

    context = Context(ConcreteStateA())


Context: Transition to ConcreteStateA
ConcreteStateA handles request1.
ConcreteStateA wants to change the state of the context.
Context: Transition to ConcreteStateB
ConcreteStateB handles request2.
ConcreteStateB wants to change the state of the context.
Context: Transition to ConcreteStateA