"""All constants for Music Assistant."""
import pathlib
-from typing import Final
+from typing import Final, cast
from music_assistant_models.config_entries import (
+ MULTI_VALUE_SPLITTER,
ConfigEntry,
ConfigValueOption,
- MultiValueConfigEntry,
)
from music_assistant_models.enums import ConfigEntryType, ContentType
from music_assistant_models.media_items import AudioFormat
{**CONF_ENTRY_PLAYER_ICON.to_dict(), "default_value": "mdi-speaker-multiple"}
)
-CONF_ENTRY_SAMPLE_RATES = MultiValueConfigEntry(
+
+CONF_ENTRY_SAMPLE_RATES = ConfigEntry(
key=CONF_SAMPLE_RATES,
- type=ConfigEntryType.INTEGER_TUPLE,
+ type=ConfigEntryType.SPLITTED_STRING,
+ multi_value=True,
options=[
- ConfigValueOption("44.1kHz / 16 bits", (44100, 16)),
- ConfigValueOption("44.1kHz / 24 bits", (44100, 24)),
- ConfigValueOption("48kHz / 16 bits", (48000, 16)),
- ConfigValueOption("48kHz / 24 bits", (48000, 24)),
- ConfigValueOption("88.2kHz / 16 bits", (88200, 16)),
- ConfigValueOption("88.2kHz / 24 bits", (88200, 24)),
- ConfigValueOption("96kHz / 16 bits", (96000, 16)),
- ConfigValueOption("96kHz / 24 bits", (96000, 24)),
- ConfigValueOption("176.4kHz / 16 bits", (176400, 16)),
- ConfigValueOption("176.4kHz / 24 bits", (176400, 24)),
- ConfigValueOption("192kHz / 16 bits", (192000, 16)),
- ConfigValueOption("192kHz / 24 bits", (192000, 24)),
- ConfigValueOption("352.8kHz / 16 bits", (352800, 16)),
- ConfigValueOption("352.8kHz / 24 bits", (352800, 24)),
- ConfigValueOption("384kHz / 16 bits", (384000, 16)),
- ConfigValueOption("384kHz / 24 bits", (384000, 24)),
+ ConfigValueOption("44.1kHz / 16 bits", f"44100{MULTI_VALUE_SPLITTER}16"),
+ ConfigValueOption("44.1kHz / 24 bits", f"44100{MULTI_VALUE_SPLITTER}24"),
+ ConfigValueOption("48kHz / 16 bits", f"48000{MULTI_VALUE_SPLITTER}16"),
+ ConfigValueOption("48kHz / 24 bits", f"48000{MULTI_VALUE_SPLITTER}24"),
+ ConfigValueOption("88.2kHz / 16 bits", f"88200{MULTI_VALUE_SPLITTER}16"),
+ ConfigValueOption("88.2kHz / 24 bits", f"88200{MULTI_VALUE_SPLITTER}24"),
+ ConfigValueOption("96kHz / 16 bits", f"96000{MULTI_VALUE_SPLITTER}16"),
+ ConfigValueOption("96kHz / 24 bits", f"96000{MULTI_VALUE_SPLITTER}24"),
+ ConfigValueOption("176.4kHz / 16 bits", f"176400{MULTI_VALUE_SPLITTER}16"),
+ ConfigValueOption("176.4kHz / 24 bits", f"176400{MULTI_VALUE_SPLITTER}24"),
+ ConfigValueOption("192kHz / 16 bits", f"192000{MULTI_VALUE_SPLITTER}16"),
+ ConfigValueOption("192kHz / 24 bits", f"192000{MULTI_VALUE_SPLITTER}24"),
+ ConfigValueOption("352.8kHz / 16 bits", f"352800{MULTI_VALUE_SPLITTER}16"),
+ ConfigValueOption("352.8kHz / 24 bits", f"352800{MULTI_VALUE_SPLITTER}24"),
+ ConfigValueOption("384kHz / 16 bits", f"384000{MULTI_VALUE_SPLITTER}16"),
+ ConfigValueOption("384kHz / 24 bits", f"384000{MULTI_VALUE_SPLITTER}24"),
],
- default_value=[(44100, 16), (48000, 16)],
+ default_value=[f"44100{MULTI_VALUE_SPLITTER}16", f"44100{MULTI_VALUE_SPLITTER}24"],
required=True,
label="Sample rates supported by this player",
category="advanced",
safe_max_bit_depth: int = 16,
hidden: bool = False,
supported_sample_rates: list[int] | None = None,
-) -> MultiValueConfigEntry:
+) -> ConfigEntry:
"""Create sample rates config entry based on player specific helpers."""
assert CONF_ENTRY_SAMPLE_RATES.options
- conf_entry = MultiValueConfigEntry.from_dict(CONF_ENTRY_SAMPLE_RATES.to_dict())
+ conf_entry = ConfigEntry.from_dict(CONF_ENTRY_SAMPLE_RATES.to_dict())
conf_entry.hidden = hidden
options: list[ConfigValueOption] = []
- default_value: list[tuple[int, int]] = []
+ default_value: list[str] = []
for option in CONF_ENTRY_SAMPLE_RATES.options:
- if not isinstance(option.value, tuple):
- continue
- sample_rate, bit_depth = option.value
+ option_value = cast(str, option.value)
+ sample_rate_str, bit_depth_str = option_value.split(MULTI_VALUE_SPLITTER, 1)
+ sample_rate = int(sample_rate_str)
+ bit_depth = int(bit_depth_str)
if supported_sample_rates and sample_rate not in supported_sample_rates:
continue
if sample_rate <= max_sample_rate and bit_depth <= max_bit_depth:
options.append(option)
if sample_rate <= safe_max_sample_rate and bit_depth <= safe_max_bit_depth:
- default_value.append(option.value)
+ default_value.append(option_value)
conf_entry.options = options
conf_entry.default_value = default_value
return conf_entry
from collections.abc import Callable, Iterator, MutableMapping
from typing import TYPE_CHECKING, Any, ParamSpec, TypeVar
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import ConfigEntryType
from music_assistant.constants import DB_TABLE_CACHE, DB_TABLE_SETTINGS, MASS_LOGGER_NAME
async def get_config_entries(
self,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
if action == CONF_CLEAR_CACHE:
from cryptography.fernet import Fernet, InvalidToken
from music_assistant_models import config_entries
from music_assistant_models.config_entries import (
+ MULTI_VALUE_SPLITTER,
ConfigEntry,
- ConfigValueTypes,
+ ConfigValueType,
CoreConfig,
PlayerConfig,
ProviderConfig,
self._data: dict[str, Any] = {}
self.filename = os.path.join(self.mass.storage_path, "settings.json")
self._timer_handle: asyncio.TimerHandle | None = None
- self._value_cache: dict[str, ConfigValueTypes] = {}
+ self._value_cache: dict[str, ConfigValueType] = {}
async def setup(self) -> None:
"""Async initialize of controller."""
raise KeyError(msg)
@api_command("config/providers/get_value")
- async def get_provider_config_value(self, instance_id: str, key: str) -> ConfigValueTypes:
+ async def get_provider_config_value(self, instance_id: str, key: str) -> ConfigValueType:
"""Return single configentry value for a provider."""
cache_key = f"prov_conf_value_{instance_id}.{key}"
if (cached_value := self._value_cache.get(cache_key)) is not None:
provider_domain: str,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup/configure a provider.
async def save_provider_config(
self,
provider_domain: str,
- values: dict[str, ConfigValueTypes],
+ values: dict[str, ConfigValueType],
instance_id: str | None = None,
) -> ProviderConfig:
"""
self,
player_id: str,
key: str,
- ) -> ConfigValueTypes:
+ unpack_splitted_values: bool = False,
+ ) -> ConfigValueType:
"""Return single configentry value for a player."""
conf = await self.get_player_config(player_id)
+ if unpack_splitted_values:
+ return conf.values[key].get_splitted_values()
return (
conf.values[key].value
if conf.values[key].value is not None
)
def get_raw_player_config_value(
- self, player_id: str, key: str, default: ConfigValueTypes = None
- ) -> ConfigValueTypes:
+ self, player_id: str, key: str, default: ConfigValueType = None
+ ) -> ConfigValueType:
"""
Return (raw) single configentry value for a player.
@api_command("config/players/save")
async def save_player_config(
- self, player_id: str, values: dict[str, ConfigValueTypes]
+ self, player_id: str, values: dict[str, ConfigValueType]
) -> PlayerConfig:
"""Save/update PlayerConfig."""
config = await self.get_player_config(player_id)
provider: str,
name: str,
enabled: bool,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> None:
"""
Create default/empty PlayerConfig.
return CoreConfig.parse(config_entries, raw_conf)
@api_command("config/core/get_value")
- async def get_core_config_value(self, domain: str, key: str) -> ConfigValueTypes:
+ async def get_core_config_value(self, domain: str, key: str) -> ConfigValueType:
"""Return single configentry value for a core controller."""
conf = await self.get_core_config(domain)
return (
self,
domain: str,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to configure a core controller.
async def save_core_config(
self,
domain: str,
- values: dict[str, ConfigValueTypes],
+ values: dict[str, ConfigValueType],
) -> CoreConfig:
"""Save CoreController Config values."""
config = await self.get_core_config(domain)
return await self.get_core_config(domain)
def get_raw_core_config_value(
- self, core_module: str, key: str, default: ConfigValueTypes = None
- ) -> ConfigValueTypes:
+ self, core_module: str, key: str, default: ConfigValueType = None
+ ) -> ConfigValueType:
"""
Return (raw) single configentry value for a core controller.
)
def get_raw_provider_config_value(
- self, provider_instance: str, key: str, default: ConfigValueTypes = None
- ) -> ConfigValueTypes:
+ self, provider_instance: str, key: str, default: ConfigValueType = None
+ ) -> ConfigValueType:
"""
Return (raw) single config(entry) value for a provider.
self,
provider_instance: str,
key: str,
- value: ConfigValueTypes,
+ value: ConfigValueType,
encrypted: bool = False,
) -> None:
"""
if prov := self.mass.get_provider(provider_instance, return_unavailable=True):
prov.config.values[key].value = value
- def set_raw_core_config_value(
- self, core_module: str, key: str, value: ConfigValueTypes
- ) -> None:
+ def set_raw_core_config_value(self, core_module: str, key: str, value: ConfigValueType) -> None:
"""
Set (raw) single config(entry) value for a core controller.
self.set(f"{CONF_CORE}/{core_module}", CoreConfig({}, core_module).to_raw())
self.set(f"{CONF_CORE}/{core_module}/values/{key}", value)
- def set_raw_player_config_value(
- self, player_id: str, key: str, value: ConfigValueTypes
- ) -> None:
+ def set_raw_player_config_value(self, player_id: str, key: str, value: ConfigValueType) -> None:
"""
Set (raw) single config(entry) value for a player.
self._data[CONF_PROVIDERS].pop(instance_id, None)
LOGGER.warning("Removed corrupt provider configuration: %s", instance_id)
changed = True
+ # migrate sample_rates config entry
+ for player_id, player_config in list(self._data.get(CONF_PLAYERS, {}).items()):
+ if not (values := player_config.get("values")):
+ continue
+ if not (sample_rates := values.get("sample_rates")):
+ continue
+ if not isinstance(sample_rates, list):
+ del player_config["values"]["sample_rates"]
+ if not any(isinstance(x, list) for x in sample_rates):
+ continue
+ player_config["values"]["sample_rates"] = [
+ f"{x[0]}{MULTI_VALUE_SPLITTER}{x[1]}" if isinstance(x, list) else x
+ for x in sample_rates
+ ]
+ changed = True
if changed:
await self._async_save()
await self.mass.load_provider_config(config)
async def _update_provider_config(
- self, instance_id: str, values: dict[str, ConfigValueTypes]
+ self, instance_id: str, values: dict[str, ConfigValueType]
) -> ProviderConfig:
"""Update ProviderConfig."""
config = await self.get_provider_config(instance_id)
async def _add_provider_config(
self,
provider_domain: str,
- values: dict[str, ConfigValueTypes],
+ values: dict[str, ConfigValueType],
) -> list[ConfigEntry] | ProviderConfig:
"""
Add new Provider (instance).
import aiofiles
from aiohttp import web
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
from music_assistant_models.enums import (
AlbumType,
ConfigEntryType,
async def get_config_entries(
self,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
return (
from math import inf
from typing import TYPE_CHECKING, Final, cast
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import (
CacheCategory,
ConfigEntryType,
async def get_config_entries(
self,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
entries = (
if provider_instance.startswith(("filesystem", "jellyfin", "plex", "opensubsonic")):
# removal of a local provider can become messy very fast due to the relations
# such as images pointing at the files etc. so we just reset the whole db
+ # TODO: Handle this more gracefully in the future where we remove the provider
+ # and traverse the database to also remove all related items.
self.logger.warning(
"Removal of local provider detected, issuing full database reset..."
)
from types import NoneType
from typing import TYPE_CHECKING, Any, TypedDict, cast
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
from music_assistant_models.enums import (
CacheCategory,
ConfigEntryType,
async def get_config_entries(
self,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
enqueue_options = [ConfigValueOption(x.name, x.value) for x in QueueOption]
from aiofiles.os import wrap
from aiohttp import web
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
async def get_config_entries(
self,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
default_ip = await get_ip()
) -> AudioFormat:
"""Parse (player specific) output format details for given format string."""
content_type: ContentType = ContentType.try_parse(output_format_str)
- supported_rates_conf = await self.mass.config.get_player_config_value(
- player.player_id, CONF_SAMPLE_RATES
+ supported_rates_conf: list[
+ tuple[str, str]
+ ] = await self.mass.config.get_player_config_value(
+ player.player_id, CONF_SAMPLE_RATES, unpack_splitted_values=True
)
- supported_sample_rates: tuple[int] = tuple(x[0] for x in supported_rates_conf)
- supported_bit_depths: tuple[int] = tuple(x[1] for x in supported_rates_conf)
+ supported_sample_rates: tuple[int] = tuple(int(x[0]) for x in supported_rates_conf)
+ supported_bit_depths: tuple[int] = tuple(int(x[1]) for x in supported_rates_conf)
+
player_max_bit_depth = max(supported_bit_depths)
if content_type.is_pcm() or content_type == ContentType.WAV:
# parse pcm details from format string
player: Player,
) -> AudioFormat:
"""Parse (player specific) flow stream PCM format."""
- supported_rates_conf = await self.mass.config.get_player_config_value(
- player.player_id, CONF_SAMPLE_RATES
+ supported_rates_conf: list[
+ tuple[str, str]
+ ] = await self.mass.config.get_player_config_value(
+ player.player_id, CONF_SAMPLE_RATES, unpack_splitted_values=True
)
- supported_sample_rates: tuple[int] = tuple(x[0] for x in supported_rates_conf)
+ supported_sample_rates: tuple[int] = tuple(int(x[0]) for x in supported_rates_conf)
output_sample_rate = DEFAULT_PCM_FORMAT.sample_rate
for sample_rate in (192000, 96000, 48000, 44100):
if sample_rate in supported_sample_rates:
if TYPE_CHECKING:
from collections.abc import Awaitable
- from music_assistant_models.config_entries import ConfigValueTypes, CoreConfig
+ from music_assistant_models.config_entries import ConfigValueType, CoreConfig
from music_assistant_models.event import MassEvent
DEFAULT_SERVER_PORT = 8095
async def get_config_entries(
self,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
default_publish_ip = await get_ip()
from .plugin import PluginProvider
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
from music_assistant_models.provider import ProviderManifest
from music_assistant import MusicAssistant
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from music_assistant.constants import CONF_LOG_LEVEL, MASS_LOGGER_NAME
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, CoreConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, CoreConfig
from music_assistant import MusicAssistant
async def get_config_entries(
self,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
return ()
from music_assistant.models.music_provider import MusicProvider
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
from music_assistant_models.provider import ProviderManifest
from music_assistant.mass import MusicAssistant
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
"""
# ruff: noqa: ARG001
# Config Entries are used to configure the Music Provider if needed.
- # See the models of ConfigEntry and ConfigValueTypes for more information what is supported.
+ # See the models of ConfigEntry and ConfigValueType for more information what is supported.
# The ConfigEntry is a dataclass that represents a single configuration entry.
- # The ConfigValueTypes is an Enum that represents the type of value that
+ # The ConfigValueType is an Enum that represents the type of value that
# can be stored in a ConfigEntry.
# If your provider does not need any configuration, you can return an empty tuple.
if TYPE_CHECKING:
from music_assistant_models.config_entries import (
ConfigEntry,
- ConfigValueTypes,
+ ConfigValueType,
PlayerConfig,
ProviderConfig,
)
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
"""
# ruff: noqa: ARG001
# Config Entries are used to configure the Player Provider if needed.
- # See the models of ConfigEntry and ConfigValueTypes for more information what is supported.
+ # See the models of ConfigEntry and ConfigValueType for more information what is supported.
# The ConfigEntry is a dataclass that represents a single configuration entry.
- # The ConfigValueTypes is an Enum that represents the type of value that
+ # The ConfigValueType is an Enum that represents the type of value that
# can be stored in a ConfigEntry.
# If your provider does not need any configuration, you can return an empty tuple.
return ()
from music_assistant.models.plugin import PluginProvider, PluginSource
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
from music_assistant_models.event import MassEvent
from music_assistant_models.provider import ProviderManifest
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
"""
# ruff: noqa: ARG001
# Config Entries are used to configure the Provider if needed.
- # See the models of ConfigEntry and ConfigValueTypes for more information what is supported.
+ # See the models of ConfigEntry and ConfigValueType for more information what is supported.
# The ConfigEntry is a dataclass that represents a single configuration entry.
- # The ConfigValueTypes is an Enum that represents the type of value that
+ # The ConfigValueType is an Enum that represents the type of value that
# can be stored in a ConfigEntry.
# If your provider does not need any configuration, you can return an empty tuple.
return ()
from typing import TYPE_CHECKING, cast
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, ProviderConfig
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
from music_assistant_models.enums import ConfigEntryType
from music_assistant_models.provider import ProviderManifest
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from typing import TYPE_CHECKING, Any
import aiofiles
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import (
AlbumType,
ConfigEntryType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from music_assistant_models.config_entries import (
ConfigEntry,
ConfigValueOption,
- ConfigValueTypes,
+ ConfigValueType,
ProviderConfig,
)
from music_assistant_models.enums import ConfigEntryType, EventType, MediaType, ProviderFeature
mass: MusicAssistant,
instance_id: str | None = None, # noqa: ARG001
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
)
from aioaudiobookshelf.schema.library import LibraryMediaType as AbsLibraryMediaType
from mashumaro.mixins.dict import DataClassDictMixin
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, ProviderConfig
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from music_assistant.models.player_provider import PlayerProvider
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
from music_assistant_models.provider import ProviderManifest
from zeroconf.asyncio import AsyncServiceInfo
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Set up legacy BluOS devices."""
# ruff: noqa: ARG001
from music_assistant.models.music_provider import MusicProvider
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueType, ProviderConfig
from music_assistant_models.provider import ProviderManifest
from music_assistant.mass import MusicAssistant
mass: MusicAssistant, # noqa: ARG001
instance_id: str | None = None, # noqa: ARG001
action: str | None = None, # noqa: ARG001
- values: dict[str, ConfigValueTypes] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueType] | None = None, # noqa: ARG001
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from .helpers import CastStatusListener, ChromecastInfo
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueType, ProviderConfig
from music_assistant_models.provider import ProviderManifest
from pychromecast.controllers.media import MediaStatus
from pychromecast.controllers.receiver import CastStatus
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from aiohttp import ClientSession, ClientTimeout
from Crypto.Cipher import Blowfish
from deezer import exceptions as deezer_exceptions
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, ProviderConfig
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
from music_assistant_models.enums import (
AlbumType,
ConfigEntryType,
mass: MusicAssistant,
instance_id: str | None = None, # noqa: ARG001
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return Config entries to setup this provider."""
# Action is to launch oauth flow
from async_upnp_client.exceptions import UpnpError, UpnpResponseError
from async_upnp_client.profiles.dlna import DmrDevice, TransportState
from async_upnp_client.search import async_search
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import ConfigEntryType, PlayerFeature, PlayerState, PlayerType
from music_assistant_models.errors import PlayerUnavailableError
from music_assistant_models.player import DeviceInfo, Player, PlayerMedia
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from music_assistant.models.metadata_provider import MetadataProvider
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueType, ProviderConfig
from music_assistant_models.media_items import Album, Artist
from music_assistant_models.provider import ProviderManifest
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
)
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
from music_assistant_models.provider import ProviderManifest
from music_assistant.mass import MusicAssistant
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
import platform
from typing import TYPE_CHECKING
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import ConfigEntryType
from music_assistant_models.errors import LoginFailed
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from typing import TYPE_CHECKING
from fullykiosk import FullyKiosk
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import ConfigEntryType, PlayerFeature, PlayerState, PlayerType
from music_assistant_models.errors import PlayerUnavailableError, SetupFailedError
from music_assistant_models.player import DeviceInfo, Player, PlayerMedia
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
get_token,
get_websocket_url,
)
-from music_assistant_models.config_entries import (
- ConfigEntry,
- ConfigValueOption,
- ConfigValueTypes,
- MultiValueConfigEntry,
-)
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
from music_assistant_models.enums import ConfigEntryType
from music_assistant_models.errors import LoginFailed, SetupFailedError
from music_assistant_models.player_control import PlayerControl
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
return (
*base_entries,
- MultiValueConfigEntry(
+ ConfigEntry(
key=CONF_POWER_CONTROLS,
type=ConfigEntryType.STRING,
+ multi_value=True,
label=CONF_POWER_CONTROLS,
default_value=[],
),
- MultiValueConfigEntry(
+ ConfigEntry(
key=CONF_VOLUME_CONTROLS,
type=ConfigEntryType.STRING,
+ multi_value=True,
label=CONF_VOLUME_CONTROLS,
default_value=[],
),
- MultiValueConfigEntry(
+ ConfigEntry(
key=CONF_MUTE_CONTROLS,
type=ConfigEntryType.STRING,
+ multi_value=True,
label=CONF_MUTE_CONTROLS,
default_value=[],
),
all_mute_entities.sort(key=lambda x: x.title)
all_volume_entities.sort(key=lambda x: x.title)
return (
- MultiValueConfigEntry(
+ ConfigEntry(
key=CONF_POWER_CONTROLS,
type=ConfigEntryType.STRING,
+ multi_value=True,
label="Player Power Control entities",
required=True,
options=all_power_entities,
"like to import as player Power controls in Music Assistant.",
category="player_controls",
),
- MultiValueConfigEntry(
+ ConfigEntry(
key=CONF_VOLUME_CONTROLS,
type=ConfigEntryType.STRING,
+ multi_value=True,
label="Player Volume Control entities",
required=True,
options=all_volume_entities,
"like to import as player Volume controls in Music Assistant.",
category="player_controls",
),
- MultiValueConfigEntry(
+ ConfigEntry(
key=CONF_MUTE_CONTROLS,
type=ConfigEntryType.STRING,
+ multi_value=True,
label="Player Mute Control entities",
required=True,
options=all_mute_entities,
from typing import TYPE_CHECKING, Any
from hass_client.exceptions import FailedCommand
-from music_assistant_models.config_entries import (
- ConfigEntry,
- ConfigValueOption,
- ConfigValueTypes,
- MultiValueConfigEntry,
-)
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
from music_assistant_models.enums import ConfigEntryType, PlayerFeature, PlayerState, PlayerType
from music_assistant_models.errors import SetupFailedError
from music_assistant_models.player import DeviceInfo, Player, PlayerMedia
mass: MusicAssistant,
instance_id: str | None = None, # noqa: ARG001
action: str | None = None, # noqa: ARG001
- values: dict[str, ConfigValueTypes] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueType] | None = None, # noqa: ARG001
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
name = f"{state['attributes']['friendly_name']} ({state['entity_id']})"
player_entities.append(ConfigValueOption(name, state["entity_id"]))
return (
- MultiValueConfigEntry(
+ ConfigEntry(
key=CONF_PLAYERS,
type=ConfigEntryType.STRING,
+ multi_value=True,
label="Player entities",
required=True,
options=player_entities,
from aiohttp import ClientSession
from ibroadcastaio import IBroadcastClient
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import (
AlbumType,
ConfigEntryType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from aiojellyfin import MediaLibrary as JellyMediaLibrary
from aiojellyfin import NotFound, authenticate_by_name
from aiojellyfin.session import SessionConfiguration
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, ProviderConfig
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
from music_assistant_models.enums import ConfigEntryType, MediaType, ProviderFeature, StreamType
from music_assistant_models.errors import LoginFailed, MediaNotFoundError
from music_assistant_models.media_items import (
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from music_assistant.models.metadata_provider import MetadataProvider
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
from music_assistant_models.media_items import Album, Track
from music_assistant_models.provider import ProviderManifest
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from typing import TYPE_CHECKING
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, ProviderConfig
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
from music_assistant_models.enums import ConfigEntryType
from music_assistant.constants import CONF_PASSWORD, CONF_PATH, CONF_PORT, CONF_USERNAME
mass: MusicAssistant, # noqa: ARG001
instance_id: str | None = None, # noqa: ARG001
action: str | None = None, # noqa: ARG001
- values: dict[str, ConfigValueTypes] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueType] | None = None, # noqa: ARG001
) -> tuple[ConfigEntry, ...]:
"""Return Config entries to setup this provider."""
return (
from music_assistant_models.config_entries import (
ConfigEntry,
ConfigValueOption,
- ConfigValueTypes,
- MultiValueConfigEntry,
+ ConfigValueType,
PlayerConfig,
)
from music_assistant_models.constants import PLAYER_CONTROL_NATIVE, PLAYER_CONTROL_NONE
hidden=True,
required=True,
)
-CONF_ENTRY_GROUP_MEMBERS = MultiValueConfigEntry(
+CONF_ENTRY_GROUP_MEMBERS = ConfigEntry(
key=CONF_GROUP_MEMBERS,
type=ConfigEntryType.STRING,
+ multi_value=True,
label="Group members",
default_value=[],
description="Select all players you want to be part of this group",
mass: MusicAssistant, # noqa: ARG001
instance_id: str | None = None, # noqa: ARG001
action: str | None = None, # noqa: ARG001
- values: dict[str, ConfigValueTypes] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueType] | None = None, # noqa: ARG001
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from music_assistant_models.config_entries import (
ConfigEntry,
ConfigValueOption,
- ConfigValueTypes,
+ ConfigValueType,
ProviderConfig,
)
from music_assistant_models.enums import (
mass: MusicAssistant,
instance_id: str | None = None, # noqa: ARG001
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from typing import TYPE_CHECKING
import podcastparser
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from typing import TYPE_CHECKING
from aiohttp import client_exceptions
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import (
AlbumType,
ConfigEntryType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from collections.abc import AsyncGenerator, Sequence
from typing import TYPE_CHECKING, cast
-from music_assistant_models.config_entries import ConfigEntry, MultiValueConfigEntry
+from music_assistant_models.config_entries import ConfigEntry
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
}
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueType, ProviderConfig
from music_assistant_models.provider import ProviderManifest
from music_assistant.mass import MusicAssistant
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
"""
# ruff: noqa: ARG001 D205
return (
- MultiValueConfigEntry(
+ ConfigEntry(
# RadioBrowser doesn't support a library feature at all
# but MA users like to favorite their radio stations and
# have that included in backups so we store it in the config.
key=CONF_STORED_RADIOS,
type=ConfigEntryType.STRING,
+ multi_value=True,
label=CONF_STORED_RADIOS,
default_value=[],
required=False,
from collections.abc import AsyncGenerator, Awaitable, Sequence
from typing import TYPE_CHECKING, Any, cast
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from music_assistant_models.config_entries import (
ConfigEntry,
ConfigValueOption,
- ConfigValueTypes,
+ ConfigValueType,
PlayerConfig,
)
from music_assistant_models.enums import (
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from typing import TYPE_CHECKING, Final, cast
from bidict import bidict
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
mass: MusicAssistant, # noqa: ARG001
instance_id: str | None = None, # noqa: ARG001
action: str | None = None, # noqa: ARG001
- values: dict[str, ConfigValueTypes] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueType] | None = None, # noqa: ARG001
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from .provider import CONF_IPS, SonosPlayerProvider
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueType, ProviderConfig
from music_assistant_models.provider import ProviderManifest
from music_assistant import MusicAssistant
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from dataclasses import dataclass, field
from typing import TYPE_CHECKING, cast
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import (
ConfigEntryType,
PlayerFeature,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
import time
from typing import TYPE_CHECKING, Any
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from typing import TYPE_CHECKING, Any, cast
from urllib.parse import urlencode
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import (
AlbumType,
ConfigEntryType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
if TYPE_CHECKING:
from aiohttp.web import Request
- from music_assistant_models.config_entries import ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueType, ProviderConfig
from music_assistant_models.event import MassEvent
from music_assistant_models.provider import ProviderManifest
mass: MusicAssistant,
instance_id: str | None = None, # noqa: ARG001
action: str | None = None, # noqa: ARG001
- values: dict[str, ConfigValueTypes] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueType] | None = None, # noqa: ARG001
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from music_assistant.models.music_provider import MusicProvider
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueType, ProviderConfig
from music_assistant_models.provider import ProviderManifest
from music_assistant.mass import MusicAssistant
mass: MusicAssistant, # noqa: ARG001
instance_id: str | None = None, # noqa: ARG001
action: str | None = None, # noqa: ARG001
- values: dict[str, ConfigValueTypes] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueType] | None = None, # noqa: ARG001
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from music_assistant.models.metadata_provider import MetadataProvider
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigValueTypes, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueType, ProviderConfig
from music_assistant_models.provider import ProviderManifest
from music_assistant.mass import MusicAssistant
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from enum import StrEnum
from typing import TYPE_CHECKING, ParamSpec, TypeVar, cast
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
from music_assistant_models.enums import (
AlbumType,
CacheCategory,
mass: MusicAssistant,
instance_id: str | None = None, # noqa: ARG001
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from typing import TYPE_CHECKING
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueTypes] | None = None,
+ values: dict[str, ConfigValueType] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
import yt_dlp
from duration_parser import parse as parse_str_duration
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
from music_assistant_models.enums import (
AlbumType,
ConfigEntryType,
mass: MusicAssistant, # noqa: ARG001
instance_id: str | None = None, # noqa: ARG001
action: str | None = None, # noqa: ARG001
- values: dict[str, ConfigValueTypes] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueType] | None = None, # noqa: ARG001
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
"mashumaro==3.15",
"memory-tempfile==2.2.3",
"music-assistant-frontend==2.11.5",
- "music-assistant-models==1.1.28",
+ "music-assistant-models==1.1.29",
"mutagen==1.47.0",
"orjson==3.10.12",
"pillow==11.1.0",
mashumaro==3.15
memory-tempfile==2.2.3
music-assistant-frontend==2.11.5
-music-assistant-models==1.1.28
+music-assistant-models==1.1.29
mutagen==1.47.0
orjson==3.10.12
pillow==11.1.0
projects / music-assistant-server.git / commitdiff