aiopioneer

aiopioneer

Python library for controlling a Pioneer AVR via its built-in API.

Used by the pioneer_async integration for Home Assistant, which was inspired by the original Pioneer Home Assistant integration. Originally developed and tested on a VSX-930 (Main Zone and HDZone outputs) but has since been tested on a larger set of models by the community.

Features

• Implemented in asyncio
• Maintains single continuous telnet session to AVR, with automatic reconnect. This method of accessing the AVR API crashes less often than the integration included with Home Assistant
• Eliminates status polling where AVR sends keepalive responses (on port 8102)
• Auto-detects Zones 1, 2, 3 and HDZone
• Ignore specific zones, for AVRs that report phantom zones
• Automatically polls AVR for source names - no longer need to manually code them in your config any more if your AVR supports their retrieval. Can also set source names manually
• Queries device information from the AVR: MAC address, software version, model
• Ability to set internal parameters to change the API functionality, eg. maximum volume, volume step change delta
• Defaults for internal parameters set via custom profiles based on AVR model
• Includes workaround for AVRs with an initial volume set on the Main Zone (eg. VSX-930)
• Supports AVRs that do not support setting the volume level by emulating using up/down commands (eg. VSX-S510)
• Command line client for sending commands and testing
• Supports all listening mode functions
• Supports all video related functions
• Supports panel and remote locking
• Supports most AMP related functions
• Supports all tone functions
• Supports most zone power functions
• Supports all zone input functions
• Supports all zone volumne and mute functions
• Supports setting of tuner band and preset
• Supports setting tuner frequency directly for AVRs that support this via the API, and also by stepping the frequency up/down

Parameters

There are several types of parameters that modify the library's functionality. These are listed below in order of increasing priority:

• Default parameters: these are the defaults for all of the parameters
• Model parameters: these parameters are determined by the AVR model as detected by the library. Custom profiles for specific AVR models are defined in aiopioneer/param.py
• User parameters: these parameters are provided by the user at instantiation, and can also be updated via the set_user_params method
• Run-time parameters: these parameters are set by the library at run-time

Where a parameter is specified at more than one level, the higher priority parameter takes precedence. Thus, a user specified parameter will override any value that is determined by the AVR model.

[!NOTE] YAML syntax is used to indicate values the table below. Use Python equivalents (false -> False, true -> True, null -> None etc.) when calling the Python API directly, and JSON syntax if specifying parameters manually via the Home Assistant integration.

Name	Type	Default	Description
ignored_zones	list	[]	List of zones to ignore even if they are auto-discovered. Specify Zone IDs as strings: "1", "2", "3" and "Z"
command_delay	float	0.1	Insert a delay between sequential commands that are sent to the AVR. This appears to make the AVR behave more reliably during status polls. Increase this value if debug logging shows that your AVR times out between commands
max_source_id	int	60	Maximum source ID that the source discovery queries. Reduce this if your AVR returns errors
max_volume	int	185	Maximum volume for the Main Zone
max_volume_zonex	int	185	Maximum volume for zones other than the Main Zone
power_on_volume_bounce	bool	false	On some AVRs (eg. VSX-930) where a power-on is set, the initial volume is not reported by the AVR correctly until a volume change is made. This option enables a workaround that sends a volume up and down command to the AVR on power-on to correct the reported volume without affecting the power-on volume
volume_step_only	bool	false	On some AVRs (eg. VSX-S510), setting the volume level is not supported natively by the API. This option emulates setting the volume level using volume up and down commands.
ignore_volume_check	bool	false	Don't check volume when determining whether a zone exists on the AVR. Useful for AVRs with an HDZone that passes through audio
zone_1_sources	list	[]	(>0.4) Customises the available sources for use with Zone 1. Defaults to all available sources
zone_2_sources	list	see source	Customises the available sources for use with Zone 2 (some AVRs do not support all sources)
zone_3_sources	list	see source	Customises the available sources for use with Zone 3 (some AVRs do not support all sources)
hdzone_sources	list	see source	Customises the available sources for use with HDZone (some AVRs do not support all sources)
amp_speaker_system_modes	dict	....	Customises the names of speaker system modes. Different generations of AVR will name zones slighty differently. For example, the SC-LX57 names speaker system mode 15 as 5.1ch Bi-Amp + ZONE2 however this can also be called 5.2ch Bi-Amp + HDZONE on newer AVRs
extra_amp_listening_modes	dict	see source	(>0.5) Additional listening modes that are added to the list of all possible listening modes for the AVR. This list is used to decode the listening mode ID returned by the AVR. See the source for the format for listening mode definition
enabled_amp_listening_modes	list	[]	(>0.5) A list of listening mode IDs to be made available for selection. If specified, then no listening mode IDs will be included by default. All enabled source names must be unique, and duplicated names are ignored. The additional listening modes must be actually supported by the AVR, and will return an error (usually E02) when an unsupported listening mode is selected. This list is predefined for some AVRs, and specifying this parameter manually will override the model specific default disable list
disabled_amp_listening_modes	list	[]	A list of listening mode IDs to be disabled. Listening mode IDs that are also specified in enabled_amp_listening_modes will be disabled. This list is predefined for some AVRs, and specifying this parameter manually will override the model specific default disable list
video_resolution_modes	list	['0', '1', '3', '4', '5', '6', '7', '8', '9']	Sets the available video resolutions. Not all AVRs support the same resolution settings. This defaults to all of the latest resolutions from FY16
mhl_source	string	null	Sets the MHL source ID. This is used for media controls. This information cannot be queried automatically
enabled_functions	list	["basic", "audio", "amp", "dsp", "tone", "channels", "video", "tuner", "system", "display"]	Change the functions that are enabled by the API, adding more functions will increase the amount of time it takes to complete a full init and update
disable_auto_query	bool	false	Set to true to disable auto queries on first zone power on for all functions apart from core functionality (power, source, volume and mute)
am_frequency_step	int	null	Optional setting to configure the tuner AM frequency step. If not specified, it will be queried from the AVR if supported by the AVR, otherwise it will be determined by stepping the frequency up and down when the AM tuner is first used
always_poll	bool	false	Always poll the AVR every scan_interval. If set to false, out of band status responses from the AVR will reset the polling interval
debug_listener	bool	false	Enables additional debug logging for the listener task
debug_responder	bool	false	Enables additional debug logging for the responder task
debug_updater	bool	false	Enables additional debug logging for the updater task
debug_command	bool	false	Enables additional debug logging for commands sent and responses received
debug_command_queue	bool	false	Enables additional debug logging for the command queue task

If your model of AVR always needs specific parameters to be set for the library to function properly, then please create a PR to add a custom profile for the AVR model.

Python API

The library exposes a Python API through the PioneerAVR class. The class methods are listed below:

PioneerAVR.__init__(host: str, port = DEFAULT_PORT, timeout: float = DEFAULT_TIMEOUT, scan_interval: float = DEFAULT_SCAN_INTERVAL, params: dict[str, str] = None )

Constructor for the PioneerAVR class. The connection parameters are used when PioneerAVR.connect is called. After connection is established, the AVR will be polled every scan_interval seconds. If the always_poll parameter is set, the poll timer is reset when a response from the AVR is received. Optional user parameters are provided via params.

Connection methods (inherited by PioneerAVR)

awaitable PioneerAVRConnection.connect(reconnect: bool = True)

Establish a connection to the AVR. Set reconnect to True to re-establish the connection if it is disconnected.

awaitable PioneerAVRConnection.disconnect(reconnect: bool)

Disconnect from the AVR. Attempt to re-establish the connection if enabled at connect, or overridden by specifying reconnect.

awaitable PioneerAVRConnection.shutdown()

Permanently disconnect from the AVR. Does not attempt reconnection.

awaitable PioneerAVRConnection.set_timeout(timeout: float)

Set command and socket keepalive timeouts.

property available: bool

Whether integration is connected to the AVR.

property scan_interval: float

Number of seconds between polls for AVR full updates.

Update methods

awaitable PioneerAVR.update(zones: list[Zone] = None, wait: bool = True)

Update of the cached properties from the AVR via the command queue.
Refresh the AVR zones zones, or all AVR zones if not specified.
Wait for the update to be completed if wait is True.

awaitable PioneerAVR.set_scan_interval(scan_interval: int)

Set the scan interval to scan_interval and restart the updater task.

AVR system methods

awaitable PioneerAVR.turn_on(zone: Zone = Zone.Z1):

Turn on the Pioneer AVR zone.

awaitable PioneerAVR.turn_off(zone: Zone = Zone.Z1):

Turn off the Pioneer AVR zone.

awaitable PioneerAVR.query_device_model() -> bool | None

Query the AVR for device model. Updates the model parameters if device model is changed. Returns True if the AVR responds with its model, False if the AVR responds with an error, and None otherwise.

awaitable PioneerAVR.query_device_info()

Query the AVR for device information.

awaitable PioneerAVR.query_zones(force_update: bool = True)

Query the AVR for available zones by querying the power status for each zone and checking if the AVR responds. Ignores zones listed in the ignored_zones parameter.
If the ignore_volume_check parameter is not set, then additionally query the zone volume as well.

awaitable PioneerAVR.set_panel_lock(panel_lock: str):

Set the panel lock.

awaitable PioneerAVR.set_remote_lock(remote_lock: bool):

Set the remote lock.

awaitable PioneerAVR.set_dimmer(dimmer: str, zone: Zone = Zone.Z1):

Set the display dimmer.

AVR source methods

awaitable PioneerAVR.select_source(source: str = None, source_id: str = None, zone: Zone = Zone.Z1):

Set the input source for zone to name source_name or ID source_id (requires one argument.)

awaitable PioneerAVR.build_source_dict()

Query the available sources names from the AVR.
Parameter max_source_id determines the highest source ID that is queried.

PioneerAVRProperties.set_source_dict(sources: dict[str, str])

Manually set the available sources to the dict sources, where the keys are source IDs (padded to 2 chars) and the values are the corresponding source names.

PioneerAVRProperties.get_source_list(zone: Zone = Zone.Z1) -> list[str]

Return the set of currently available source names for zone. The source names can be used with the select_source method.

PioneerAVRProperties.get_source_dict(zone: Zone = None) -> dict[str, str]

Return a dict of currently available source names to source ID mappings for zone.
If zone is None, then return the dict of all available source names to source ID mappings.

PioneerAVRProperties.get_source_name(source_id: str) -> str

Return the source name for source_id.

awaitable PioneerAVR.set_source_name(source_id: str, source_name: str = "", default: bool = False) -> bool

Renames source_id to source_name on the AVR.
If default is True, reset source_id to the default source name.

PioneerAVRProperties.clear_source_id(source_id: str)

Clear the name mapping for source_id.

Command queue

PioneerAVR.queue_command(command: str | list, skip_if_queued: bool = True, insert_at: int = -1) -> None

Add command to the command queue, to to be sent in the background to the AVR or executed as a local command. Starts the command queue task if not already running.
command may be specified as a str, or a list whose first element is a str that is used as the command to execute. The list form is used for local commands that support arguments of arbitrary type. The following local commands are supported, these are mainly used by the command parsers for more complex actions:

• _power_on: execute initial refresh on zone power on
• _full_refresh: perform a full refresh on all AVR Zones
• [ _refresh_zone, zone: Zone ]: perform a refresh on the specified zone
• [ _delayed_query_basic, delay: float ]: schedule a basic AVR query if parameter disable_auto_query is not enabled
• _query_basic: perform a basic AVR query if parameter disable_auto_query is not enabled
• _calculate_am_frequency_step: calculate the tuner AM frequency step
• [ _sleep, delay: float ]: sleep for delay before executing the next command in the queue

If skip_if_queued is True and command is already present in the command queue, then the command is not queued again. Local command arguments are included in the match. <br> Insert the command at queue position insert_at if specified. Inserts by default at end of the queue.

Low level AVR command methods (inherited by PioneerAVR)

awaitable PioneerAVRConnection.send_command(command: str, zone: Zone = Zone.Z1, prefix: str = "", suffix: str = "", _ignore_erro* = None, rate_limit: bool = True) -> bool | None

Send command command for zone zone to the AVR, prefixed with prefix and/or suffixed with suffix if specified.
If command does not generate a response, then returns True if the command was successfully sent. Otherwise, returns the response received from the AVR, None if timed out, or False if an error response was received.
If ignore_error is None (default), then raise an exception on error. If ignore_error is True, then log the error as level debug, otherwise log the error as level error.
Raises AVRUnavailable if the AVR is disconnected, AVRResponseTimeoutError on timeout, and AVRCommandError if the request returned an error.
If rate_limit is True, then rate limit the commands sent to the AVR in accordance with the command_delay parameter.

awaitable PioneerAVRConnection.send_raw_command(command: str, rate_limit: bool = True)

Send a raw command command to the AVR. If rate_limit is True, then rate limit the commands sent to the AVR in accordance with the command_delay parameter.
Raises AVRUnavailable if the AVR is disconnected.

awaitable PioneerAVRConnection.send_raw_request(command: str, response_prefix: str, rate_limit: bool = True) -> str | bool | None

Send a raw command command to the AVR and wait for a response with prefix response_prefix. Returns the response received from the AVR.
Raises AVRUnavailable if the AVR is disconnected, AVRResponseTimeoutError on timeout, and AVRCommandError if the request returned an error.
If rate_limit is True, then rate limit the commands sent to the AVR in accordance with the command_delay parameter.

AVR tuner methods

awaitable PioneerAVR.select_tuner_band(band: TunerBand = TunerBand.FM) -> bool

Set the tuner band to band.

awaitable PioneerAVR.set_tuner_frequency(band: TunerBand, frequency: float = None) -> bool

Set the tuner band to band and tuner frequency to frequency. Step the frequency up or down if it cannot be set directly.

awaitable PioneerAVR.select_tuner_preset(tuner_class: str, preset: int) -> bool:

Select the tuner preset preset in class tuner_class.

awaitable PioneerAVR.tuner_previous_preset()

Select the previous tuner preset.

awaitable PioneerAVR.tuner_next_preset()

Select the next tuner preset.

AVR audio/video methods

awaitable PioneerAVR.select_listening_mode(mode_name: str = None, mode_id: str = None) -> bool

Set the listening mode to name mode_name, or ID mode_id (requires one argument.) Must be a listening mode valid for the current sound input as returned by get_listening_modes.

PioneerAVR.get_listening_modes() -> dict[str, str] | None

Return dict of valid listening mode mapping to names for the AVR.

awaitable PioneerAVR.set_volume_level(target_volume: int, zone: Zones = Zones.Z1)

Set the volume level for zone zone to target_volume. target_volume must be between 0 and 185 inclusive for Zone 1, and between 0 and 81 inclusive for all other zones.

awaitable PioneerAVR.mute_on(zone: Zone = Zone.Z1) -> bool

Turn mute on for zone zone.

awaitable PioneerAVR.mute_off(zone: Zone = Zone.Z1) -> bool

Turn mute off for zone zone.

awaitable PioneerAVR.set_tone_settings(tone: str = None, treble: int = None, bass: int = None, zone: Zone = Zone.Z1 )*

Set the tone settings for zone zone to tone. When tone is set to On, treble specifies the treble and bass specifies the bass.

awaitable PioneerAVR.set_amp_settings(speaker_config: str = None, hdmi_out: str = None, hdmi_audio_output: bool = None, pqls: bool = None, amp: str = None, zone: Zone = Zone.Z1) -> bool

Set amplifier function settings for zone zone.

PioneerAVRProperties.get_supported_media_controls(zone: Zone) -> list[str]

Return a list of all valid media control actions for a given zone. If the provided zone source is not currently compatible with media controls, None will be returned.

property PioneerAVRProperties.ipod_control_commands: list[str]

Return a list of all valid iPod control modes.

property PioneerAVRProperties.tuner_control_commands: list[str]

Return a list of all valid tuner control commands.

awaitable PioneerAVR.set_channel_levels(channel: str, level: float, zone: Zone = Zone.Z1) -> bool

Set the level (gain) for amplifier channel in zone zone.

awaitable PioneerAVR.set_video_settings(zone: Zone, **arguments) -> bool

Set video settings for zone zone.

awaitable PioneerAVR.set_dsp_settings(zone: Zone, **arguments) -> bool

Set the DSP settings for the amplifier for zone zone.

awaitable PioneerAVR.media_control(action: str, zone: Zone = Zone.Z1) -> bool

Perform media control activities such as play, pause, stop, fast forward or rewind.

AVR zone callback methods

PioneerAVR.set_zone_callback(zone: Zone, callback: Callable[..., None])

Register callback callback for zone zone.

PioneerAVR.clear_zone_callbacks()

Clear callbacks for all zones.

Parameter methods

PioneerAVRParams.set_default_params_model(model: str) -> None

Set default parameters based on device model.

PioneerAVRParams.set_user_params(params: dict[str, Any] = None) -> None

Set user parameters and update current parameters.

PioneerAVRParams.set_user_param(param: str, value: Any) -> None

Set a user parameter.

PioneerAVRParams.set_runtime_param(param: str, value: Any) -> None

Set a run-time parameter.

property PioneerAVRParams.zones_initial_refresh: set[Zone]

Return set of zones that have completed an initial refresh.

property PioneerAVRParams.default_params: dict[str, Any]

Get a copy of current default parameters.

property PioneerAVRParams.user_params: dict[str, Any]

Get a copy of user parameters.

_property PioneerAVRParams.params_all -> dict[str, Any]

Get a copy of all current parameters.

PioneerAVRParams.get_param(param_name: str) -> Any

Get the value of the specified parameter.

PioneerAVRParams.get_runtime_param(param_name: str) -> Any

Get the value of the specified run-time parameter.

AVR Properties

Listed below are the public attributes of a PioneerAVRProperties object that contains the current state of the AVR. Use a Zone enum to access zone specific attributes for those that are indexed by zone.

Attribute	Type	Description
model	str | None	Model number returned by the AVR
software_version	str | None	Software version returned by the AVR
mac_addr	str | None	System MAC address returned by the AVR
zones	list[Zone]	List of all zones detected on the AVR
power	dict[Zone, bool]	Power status for each detected zone
volume	dict[Zone, int]	Volume status for each detected zone
max_volume	dict[Zone, int]	Maximum valid volume for each detected zone
mute	dict[Zone, bool]	Mute status for each detected zone
source_id	dict[Zone, str]	Active source ID for each detected zone
source_name	dict[Zone, str]	Active source name for each detected zone
listening_mode	str	Name of the currently active listening mode
listening_mode_raw	str	ID of the currently active listening mode
media_control_mode	dict[Zone, str]	Media control mode for each detected zone
tone	dict[Zone, dict]	Tone attributes for each detected zone
amp	dict[str | Zone, str]	Current AVR amp attributes
tuner	dict[str | Zone, str]	Current AVR tuner attributes
dsp	dict[str | Zone, str]	Current AVR DSP attributes
video	dict[str | Zone, str]	Current AVR video parameters
audio	dict[str | Zone, str]	Current AVR audio parameters
system	dict[str | Zone, str]	AVR system attributes
channel_levels	dict[str, Any]	Current AVR channel levels, indexed by channel name
ip_control_port_n	str	IP control ports configured on the AVR (where n is the port index)

Command line interface (CLI)

A very simple command line interface aiopioneer is available to connect to the AVR, send commands and receive responses. It can be used to test the capabilities of the library against your specific AVR.

On Home Assistant, you can run the CLI when the pioneer_async Home Assistant integration has been installed. On Home Assistant Supervised or Container, start the CLI from within the HA container: docker exec -it homeassistant aiopioneer.

Invoke the CLI with the following arguments:

Argument	Default	Description
hostname	required	hostname for AVR connection
-p --port	8102	port for AVR connection
+Z --no-query-zones	None	skip AVR zone query

The CLI accepts all API commands, as well as the following:

Command	Argument	Description
exit or quit		Exit the CLI.
zone	zone	Change current zone to zone.
log_level	log_level	Change debug level to log_level. Valid log levels are: debug, info, warning, error, critical.
update		Request update of AVR. An update is scheduled in the updater task if a scan interval is set, if it is not set then the update is performed synchronously.
update_full		Request a full update of AVR irrespective of when the previous update was performed. An update is scheduled in the updater task if a scan interval is set, if it is not set then the update is performed synchronously.
query_device_info		Query the AVR for device information.
query_zones		Query the AVR for available zones. Ignore zones specified in parameter ignored_zones (list).
build_source_dict		Query the sources from the AVR.
set_source_dict	sources (JSON)	Manually set the sources to sources.
get_source_list		Return the current set of available source names that can be used with the select_source command.
get_zone_listening_modes		(>0.5) Return the current set of available listening modes.
get_params		Return the currently active set of parameters.
get_user_params		Return the currently active set of user parameters.
set_user_params	params (JSON)	Set the user parameters to params.
get_tone		Returns the current AVR tone attributes.
get_amp		Returns the current AVR amp attributes.
get_tuner		Returns the current AVR tuner attributes.
get_channel_levels		Returns the current AVR channel levels.
get_dsp		Returns the current AVR DSP attributes.
get_video		Returns the current AVR video parameters.
get_audio		Returns the current AVR audio parameters.
get_system		Returns the AVR system attributes.
debug_listener	state (bool)	Enable/disable the debug_listener parameter.
debug_responder	state (bool)	Enable/disable the debug_responder parameter.
debug_updater	state (bool)	Enable/disable the debug_updater parameter.
debug_command	state (bool)	Enable/disable the debug_command parameter.
debug_command_queue	state (bool)	Enable/disable the debug_command_queue parameter.
set_scan_interval	scan_interval (float)	Set the scan interval to scan_interval.
get_scan_interval		Return the current scan interval.
set_volume_level	volume_level (int)	Set the volume level for the current zone.
select_source	source_name	Set the input source for the current zone.
select_listening_mode	listening_mode	(>0.5) Set the listening mode to the specified mode.
set_tuner_frequency	band frequency	Set the tuner band and (optionally) frequency.
tuner_previous_preset		Select the previous tuner preset
tuner_next_preset		Select the next tuner preset
send_raw_command or >	raw_command	Send the raw command raw_command to the AVR.

NOTE: The CLI interface may change in the future, and should not be used in scripts. Use the Python API instead.

Source list

The list below shows the source ID that corresponds to each AVR source:

ID	Default Name
25	BD
04	DVD
06	SAT/CBL
10	VIDEO
15	DVR/BDR
19	HDMI 1
20	HDMI 2
21	HDMI 3
22	HDMI 4
23	HDMI 5
24	HDMI 6
34	HDMI 7
49	GAME
26	NETWORK (cyclic)
38	INTERNET RADIO
53	Spotify
41	PANDORA
44	MEDIA SERVER
45	FAVORITES
17	iPod/USB
05	TV
01	CD
13	USB-DAC
02	TUNER
00	PHONO
12	MULTI CH IN
33	BT AUDIO
31	HDMI (cyclic)
46	AirPlay (Information only)
47	DMR (Information only)

Breaking changes

0.8

• To enable params to be accessible from AVR response parsers and also to reduce the size of the main class, the PioneerAVR class has been split out to the classes listed below. References to parameter and properties methods and attributes will need to be updated to be accessed via the params and properties attributes of the PioneerAVR object. All other public attributes have moved to the new classes.
  • PioneerAVRParams contains the user and run-time parameter get/set methods. Some method names have changed, please consult the updated documentation for details
  • PioneerAVRProperties contains the cache of AVR properties collected from its responses
  • PioneerAVRConnection contains the connection related methods, although PioneerAVR inherits from the new class so the connection methods are still accessible via the PioneerAVR class
• Commands that are sent to the AVR to perform full updates are now executed via the command queue. This eliminates the previous interaction between the updater and command queue threads, as the updater now simply schedules updates via the command queue
• The order of queries during a full update has been modified so that amp, DSP and tone queries are executed before video queries
• The Zones enum has been renamed Zone for improved consistency
• The param module has been renamed params for improved consistency
• Exception handling within the AVR interface methods has been made more robust. The AVR listener and responders will now only trigger disconnection from the AVR (and reconnection if requested) if the AVR connection drops. Notably, parser exceptions and timeouts to power, volume and mute queries will no longer cause the AVR connection to disconnect and reconnect. This should fully resolve issues such as crowbarz/ha-pioneer_async#54
• Not detecting Zone 1 on the AVR on module startup has been demoted from an error to a warning and Zone 1 is assumed to exist. Despite this change, most AVR commands will still not work when the AVR is in this state. It is now up to the client to check that Zone 1 has been discovered and handle the case when it is not
• The source AVR zone property has been renamed source_id, and an additional source_name property has been introduced that contains the mapped name for the source for each zone
• The query_device_model method has been introduced to query the device model and set default model parameters. Previously, the query_device_info queried all device information including the device model regardless of whether the AVR main zone was powered on. Clients that previously called query_device_info at module startup should now call query_device_model. query_device_info will be automatically called when the main zone is powered on for the first time after connecting, and no longer needs to be called by the client
• If Zone 1 is not powered on at integration startup, queries for AVR device info is deferred until Zone 1 is first powered on.
• The query_audio_information and query_video_information commands have been renamed query_basic_audio_information and query_basic_video_information. These basic query commands, in addition to query_listening_mode, are executed with a delay after all zone power and source operations whenever any zone is powered on
• The system_query_source_name has been renamed to query_source_name to avoid being sent during AVR device info queries
• The query_sources method has been removed. PioneerAVRParams.get_runtime_param(PARAM_QUERY_SOURCES) should be used instead
• The update_zones method has been removed. Change the AVR zones by recreating the PioneerAVR object with the new zones
• The PioneerAVR.initial_update property has moved to run-time param PARAM_ZONES_INITIAL_REFRESH and is now a set of Zone. The PioneerAVRParams.zones_initial_refresh property is provided as a convenience to access this run-time parameter
• System parameters have been re-termed as run-time parameters to better reflect their function
• The PioneerAVRProperties.zones property now has typing set[Zone]

0.7

• Most PioneerAVR methods now raise exceptions derived from PioneerError when an error is encountered, rather than returning false, None or similar error value. Some instances that currently raise ValueError or SystemError will also raise PioneerError subclasses in the near future
• send_raw_request no longer accepts an argument ignore_error and will always raise exceptions on error. Use ignore_error with send_command to have exceptions handled for you
• asyncio yields have been optimised and minimised, which may cause certain sequences of operations to happen in a different order

0.6

• Python requirement bumped to 3.11 for StrEnum
• Zones enum now used on all methods accepting zone arguments (except in params)
• Zone argument removed from tuner methods as tuner is independent of zone
• TunerBand enum now used to specify a tuner band
• update now waits for the update to finish by default
• set_tuner_preset has been renamed to select_tuner_preset
• get_zone_listening_modes has been renamed to get_listening_modes
• set_listening_mode has been renamed to select_listening_mode
• tuner_*, get_zone_listening_modes, set_panel_lock, set_remote_lock and set_dimmer methods no longer accept a zone argument
• The suffix argument of the send_command method has been reordered after the prefix argument
• Response codes marked --- now return None
• Dimmer mode, tone mode and dB strings have been updated

0.5

• get_sound_modes was renamed to get_zone_listening_modes to reflect Pioneer AVR terminology
• disable_autoquery was renamed disable_auto_query to better match the underlying variable name
• amplifier_speaker_system_modes and disabled_amplifier_listening_modes were shortened to amp_speaker_system_modes and disabled_amp_listening_modes respectively

0.4

• zone_z_sources was renamed hdzone_sources for even more consistency

0.3

• zone_h_sources was renamed zone_z_sources for consistency

0.2

• volume_step_delta has been removed entirely
• By default, a number of additional queries are sent at module startup to the AVR to gather amp, tuner and channel levels attributes. If your AVR does not handle these additional queries well, they can be disabled by setting parameter disable_autoquery to true

0.1

• _PioneerAVR.__init__() no longer accepts command_delay, volume_workaround and volume_steps arguments. Configure these parameters using the equivalent PARAM_* keys in the params dict, passed in via the constructure or set via set_user_params()

References

• Home Assistant Pioneer integration: https://www.home-assistant.io/integrations/pioneer/
• Pioneer commands references: https://github.com/rwifall/pioneer-receiver-notes
• Another asyncio Pioneer HA component: https://github.com/realthk/asyncpioneer
• Pioneer IP and serial IO control documentation: https://www.pioneerelectronics.com/PUSA/Support/Home-Entertainment-Custom-Install/RS-232+&+IP+Codes/A+V+Receivers
  • This library supports many of the commands listed in the 2015 Pioneer & Elite AVR External Command document