init to got straight into a sub-state?

[MiMiMeowMeow]

Hello, i'm wondering something like the attached is possible now.

I tried to code it up but it doesn't seem possible to define the init of one state to go into a sub-state. For example d2-init will go right into d211 state. Or d-init will go right into d11 state.

Just for reference this was from Practical UML Statecharts in C/C++, 2nd Ed
https://www.state-machine.com/doc/PSiCC2.pdf

[fgmacedo]

Hi @MiMiMeowMeow, this is absolutely possible with v3! The key is that compound states cascade their initial transitions automatically — when the engine enters a compound state, it recursively enters the initial child at each level until it reaches an atomic state.

So for your diagram, when d2 is entered, the engine automatically goes: d2 → d21 (initial child) → d211 (initial child of d21). No special setup needed — just mark the initial states and the cascading happens.

Here's a working reproduction of the full structure from the PSiCC2 diagram:

from statemachine import State, StateChart


class PSiCC2(StateChart):
    """HSM example from Practical UML Statecharts in C/C++, 2nd Ed."""

    # State hierarchy:
    # d (compound, top-level)
    #   d1 (compound, initial of d)
    #     d11 (atomic, initial of d1)
    #   d2 (compound)
    #     d21 (compound, initial of d2)
    #       d211 (atomic, initial of d21)

    class d(State.Compound):
        class d1(State.Compound):
            d11 = State(initial=True)

        class d2(State.Compound):
            class d21(State.Compound):
                d211 = State(initial=True)

    terminate = State(final=True)

    # Instance variable used in guards
    foo: bool = False

    def is_foo(self):
        return self.foo

    def not_foo(self):
        return not self.foo

    def set_foo(self):
        self.foo = True

    def clear_foo(self):
        self.foo = False

    # --- Transitions ---

    # A: d1 self-transition; d21 self-transition
    A = d.d1.to(d.d1) | d.d2.d21.to(d.d2.d21)

    # B: d1 → d11; d21 → d211
    B = d.d1.to(d.d1.d11) | d.d2.d21.to(d.d2.d21.d211)

    # C: d1 ↔ d2
    C = d.d1.to(d.d2) | d.d2.to(d.d1)

    # D: d1 [!foo] → d / set_foo; d11 [foo] → d1 / clear_foo; d211 → d21
    D = (
        d.d1.to(d, cond="not_foo", on="set_foo")
        | d.d1.d11.to(d.d1, cond="is_foo", on="clear_foo")
        | d.d2.d21.d211.to(d.d2.d21)
    )

    # E: d → d11
    E = d.to(d.d1.d11)

    # F: d1 → d211; d2 → d11
    F = d.d1.to(d.d2.d21.d211) | d.d2.to(d.d1.d11)

    # G: d11 → d21; d21 → d1
    G = d.d1.d11.to(d.d2.d21) | d.d2.d21.to(d.d1)

    # H: d11 → d; d211 → d
    H = d.d1.d11.to(d) | d.d2.d21.d211.to(d)

    # I: d1 internal; d2 [!foo] self / set_foo; d [foo] self / clear_foo
    I = (
        d.d1.to.itself(internal=True)
        | d.d2.to(d.d2, cond="not_foo", on="set_foo")
        | d.to(d, cond="is_foo", on="clear_foo")
    )

    # TERMINATE: d → final state
    TERMINATE = d.to(terminate)

    # d2's initial transition action: foo = False
    def on_enter_d2(self):
        self.foo = False

And here's how the cascading init works:

>>> sm = PSiCC2()

>>> sorted(sm.configuration_values)
['d', 'd1', 'd11']
# d-init cascades: d → d1 (initial) → d11 (initial) ✓

>>> sm.send("C")  # d1 → d2
>>> sorted(sm.configuration_values)
['d', 'd2', 'd21', 'd211']
# d2-init cascades: d2 → d21 (initial) → d211 (initial) ✓

>>> sm.send("H")  # d211 → d (re-enters d, cascades back to d1/d11)
>>> sorted(sm.configuration_values)
['d', 'd1', 'd11']

How it works: at each compound level, if no explicit initial=True is set, the first child in document order becomes the initial state. The engine creates initial transitions automatically, and when entering a compound state, it follows these transitions recursively until it reaches an atomic state. You can access deeply nested states using dot notation (d.d2.d21.d211) for defining transitions, and use the | operator to combine multiple transitions under a single event name.