Latest HA update broke AIMP plugin

[tomiisp]

Hi,

not sure if this project is still alive but working till now, after latest update of HA plugin stopped working and HA config show this error:
Platform error 'media_player' from integration 'aimp' - cannot import name 'MEDIA_TYPE_MUSIC' from 'homeassistant.components.media_player.const' (/usr/src/homeassistant/homeassistant/components/media_player/const.py)

Any solution or idea ?

/Tomi

[mobizon16]

replace the code (copy my entire code and paste it into your file) in the file
/config/custom_components/aimp/media_player.py

"""Support to interface with the AIMP Web API."""
import logging
import re

from datetime import timedelta
import requests
import json
import voluptuous as vol

from homeassistant.components.media_player import (
PLATFORM_SCHEMA,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaType,
)
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PORT,
STATE_IDLE,
STATE_OFF,
STATE_PAUSED,
STATE_PLAYING,
STATE_UNAVAILABLE,
)
import homeassistant.helpers.config_validation as cv
import homeassistant.util.dt as dt_util
from homeassistant.util import Throttle

_LOGGER = logging.getLogger(name)

DEFAULT_NAME = "AIMP"
DEFAULT_PORT = 3333

SUPPORT_AIMP = (
MediaPlayerEntityFeature.PAUSE
| MediaPlayerEntityFeature.VOLUME_SET
| MediaPlayerEntityFeature.VOLUME_MUTE
| MediaPlayerEntityFeature.PREVIOUS_TRACK
| MediaPlayerEntityFeature.NEXT_TRACK
| MediaPlayerEntityFeature.SEEK
| MediaPlayerEntityFeature.STOP
| MediaPlayerEntityFeature.PLAY
| MediaPlayerEntityFeature.SELECT_SOURCE
| MediaPlayerEntityFeature.SHUFFLE_SET
| MediaPlayerEntityFeature.CLEAR_PLAYLIST
)

PLAYLIST_UPDATE_INTERVAL = timedelta(seconds=15)

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_HOST): cv.string,
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
}
)

def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the AIMP platform."""
name = config.get(CONF_NAME)
host = config.get(CONF_HOST)
port = config.get(CONF_PORT)

add_entities([AIMP(name, host, port, hass)], True)

class AIMP(MediaPlayerEntity):
"""AIMP Player Object."""

def __init__(self, name, host, port, hass):
    """Initialize the media player."""
    self.host = host
    self.port = port
    self.hass = hass
    self._url = "{}:{}".format(host, str(port))
    self._name = name
    self._available = False

    self._aimp = None
    self._coverurl = {}
    self._playinfo = {}
    self._playlists = []
    self._playlists_db = dict()
    self._currentplaylist = None

    self._state = STATE_UNAVAILABLE
    self._state_dict = {}
    self._media_position = int()
    self._media_position_dict = {}
    self._media_position_updated_at = None
    self._volume_level = {}
    self._shuffle = {}
    self._is_volume_muted = {}

def send_aimp_msg(self, method, params):
    """Send message."""
    try:
        url = f"http://{self._url}/RPC_JSON"
        payload = {"version": "1.1", "method": method, "id": 1, "params": params}
        response = requests.post(url, json=payload, timeout=3)
        if response.status_code == 200:
            try:
                data = response.json()
                result = data["result"]
            except:
                result = None
        else:
            _LOGGER.error(
                "Query failed, response code: %s Full message: %s",
                response.status_code,
                response,
            )
            return False

    except requests.exceptions.RequestException:
        _LOGGER.error(
            "Could not send command %s to AIMP at: %s", method, self._url
        )
        return False
    try:
        return result
    except AttributeError:
        _LOGGER.error("Received invalid response: %s", data)
        return False

def update(self):
    """Update state."""
    if self._aimp is None:
        try:
            url = f"http://{self._url}/RPC_JSON"
            payload = {"version":"1.1","method":"Status","id":1,"params":{"status_id":4}}
            response = requests.post(url, json=payload, timeout=3)
            if response.status_code == 200:
                self._available = True
                self.update_playinfo()
                self.update_coverurl()
                self.update_state()
                self.update_media_position()
                self.update_volume_level()
                self.update_shuffle()
                self.update_is_volume_muted()
                self.update_playlists()
                
        except requests.exceptions.RequestException:
            if self._available:
                _LOGGER.error(
                    "Connect error to AIMP at: %s", self._url
                )
                self._available = False
            self._aimp = None
            return

        self._state = STATE_IDLE
        self._available = True

def update_playinfo(self):
    resp = self.send_aimp_msg("GetPlaylistEntryInfo", {"playlist_id": -1, "track_id": -1})
    if resp is False:
        return
    self._playinfo = resp.copy()

def update_coverurl(self):
    resp = self.send_aimp_msg("GetCover", {"playlist_id": -1, "track_id": -1, "cover_width": 512, "cover_height": 512})
    if resp is False:
        return
    elif resp is None:
        self._coverurl = {}
    else:
        self._coverurl = resp.copy()

def update_state(self):
    resp = self.send_aimp_msg("Status", {"status_id":4})
    if resp is False:
        return
    self._state_dict = resp.copy()

def update_media_position(self):
    resp = self.send_aimp_msg("Status", {"status_id":31})
    if resp is False:
        return
    self._media_position_dict = resp.copy()

def update_volume_level(self):
    resp = self.send_aimp_msg("Status", {"status_id":1})
    if resp is False:
        return
    self._volume_level = resp.copy()

def update_shuffle(self):
    resp = self.send_aimp_msg("Status", {"status_id":41})
    if resp is False:
        return
    self._shuffle = resp.copy()

def update_is_volume_muted(self):
    resp = self.send_aimp_msg("Status", {"status_id":5})
    if resp is False:
        return
    self._is_volume_muted = resp.copy()

@property
def media_content_type(self):
    """Content type of current playing media."""
    return MediaType.MUSIC

@property
def state(self):
    """Return the state of the device."""
    playback_state = self._state_dict.get("value", None)
    if playback_state == 2:
        return STATE_PAUSED
    if playback_state == 1:
        return STATE_PLAYING
    return STATE_IDLE

@property
def available(self):
    """Return True if entity is available."""
    return self._available

@property
def media_title(self):
    """Title of current playing media."""
    return self._playinfo.get("title", None)

@property
def media_artist(self):
    """Artist of current playing media (Music track only)."""
    return self._playinfo.get("artist", None)

@property
def media_album_name(self):
    """Artist of current playing media (Music track only)."""
    return self._playinfo.get("album", None)

@property
def media_image_url(self):
    """Image url of current playing media."""
    url = self._coverurl.get("album_cover_uri", None)
    if url is None:
        return None
    if str(url[0:2]).lower() == "ht":
        mediaurl = url
    else:
        mediaurl = f"http://{self.host}:{self.port}/{url}"
    return mediaurl

@property
def media_position(self):
    """Time in seconds of current seek position."""
    time = self._media_position_dict.get("value")
    if time is None:
        return None
    return int(time)

@property
def media_position_updated_at(self):
    """When was the position of the current playing media valid."""
    time = dt_util.utcnow()
    return time

@property
def media_duration(self):
    """Time in seconds of current song duration."""
    time = self._playinfo.get("duration")
    if time is None:
        return None

    return int(time) // 1000

@property
def volume_level(self):
    """Volume level of the media player (0..1)."""
    volume = self._volume_level.get("value", None)
    if volume is not None and volume != "":
        volume = int(volume) / 100
    return volume

@property
def is_volume_muted(self):
    """Boolean if volume is currently muted."""
    return self._is_volume_muted.get("value", 0) == 1

@property
def name(self):
    """Return the name of the device."""
    return self._name

@property
def shuffle(self):
    """Boolean if shuffle is enabled."""
    return self._shuffle.get("value", 0) == 1

@property
def source_list(self):
    """Return the list of available input sources."""
    return self._playlists

@property
def source(self):
    """Name of the current input source."""
    playlistid = self._playinfo.get("playlist_id", None)
    playlistname = self._playlists_db[str(playlistid)]
    self._currentplaylist = playlistname
    return self._currentplaylist

@property
def supported_features(self):
    """Flag of media commands that are supported."""
    return SUPPORT_AIMP

def media_next_track(self):
    """Send media_next command to media player."""
    self.send_aimp_msg("PlayNext", "{}")

def media_previous_track(self):
    """Send media_previous command to media player."""
    self.send_aimp_msg("PlayPrevious", "{}")

def media_play(self):
    """Send media_play command to media player."""
    self.send_aimp_msg("Play", "{}")

def media_pause(self):
    """Send media_pause command to media player."""
    self.send_aimp_msg("Pause", "{}")

def media_stop(self):
    """Send media_pause command to media player."""
    self.send_aimp_msg("Stop", "{}")

def set_volume_level(self, volume):
    """Send volume_up command to media player."""
    self.send_aimp_msg("Status", {"status_id": 1, "value": int(volume * 100)})

def mute_volume(self, mute):
    """Send mute command to media player."""
    mutecmd = 1 if mute else 0
    self.send_aimp_msg("Status", {"status_id": 5, "value": mutecmd })

def set_shuffle(self, shuffle):
    """Enable/disable shuffle mode."""
    shufflecmd = 1 if shuffle else 0
    # Исправлено: status_id 41 для shuffle (было ошибочно 5)
    self.send_aimp_msg("Status", {"status_id": 41, "value": shufflecmd })
    
def media_seek(self, position):
    """Send seek command."""
    self.send_aimp_msg("Status", {"status_id": 31, "value": int(position) })

def select_source(self, source):
    """Choose a different available playlist and play it."""
    self._currentplaylist = source
    
    def get_key(val):
        for key, value in self._playlists_db.items():
             if val == value:
                 return key
        return "key doesn't exist"

    playlistid = get_key(source)
    resp = self.send_aimp_msg("GetPlaylistEntries", {"playlist_id":int(playlistid),"fields":["album","artist","bitrate","genre","duration","filesize","date","id","rating"]})
    try: 
        entries = resp.get("entries")
    except:
        _LOGGER.error("Received invalid response: resp: %s", resp,)
        return False
        
    try:
        trackinfo = list(entries[0])
    except:
        _LOGGER.error("Received invalid response: : entries: %s", entries,)
        return False
        
    try:
        trackid = trackinfo[7]
    except:
        _LOGGER.error("Received invalid response: trackinfo: %s", trackinfo,)
        return False

    resp2 = self.send_aimp_msg("Play", {"playlist_id": int(playlistid), "track_id": int(trackid)})
    if resp2 is False:
        return
    
def clear_playlist(self):
    """Clear players playlist."""
    self._currentplaylist = None
    self.send_aimp_msg("Stop", "{}")

@Throttle(PLAYLIST_UPDATE_INTERVAL)
def update_playlists(self, **kwargs):
    """Update available AIMP playlists."""
    playlists = self.send_aimp_msg(
        "GetPlaylists", "{fields: [\"id\", \"title\", \"crc32\"]}}"
    )
    self._playlists = re.findall(r"'title': '(.+?)'", str(playlists))
    
    playlists_db = re.findall(r"'id': (.+?), 'title': '(.+?)'", str(playlists))
    for var in playlists_db:
        self._playlists_db[var[0]] = var[1]

    # _LOGGER.debug(
    #     "Success! self._playlists_db: %s",
    #     self._playlists_db,
    # )