Skip to content

ATXResource

ATXResource

ATX power management for the host machine.

Source code in src/aiopikvm/resources/atx.py 
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
class ATXResource(BaseResource):
    """ATX power management for the host machine."""

    async def get_state(self) -> ATXState:
        """Get the current ATX state.

        Returns:
            Current ATX subsystem state including LED indicators.
        """
        return await self._get_model("/api/atx", ATXState)

    async def click_power(
        self, *, wait: bool = False, timeout: float | None = None
    ) -> None:
        """Click the power button.

        Args:
            wait: Answer only once the action has finished. kvmd's own
                default, and this one, is not to wait: the request comes
                back immediately and a failure is written to the kvmd log
                instead of reaching the caller.
            timeout: Per-call timeout in seconds. It bounds the request
                either way, but only ``wait`` makes the request last as
                long as the click itself.

        Raises:
            BusyError: Another ATX action is still running (409). Raised
                with or without ``wait``.
            APIError: The ATX plugin is disabled (400), which
                [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
        """
        await self._post(
            "/api/atx/click",
            params={"button": "power", "wait": int(wait)},
            timeout=timeout,
        )

    async def click_power_long(
        self, *, wait: bool = False, timeout: float | None = None
    ) -> None:
        """Long-press the power button.

        Args:
            wait: Answer only once the action has finished. kvmd's own
                default, and this one, is not to wait: the request comes
                back immediately and a failure is written to the kvmd log
                instead of reaching the caller.
            timeout: Per-call timeout in seconds. The button is held for
                5.5 s and kvmd waits another second afterwards, so with
                ``wait`` this call needs more than the 10 s default to be
                comfortable.

        Raises:
            BusyError: Another ATX action is still running (409). Raised
                with or without ``wait``.
            APIError: The ATX plugin is disabled (400), which
                [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
        """
        await self._post(
            "/api/atx/click",
            params={"button": "power_long", "wait": int(wait)},
            timeout=timeout,
        )

    async def click_reset(
        self, *, wait: bool = False, timeout: float | None = None
    ) -> None:
        """Click the reset button.

        Args:
            wait: Answer only once the action has finished. kvmd's own
                default, and this one, is not to wait: the request comes
                back immediately and a failure is written to the kvmd log
                instead of reaching the caller.
            timeout: Per-call timeout in seconds. It bounds the request
                either way, but only ``wait`` makes the request last as
                long as the click itself.

        Raises:
            BusyError: Another ATX action is still running (409). Raised
                with or without ``wait``.
            APIError: The ATX plugin is disabled (400), which
                [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
        """
        await self._post(
            "/api/atx/click",
            params={"button": "reset", "wait": int(wait)},
            timeout=timeout,
        )

    async def power_on(
        self, *, wait: bool = False, timeout: float | None = None
    ) -> None:
        """Power on the host.

        Args:
            wait: Answer only once the action has finished. kvmd's own
                default, and this one, is not to wait: the request comes
                back immediately and a failure is written to the kvmd log
                instead of reaching the caller.
            timeout: Per-call timeout in seconds. It bounds the request
                either way, but only ``wait`` makes the request last
                until the host reaches the requested state.

        Raises:
            BusyError: Another ATX action is still running (409). Raised
                with or without ``wait``.
            APIError: The ATX plugin is disabled (400), which
                [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
        """
        await self._post(
            "/api/atx/power",
            params={"action": "on", "wait": int(wait)},
            timeout=timeout,
        )

    async def power_off(
        self, *, wait: bool = False, timeout: float | None = None
    ) -> None:
        """Power off the host gracefully.

        Args:
            wait: Answer only once the action has finished. kvmd's own
                default, and this one, is not to wait: the request comes
                back immediately and a failure is written to the kvmd log
                instead of reaching the caller.
            timeout: Per-call timeout in seconds. It bounds the request
                either way, but only ``wait`` makes the request last
                until the host reaches the requested state.

        Raises:
            BusyError: Another ATX action is still running (409). Raised
                with or without ``wait``.
            APIError: The ATX plugin is disabled (400), which
                [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
        """
        await self._post(
            "/api/atx/power",
            params={"action": "off", "wait": int(wait)},
            timeout=timeout,
        )

    async def power_off_hard(
        self, *, wait: bool = False, timeout: float | None = None
    ) -> None:
        """Force power off the host.

        Args:
            wait: Answer only once the action has finished. kvmd's own
                default, and this one, is not to wait: the request comes
                back immediately and a failure is written to the kvmd log
                instead of reaching the caller.
            timeout: Per-call timeout in seconds. It bounds the request
                either way, but only ``wait`` makes the request last
                until the host reaches the requested state.

        Raises:
            BusyError: Another ATX action is still running (409). Raised
                with or without ``wait``.
            APIError: The ATX plugin is disabled (400), which
                [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
        """
        await self._post(
            "/api/atx/power",
            params={"action": "off_hard", "wait": int(wait)},
            timeout=timeout,
        )

    async def reset_hard(
        self, *, wait: bool = False, timeout: float | None = None
    ) -> None:
        """Force reset the host.

        Args:
            wait: Answer only once the action has finished. kvmd's own
                default, and this one, is not to wait: the request comes
                back immediately and a failure is written to the kvmd log
                instead of reaching the caller.
            timeout: Per-call timeout in seconds. It bounds the request
                either way, but only ``wait`` makes the request last
                until the host reaches the requested state.

        Raises:
            BusyError: Another ATX action is still running (409). Raised
                with or without ``wait``.
            APIError: The ATX plugin is disabled (400), which
                [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
        """
        await self._post(
            "/api/atx/power",
            params={"action": "reset_hard", "wait": int(wait)},
            timeout=timeout,
        )

get_state() async

Get the current ATX state.

Returns:

Type Description
ATXState

Current ATX subsystem state including LED indicators.
Source code in src/aiopikvm/resources/atx.py 
10
11
12
13
14
15
16
async def get_state(self) -> ATXState:
    """Get the current ATX state.

    Returns:
        Current ATX subsystem state including LED indicators.
    """
    return await self._get_model("/api/atx", ATXState)

click_power(*, wait=False, timeout=None) async

Click the power button.

Parameters:

Name Type Description Default
wait bool

Answer only once the action has finished. kvmd's own default, and this one, is not to wait: the request comes back immediately and a failure is written to the kvmd log instead of reaching the caller.

 False
timeout float | None

Per-call timeout in seconds. It bounds the request either way, but only wait makes the request last as long as the click itself.

 None

Raises:

Type Description
BusyError

Another ATX action is still running (409). Raised with or without wait.
APIError

The ATX plugin is disabled (400), which ATXState.enabled reports up front.
Source code in src/aiopikvm/resources/atx.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
async def click_power(
    self, *, wait: bool = False, timeout: float | None = None
) -> None:
    """Click the power button.

    Args:
        wait: Answer only once the action has finished. kvmd's own
            default, and this one, is not to wait: the request comes
            back immediately and a failure is written to the kvmd log
            instead of reaching the caller.
        timeout: Per-call timeout in seconds. It bounds the request
            either way, but only ``wait`` makes the request last as
            long as the click itself.

    Raises:
        BusyError: Another ATX action is still running (409). Raised
            with or without ``wait``.
        APIError: The ATX plugin is disabled (400), which
            [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
    """
    await self._post(
        "/api/atx/click",
        params={"button": "power", "wait": int(wait)},
        timeout=timeout,
    )

click_power_long(*, wait=False, timeout=None) async

Long-press the power button.

Parameters:

Name Type Description Default
wait bool

Answer only once the action has finished. kvmd's own default, and this one, is not to wait: the request comes back immediately and a failure is written to the kvmd log instead of reaching the caller.

 False
timeout float | None

Per-call timeout in seconds. The button is held for 5.5 s and kvmd waits another second afterwards, so with wait this call needs more than the 10 s default to be comfortable.

 None

Raises:

Type Description
BusyError

Another ATX action is still running (409). Raised with or without wait.
APIError

The ATX plugin is disabled (400), which ATXState.enabled reports up front.
Source code in src/aiopikvm/resources/atx.py 
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
async def click_power_long(
    self, *, wait: bool = False, timeout: float | None = None
) -> None:
    """Long-press the power button.

    Args:
        wait: Answer only once the action has finished. kvmd's own
            default, and this one, is not to wait: the request comes
            back immediately and a failure is written to the kvmd log
            instead of reaching the caller.
        timeout: Per-call timeout in seconds. The button is held for
            5.5 s and kvmd waits another second afterwards, so with
            ``wait`` this call needs more than the 10 s default to be
            comfortable.

    Raises:
        BusyError: Another ATX action is still running (409). Raised
            with or without ``wait``.
        APIError: The ATX plugin is disabled (400), which
            [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
    """
    await self._post(
        "/api/atx/click",
        params={"button": "power_long", "wait": int(wait)},
        timeout=timeout,
    )

click_reset(*, wait=False, timeout=None) async

Click the reset button.

Parameters:

Name Type Description Default
wait bool

Answer only once the action has finished. kvmd's own default, and this one, is not to wait: the request comes back immediately and a failure is written to the kvmd log instead of reaching the caller.

 False
timeout float | None

Per-call timeout in seconds. It bounds the request either way, but only wait makes the request last as long as the click itself.

 None

Raises:

Type Description
BusyError

Another ATX action is still running (409). Raised with or without wait.
APIError

The ATX plugin is disabled (400), which ATXState.enabled reports up front.
Source code in src/aiopikvm/resources/atx.py 
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
async def click_reset(
    self, *, wait: bool = False, timeout: float | None = None
) -> None:
    """Click the reset button.

    Args:
        wait: Answer only once the action has finished. kvmd's own
            default, and this one, is not to wait: the request comes
            back immediately and a failure is written to the kvmd log
            instead of reaching the caller.
        timeout: Per-call timeout in seconds. It bounds the request
            either way, but only ``wait`` makes the request last as
            long as the click itself.

    Raises:
        BusyError: Another ATX action is still running (409). Raised
            with or without ``wait``.
        APIError: The ATX plugin is disabled (400), which
            [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
    """
    await self._post(
        "/api/atx/click",
        params={"button": "reset", "wait": int(wait)},
        timeout=timeout,
    )

power_on(*, wait=False, timeout=None) async

Power on the host.

Parameters:

Name Type Description Default
wait bool

Answer only once the action has finished. kvmd's own default, and this one, is not to wait: the request comes back immediately and a failure is written to the kvmd log instead of reaching the caller.

 False
timeout float | None

Per-call timeout in seconds. It bounds the request either way, but only wait makes the request last until the host reaches the requested state.

 None

Raises:

Type Description
BusyError

Another ATX action is still running (409). Raised with or without wait.
APIError

The ATX plugin is disabled (400), which ATXState.enabled reports up front.
Source code in src/aiopikvm/resources/atx.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
async def power_on(
    self, *, wait: bool = False, timeout: float | None = None
) -> None:
    """Power on the host.

    Args:
        wait: Answer only once the action has finished. kvmd's own
            default, and this one, is not to wait: the request comes
            back immediately and a failure is written to the kvmd log
            instead of reaching the caller.
        timeout: Per-call timeout in seconds. It bounds the request
            either way, but only ``wait`` makes the request last
            until the host reaches the requested state.

    Raises:
        BusyError: Another ATX action is still running (409). Raised
            with or without ``wait``.
        APIError: The ATX plugin is disabled (400), which
            [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
    """
    await self._post(
        "/api/atx/power",
        params={"action": "on", "wait": int(wait)},
        timeout=timeout,
    )

power_off(*, wait=False, timeout=None) async

Power off the host gracefully.

Parameters:

Name Type Description Default
wait bool

Answer only once the action has finished. kvmd's own default, and this one, is not to wait: the request comes back immediately and a failure is written to the kvmd log instead of reaching the caller.

 False
timeout float | None

Per-call timeout in seconds. It bounds the request either way, but only wait makes the request last until the host reaches the requested state.

 None

Raises:

Type Description
BusyError

Another ATX action is still running (409). Raised with or without wait.
APIError

The ATX plugin is disabled (400), which ATXState.enabled reports up front.
Source code in src/aiopikvm/resources/atx.py 
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
async def power_off(
    self, *, wait: bool = False, timeout: float | None = None
) -> None:
    """Power off the host gracefully.

    Args:
        wait: Answer only once the action has finished. kvmd's own
            default, and this one, is not to wait: the request comes
            back immediately and a failure is written to the kvmd log
            instead of reaching the caller.
        timeout: Per-call timeout in seconds. It bounds the request
            either way, but only ``wait`` makes the request last
            until the host reaches the requested state.

    Raises:
        BusyError: Another ATX action is still running (409). Raised
            with or without ``wait``.
        APIError: The ATX plugin is disabled (400), which
            [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
    """
    await self._post(
        "/api/atx/power",
        params={"action": "off", "wait": int(wait)},
        timeout=timeout,
    )

power_off_hard(*, wait=False, timeout=None) async

Force power off the host.

Parameters:

Name Type Description Default
wait bool

Answer only once the action has finished. kvmd's own default, and this one, is not to wait: the request comes back immediately and a failure is written to the kvmd log instead of reaching the caller.

 False
timeout float | None

Per-call timeout in seconds. It bounds the request either way, but only wait makes the request last until the host reaches the requested state.

 None

Raises:

Type Description
BusyError

Another ATX action is still running (409). Raised with or without wait.
APIError

The ATX plugin is disabled (400), which ATXState.enabled reports up front.
Source code in src/aiopikvm/resources/atx.py 
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
async def power_off_hard(
    self, *, wait: bool = False, timeout: float | None = None
) -> None:
    """Force power off the host.

    Args:
        wait: Answer only once the action has finished. kvmd's own
            default, and this one, is not to wait: the request comes
            back immediately and a failure is written to the kvmd log
            instead of reaching the caller.
        timeout: Per-call timeout in seconds. It bounds the request
            either way, but only ``wait`` makes the request last
            until the host reaches the requested state.

    Raises:
        BusyError: Another ATX action is still running (409). Raised
            with or without ``wait``.
        APIError: The ATX plugin is disabled (400), which
            [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
    """
    await self._post(
        "/api/atx/power",
        params={"action": "off_hard", "wait": int(wait)},
        timeout=timeout,
    )

reset_hard(*, wait=False, timeout=None) async

Force reset the host.

Parameters:

Name Type Description Default
wait bool

Answer only once the action has finished. kvmd's own default, and this one, is not to wait: the request comes back immediately and a failure is written to the kvmd log instead of reaching the caller.

 False
timeout float | None

Per-call timeout in seconds. It bounds the request either way, but only wait makes the request last until the host reaches the requested state.

 None

Raises:

Type Description
BusyError

Another ATX action is still running (409). Raised with or without wait.
APIError

The ATX plugin is disabled (400), which ATXState.enabled reports up front.
Source code in src/aiopikvm/resources/atx.py 
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
async def reset_hard(
    self, *, wait: bool = False, timeout: float | None = None
) -> None:
    """Force reset the host.

    Args:
        wait: Answer only once the action has finished. kvmd's own
            default, and this one, is not to wait: the request comes
            back immediately and a failure is written to the kvmd log
            instead of reaching the caller.
        timeout: Per-call timeout in seconds. It bounds the request
            either way, but only ``wait`` makes the request last
            until the host reaches the requested state.

    Raises:
        BusyError: Another ATX action is still running (409). Raised
            with or without ``wait``.
        APIError: The ATX plugin is disabled (400), which
            [`ATXState.enabled`][aiopikvm.ATXState] reports up front.
    """
    await self._post(
        "/api/atx/power",
        params={"action": "reset_hard", "wait": int(wait)},
        timeout=timeout,
    )