import pathlib
from typing import Final
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption
+from music_assistant_models.config_entries import (
+ ConfigEntry,
+ ConfigValueOption,
+ MultiValueConfigEntry,
+)
from music_assistant_models.enums import ConfigEntryType, ContentType
from music_assistant_models.media_items import AudioFormat
key=CONF_LOG_LEVEL,
type=ConfigEntryType.STRING,
label="Log level",
- options=(
+ options=[
ConfigValueOption("global", "GLOBAL"),
ConfigValueOption("info", "INFO"),
ConfigValueOption("warning", "WARNING"),
ConfigValueOption("error", "ERROR"),
ConfigValueOption("debug", "DEBUG"),
ConfigValueOption("verbose", "VERBOSE"),
- ),
+ ],
default_value="GLOBAL",
category="advanced",
)
CONF_ENTRY_OUTPUT_CHANNELS = ConfigEntry(
key=CONF_OUTPUT_CHANNELS,
type=ConfigEntryType.STRING,
- options=(
+ options=[
ConfigValueOption("Stereo (both channels)", "stereo"),
ConfigValueOption("Left channel", "left"),
ConfigValueOption("Right channel", "right"),
ConfigValueOption("Mono (both channels)", "mono"),
- ),
+ ],
default_value="stereo",
label="Output Channel Mode",
category="audio",
CONF_ENTRY_ANNOUNCE_VOLUME_STRATEGY = ConfigEntry(
key=CONF_ANNOUNCE_VOLUME_STRATEGY,
type=ConfigEntryType.STRING,
- options=(
+ options=[
ConfigValueOption("Absolute volume", "absolute"),
ConfigValueOption("Relative volume increase", "relative"),
ConfigValueOption("Volume increase by fixed percentage", "percentual"),
ConfigValueOption("Do not adjust volume", "none"),
- ),
+ ],
default_value="percentual",
label="Volume strategy for Announcements",
category="announcements",
{**CONF_ENTRY_PLAYER_ICON.to_dict(), "default_value": "mdi-speaker-multiple"}
)
-CONF_ENTRY_SAMPLE_RATES = ConfigEntry(
+CONF_ENTRY_SAMPLE_RATES = MultiValueConfigEntry(
key=CONF_SAMPLE_RATES,
type=ConfigEntryType.INTEGER_TUPLE,
- options=(
+ options=[
ConfigValueOption("44.1kHz / 16 bits", (44100, 16)),
ConfigValueOption("44.1kHz / 24 bits", (44100, 24)),
ConfigValueOption("48kHz / 16 bits", (48000, 16)),
ConfigValueOption("352.8kHz / 24 bits", (352800, 24)),
ConfigValueOption("384kHz / 16 bits", (384000, 16)),
ConfigValueOption("384kHz / 24 bits", (384000, 24)),
- ),
+ ],
default_value=[(44100, 16), (48000, 16)],
required=True,
- multi_value=True,
label="Sample rates supported by this player",
category="advanced",
description="The sample rates (and bit depths) supported by this player.\n"
CONF_ENTRY_HTTP_PROFILE = ConfigEntry(
key=CONF_HTTP_PROFILE,
type=ConfigEntryType.STRING,
- options=(
+ options=[
ConfigValueOption("Profile 1 - chunked", "chunked"),
ConfigValueOption("Profile 2 - no content length", "no_content_length"),
ConfigValueOption("Profile 3 - forced content length", "forced_content_length"),
- ),
+ ],
default_value="no_content_length",
label="HTTP Profile used for sending audio",
category="advanced",
CONF_ENTRY_ENABLE_ICY_METADATA = ConfigEntry(
key=CONF_ENABLE_ICY_METADATA,
type=ConfigEntryType.STRING,
- options=(
+ options=[
ConfigValueOption("Disabled - do not send ICY metadata", "disabled"),
ConfigValueOption("Profile 1 - basic info", "basic"),
ConfigValueOption("Profile 2 - full info (including image)", "full"),
- ),
+ ],
depends_on=CONF_FLOW_MODE,
default_value="disabled",
label="Try to ingest metadata into stream (ICY)",
safe_max_bit_depth: int = 16,
hidden: bool = False,
supported_sample_rates: list[int] | None = None,
-) -> ConfigEntry:
+) -> MultiValueConfigEntry:
"""Create sample rates config entry based on player specific helpers."""
assert CONF_ENTRY_SAMPLE_RATES.options
- conf_entry = ConfigEntry.from_dict(CONF_ENTRY_SAMPLE_RATES.to_dict())
+ conf_entry = MultiValueConfigEntry.from_dict(CONF_ENTRY_SAMPLE_RATES.to_dict())
conf_entry.hidden = hidden
options: list[ConfigValueOption] = []
default_value: list[tuple[int, int]] = []
options.append(option)
if sample_rate <= safe_max_sample_rate and bit_depth <= safe_max_bit_depth:
default_value.append(option.value)
- conf_entry.options = tuple(options)
+ 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, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
if action == CONF_CLEAR_CACHE:
async def close(self) -> None:
"""Cleanup on exit."""
- await self.database.close()
+ if self.database:
+ await self.database.close()
async def get(
self,
from music_assistant_models import config_entries
from music_assistant_models.config_entries import (
ConfigEntry,
- ConfigValueType,
+ ConfigValueTypes,
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, ConfigValueType] = {}
+ self._value_cache: dict[str, ConfigValueTypes] = {}
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) -> ConfigValueType:
+ async def get_provider_config_value(self, instance_id: str, key: str) -> ConfigValueTypes:
"""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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup/configure a provider.
async def save_provider_config(
self,
provider_domain: str,
- values: dict[str, ConfigValueType],
+ values: dict[str, ConfigValueTypes],
instance_id: str | None = None,
) -> ProviderConfig:
"""
self,
player_id: str,
key: str,
- ) -> ConfigValueType:
+ ) -> ConfigValueTypes:
"""Return single configentry value for a player."""
conf = await self.get_player_config(player_id)
return (
)
def get_raw_player_config_value(
- self, player_id: str, key: str, default: ConfigValueType = None
- ) -> ConfigValueType:
+ self, player_id: str, key: str, default: ConfigValueTypes = None
+ ) -> ConfigValueTypes:
"""
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, ConfigValueType]
+ self, player_id: str, values: dict[str, ConfigValueTypes]
) -> PlayerConfig:
"""Save/update PlayerConfig."""
config = await self.get_player_config(player_id)
provider: str,
name: str,
enabled: bool,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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) -> ConfigValueType:
+ async def get_core_config_value(self, domain: str, key: str) -> ConfigValueTypes:
"""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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to configure a core controller.
async def save_core_config(
self,
domain: str,
- values: dict[str, ConfigValueType],
+ values: dict[str, ConfigValueTypes],
) -> 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: ConfigValueType = None
- ) -> ConfigValueType:
+ self, core_module: str, key: str, default: ConfigValueTypes = None
+ ) -> ConfigValueTypes:
"""
Return (raw) single configentry value for a core controller.
)
def get_raw_provider_config_value(
- self, provider_instance: str, key: str, default: ConfigValueType = None
- ) -> ConfigValueType:
+ self, provider_instance: str, key: str, default: ConfigValueTypes = None
+ ) -> ConfigValueTypes:
"""
Return (raw) single config(entry) value for a provider.
self,
provider_instance: str,
key: str,
- value: ConfigValueType,
+ value: ConfigValueTypes,
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: ConfigValueType) -> None:
+ def set_raw_core_config_value(
+ self, core_module: str, key: str, value: ConfigValueTypes
+ ) -> 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: ConfigValueType) -> None:
+ def set_raw_player_config_value(
+ self, player_id: str, key: str, value: ConfigValueTypes
+ ) -> None:
"""
Set (raw) single config(entry) value for a player.
await self.mass.load_provider_config(config)
async def _update_provider_config(
- self, instance_id: str, values: dict[str, ConfigValueType]
+ self, instance_id: str, values: dict[str, ConfigValueTypes]
) -> ProviderConfig:
"""Update ProviderConfig."""
config = await self.get_provider_config(instance_id)
async def _add_provider_config(
self,
provider_domain: str,
- values: dict[str, ConfigValueType],
+ values: dict[str, ConfigValueTypes],
) -> list[ConfigEntry] | ProviderConfig:
"""
Add new Provider (instance).
import aiofiles
from aiohttp import web
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueTypes
from music_assistant_models.enums import (
AlbumType,
ConfigEntryType,
async def get_config_entries(
self,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
return (
description="Preferred language for metadata.\n\n"
"Note that English will always be used as fallback when content "
"in your preferred language is not available.",
- options=tuple(ConfigValueOption(value, key) for key, value in LOCALES.items()),
+ options=[ConfigValueOption(value, key) for key, value in LOCALES.items()],
),
ConfigEntry(
key=CONF_ENABLE_ONLINE_METADATA,
from math import inf
from typing import TYPE_CHECKING, Final, cast
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
from music_assistant_models.enums import (
CacheCategory,
ConfigEntryType,
async def get_config_entries(
self,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
entries = (
from types import NoneType
from typing import TYPE_CHECKING, Any, TypedDict, cast
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueTypes
from music_assistant_models.enums import (
CacheCategory,
ConfigEntryType,
async def get_config_entries(
self,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
- enqueue_options = tuple(ConfigValueOption(x.name, x.value) for x in QueueOption)
+ enqueue_options = [ConfigValueOption(x.name, x.value) for x in QueueOption]
return (
ConfigEntry(
key=CONF_DEFAULT_ENQUEUE_SELECT_ARTIST,
type=ConfigEntryType.STRING,
default_value=ENQUEUE_SELECT_ARTIST_DEFAULT_VALUE,
label="Items to select when you play a (in-library) artist.",
- options=(
+ options=[
ConfigValueOption(
title="Only in-library tracks",
value="library_tracks",
title="All tracks from all albums from (all) streaming provider(s)",
value="all_album_tracks",
),
- ),
+ ],
),
ConfigEntry(
key=CONF_DEFAULT_ENQUEUE_SELECT_ALBUM,
type=ConfigEntryType.STRING,
default_value=ENQUEUE_SELECT_ALBUM_DEFAULT_VALUE,
label="Items to select when you play a (in-library) album.",
- options=(
+ options=[
ConfigValueOption(
title="Only in-library tracks",
value="library_tracks",
title="All tracks for album on (streaming) provider",
value="all_tracks",
),
- ),
+ ],
),
ConfigEntry(
key=CONF_DEFAULT_ENQUEUE_OPTION_ARTIST,
from aiofiles.os import wrap
from aiohttp import web
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueTypes
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
async def get_config_entries(
self,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
default_ip = await get_ip()
type=ConfigEntryType.STRING,
default_value=VolumeNormalizationMode.FALLBACK_DYNAMIC,
label="Volume normalization method for radio streams",
- options=(
+ options=[
ConfigValueOption(x.value.replace("_", " ").title(), x.value)
for x in VolumeNormalizationMode
- ),
+ ],
category="audio",
),
ConfigEntry(
type=ConfigEntryType.STRING,
default_value=VolumeNormalizationMode.FALLBACK_DYNAMIC,
label="Volume normalization method for tracks",
- options=(
+ options=[
ConfigValueOption(x.value.replace("_", " ").title(), x.value)
for x in VolumeNormalizationMode
- ),
+ ],
category="audio",
),
ConfigEntry(
key=CONF_BIND_IP,
type=ConfigEntryType.STRING,
default_value="0.0.0.0",
- options=(ConfigValueOption(x, x) for x in {"0.0.0.0", *all_ips}),
+ options=[ConfigValueOption(x, x) for x in {"0.0.0.0", *all_ips}],
label="Bind to IP/interface",
description="Start the stream server on this specific interface. \n"
"Use 0.0.0.0 to bind to all interfaces, which is the default. \n"
if TYPE_CHECKING:
from collections.abc import Awaitable
- from music_assistant_models.config_entries import ConfigValueType, CoreConfig
+ from music_assistant_models.config_entries import ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
default_publish_ip = await get_ip()
key=CONF_BIND_IP,
type=ConfigEntryType.STRING,
default_value="0.0.0.0",
- options=(ConfigValueOption(x, x) for x in {"0.0.0.0", *all_ips}),
+ options=[ConfigValueOption(x, x) for x in {"0.0.0.0", *all_ips}],
label="Bind to IP/interface",
description="Start the (web)server on this specific interface. \n"
"Use 0.0.0.0 to bind to all interfaces. \n"
from .plugin import PluginProvider
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType, CoreConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, CoreConfig
from music_assistant import MusicAssistant
async def get_config_entries(
self,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""Return all Config Entries for this core module (if any)."""
return ()
label="Power Control",
default_value=PLAYER_CONTROL_NATIVE if supports_power else PLAYER_CONTROL_NONE,
required=True,
- options=(
+ options=[
*base_power_options,
*(ConfigValueOption(x.name, x.id) for x in power_controls),
- ),
+ ],
category="player_controls",
),
# Volume control config entry
label="Volume Control",
default_value=PLAYER_CONTROL_NATIVE if supports_volume else PLAYER_CONTROL_NONE,
required=True,
- options=(
+ options=[
*base_volume_options,
*(ConfigValueOption(x.name, x.id) for x in volume_controls),
- ),
+ ],
category="player_controls",
),
# Mute control config entry
label="Mute Control",
default_value=PLAYER_CONTROL_NATIVE if supports_mute else PLAYER_CONTROL_NONE,
required=True,
- options=(
+ options=[
*base_mute_options,
- *(ConfigValueOption(x.name, x.id) for x in mute_controls),
- ),
+ *[ConfigValueOption(x.name, x.id) for x in mute_controls],
+ ],
category="player_controls",
),
)
from music_assistant.models.music_provider import MusicProvider
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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 ConfigValueType for more information what is supported.
+ # See the models of ConfigEntry and ConfigValueTypes for more information what is supported.
# The ConfigEntry is a dataclass that represents a single configuration entry.
- # The ConfigValueType is an Enum that represents the type of value that
+ # The ConfigValueTypes 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,
- ConfigValueType,
+ ConfigValueTypes,
PlayerConfig,
ProviderConfig,
)
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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 ConfigValueType for more information what is supported.
+ # See the models of ConfigEntry and ConfigValueTypes for more information what is supported.
# The ConfigEntry is a dataclass that represents a single configuration entry.
- # The ConfigValueType is an Enum that represents the type of value that
+ # The ConfigValueTypes 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, ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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 ConfigValueType for more information what is supported.
+ # See the models of ConfigEntry and ConfigValueTypes for more information what is supported.
# The ConfigEntry is a dataclass that represents a single configuration entry.
- # The ConfigValueType is an Enum that represents the type of value that
+ # The ConfigValueTypes 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 __future__ import annotations
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
ConfigEntry(
key=CONF_BIND_INTERFACE,
type=ConfigEntryType.STRING,
- default_value=mass.streams.publish_ip,
+ default_value=cast(str, mass.streams.publish_ip),
label="Bind interface",
description="Interface to bind to for Airplay streaming.",
category="advanced",
from typing import TYPE_CHECKING, Any
import aiofiles
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
from music_assistant_models.enums import (
AlbumType,
ConfigEntryType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from music_assistant_models.config_entries import (
ConfigEntry,
ConfigValueOption,
- ConfigValueType,
+ ConfigValueTypes,
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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
hidden=not auth_required,
required=True,
value=locale,
- options=(
+ options=[
ConfigValueOption("US and all other countries not listed", "us"),
ConfigValueOption("Canada", "ca"),
ConfigValueOption("UK and Ireland", "uk"),
ConfigValueOption("India", "in"),
ConfigValueOption("Spain", "es"),
ConfigValueOption("Brazil", "br"),
- ),
+ ],
default_value="us",
),
ConfigEntry(
type=ConfigEntryType.STRING,
label="Post Login Url",
required=False,
- value=values.get(CONF_POST_LOGIN_URL),
+ value=cast(str | None, values.get(CONF_POST_LOGIN_URL)),
hidden=not auth_required,
),
ConfigEntry(
label="Code Verifier",
hidden=True,
required=False,
- value=values.get(CONF_CODE_VERIFIER),
+ value=cast(str | None, values.get(CONF_CODE_VERIFIER)),
),
ConfigEntry(
key=CONF_SERIAL,
label="Serial",
hidden=True,
required=False,
- value=values.get(CONF_SERIAL),
+ value=cast(str | None, values.get(CONF_SERIAL)),
),
ConfigEntry(
key=CONF_LOGIN_URL,
label="Login Url",
hidden=True,
required=False,
- value=values.get(CONF_LOGIN_URL),
+ value=cast(str | None, values.get(CONF_LOGIN_URL)),
),
ConfigEntry(
key=CONF_AUTH_FILE,
label="Authentication File",
hidden=True,
required=True,
- value=values.get(CONF_AUTH_FILE),
+ value=cast(str | None, values.get(CONF_AUTH_FILE)),
),
)
)
from aioaudiobookshelf.schema.library import LibraryMediaType as AbsLibraryMediaType
from mashumaro.mixins.dict import DataClassDictMixin
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, ProviderConfig
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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 ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueTypes, 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, ConfigValueType] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueTypes] | 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 ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType, ProviderConfig
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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 ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
)
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
default_value="various_artists",
help_link="https://music-assistant.io/music-providers/filesystem/#tagging-files",
required=False,
- options=(
+ options=[
ConfigValueOption("Use Track artist(s)", "track_artist"),
ConfigValueOption("Use Various Artists", "various_artists"),
ConfigValueOption("Use Folder name (if possible)", "folder_name"),
- ),
+ ],
depends_on=CONF_CONTENT_TYPE,
depends_on_value="music",
)
default_value="music",
description="The type of content to expect in the media folder(s)",
required=False,
- options=(
+ options=[
ConfigValueOption("Music", "music"),
ConfigValueOption("Audiobooks", "audiobooks"),
ConfigValueOption("Podcasts", "podcasts"),
- ),
+ ],
)
CONF_ENTRY_CONTENT_TYPE_READ_ONLY = ConfigEntry.from_dict(
{
import platform
from typing import TYPE_CHECKING
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType
+from music_assistant_models.config_entries import (
+ ConfigEntry,
+ ConfigValueOption,
+ ConfigValueTypes,
+ MultiValueConfigEntry,
+)
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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
label="URL",
required=True,
description="URL to your Home Assistant instance (e.g. http://192.168.1.1:8123)",
- value=values.get(CONF_URL) if values else None,
+ value=cast(str, values.get(CONF_URL)) if values else None,
),
ConfigEntry(
key=CONF_ACTION_AUTH,
description="You can either paste a Long Lived Token here manually or use the "
"'authenticate' button to generate a token for you with logging in.",
depends_on=CONF_URL,
- value=values.get(CONF_AUTH_TOKEN) if values else None,
+ value=cast(str, values.get(CONF_AUTH_TOKEN)) if values else None,
category="advanced",
),
ConfigEntry(
return (
*base_entries,
- ConfigEntry(
+ MultiValueConfigEntry(
key=CONF_POWER_CONTROLS,
type=ConfigEntryType.STRING,
label=CONF_POWER_CONTROLS,
default_value=[],
- multi_value=True,
),
- ConfigEntry(
+ MultiValueConfigEntry(
key=CONF_VOLUME_CONTROLS,
type=ConfigEntryType.STRING,
label=CONF_VOLUME_CONTROLS,
default_value=[],
- multi_value=True,
),
- ConfigEntry(
+ MultiValueConfigEntry(
key=CONF_MUTE_CONTROLS,
type=ConfigEntryType.STRING,
label=CONF_MUTE_CONTROLS,
default_value=[],
- multi_value=True,
),
)
all_mute_entities.sort(key=lambda x: x.title)
all_volume_entities.sort(key=lambda x: x.title)
return (
- ConfigEntry(
+ MultiValueConfigEntry(
key=CONF_POWER_CONTROLS,
type=ConfigEntryType.STRING,
label="Player Power Control entities",
required=True,
- options=tuple(all_power_entities),
- multi_value=True,
+ options=all_power_entities,
default_value=[],
description="Specify which Home Assistant entities you "
"like to import as player Power controls in Music Assistant.",
category="player_controls",
),
- ConfigEntry(
+ MultiValueConfigEntry(
key=CONF_VOLUME_CONTROLS,
type=ConfigEntryType.STRING,
label="Player Volume Control entities",
required=True,
- options=tuple(all_volume_entities),
- multi_value=True,
+ options=all_volume_entities,
default_value=[],
description="Specify which Home Assistant entities you "
"like to import as player Volume controls in Music Assistant.",
category="player_controls",
),
- ConfigEntry(
+ MultiValueConfigEntry(
key=CONF_MUTE_CONTROLS,
type=ConfigEntryType.STRING,
label="Player Mute Control entities",
required=True,
- options=tuple(all_mute_entities),
- multi_value=True,
+ options=all_mute_entities,
default_value=[],
description="Specify which Home Assistant entities you "
"like to import as player Mute controls in Music Assistant.",
from typing import TYPE_CHECKING, Any
from hass_client.exceptions import FailedCommand
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
+from music_assistant_models.config_entries import (
+ ConfigEntry,
+ ConfigValueOption,
+ ConfigValueTypes,
+ MultiValueConfigEntry,
+)
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, ConfigValueType] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueTypes] | 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 (
- ConfigEntry(
+ MultiValueConfigEntry(
key=CONF_PLAYERS,
type=ConfigEntryType.STRING,
label="Player entities",
required=True,
- options=tuple(player_entities),
- multi_value=True,
+ options=player_entities,
description="Specify which HA media_player entity id's you "
"like to import as players in Music Assistant.",
),
from aiohttp import ClientSession
from ibroadcastaio import IBroadcastClient
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
from music_assistant_models.enums import (
AlbumType,
ConfigEntryType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType, ProviderConfig
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from typing import TYPE_CHECKING
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueType, ProviderConfig
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes, 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, ConfigValueType] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueTypes] | None = None, # noqa: ARG001
) -> tuple[ConfigEntry, ...]:
"""Return Config entries to setup this provider."""
return (
from music_assistant_models.config_entries import (
ConfigEntry,
ConfigValueOption,
- ConfigValueType,
+ ConfigValueTypes,
+ MultiValueConfigEntry,
PlayerConfig,
)
from music_assistant_models.constants import PLAYER_CONTROL_NATIVE, PLAYER_CONTROL_NONE
hidden=True,
required=True,
)
-CONF_ENTRY_GROUP_MEMBERS = ConfigEntry(
+CONF_ENTRY_GROUP_MEMBERS = MultiValueConfigEntry(
key=CONF_GROUP_MEMBERS,
type=ConfigEntryType.STRING,
label="Group members",
default_value=[],
description="Select all players you want to be part of this group",
- multi_value=True,
required=False, # otherwise dynamic members won't work (which allows empty members list)
)
CONF_ENTRY_SAMPLE_RATES_UGP = create_sample_rates_config_entry(44100, 16, 44100, 16, True)
mass: MusicAssistant, # noqa: ARG001
instance_id: str | None = None, # noqa: ARG001
action: str | None = None, # noqa: ARG001
- values: dict[str, ConfigValueType] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueTypes] | None = None, # noqa: ARG001
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
from music_assistant_models.config_entries import (
ConfigEntry,
ConfigValueOption,
- ConfigValueType,
+ ConfigValueTypes,
ProviderConfig,
)
from music_assistant_models.enums import (
mass: MusicAssistant,
instance_id: str | None = None, # noqa: ARG001
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
label="Local server IP",
description="The local server IP (e.g. 192.168.1.77)",
required=True,
- value=values.get(CONF_LOCAL_SERVER_IP) if values else None,
+ value=cast(str, values.get(CONF_LOCAL_SERVER_IP)) if values else None,
),
ConfigEntry(
key=CONF_LOCAL_SERVER_PORT,
description="The local server port (e.g. 32400)",
required=True,
default_value=32400,
- value=values.get(CONF_LOCAL_SERVER_PORT) if values else None,
+ value=cast(int, values.get(CONF_LOCAL_SERVER_PORT)) if values else None,
),
ConfigEntry(
key=CONF_LOCAL_SERVER_SSL,
type=ConfigEntryType.SECURE_STRING,
label=CONF_AUTH_TOKEN,
action=CONF_AUTH_TOKEN,
- value=values.get(CONF_AUTH_TOKEN) if values else None,
+ value=cast(str | None, values.get(CONF_AUTH_TOKEN)) if values else None,
hidden=True,
),
]
):
msg = "Unable to retrieve Servers and/or Music Libraries"
raise LoginFailed(msg)
- conf_libraries.options = tuple(
+ conf_libraries.options = [
# use the same value for both the value and the title
# until we find out what plex uses as stable identifiers
ConfigValueOption(
value=x,
)
for x in libraries
- )
+ ]
# select first library as (default) value
conf_libraries.default_value = libraries[0]
conf_libraries.value = libraries[0]
from typing import TYPE_CHECKING
import podcastparser
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
ConfigEntry(
key=CONF_FEED_URL,
type=ConfigEntryType.STRING,
- default_value=[],
label="RSS Feed URL",
required=True,
),
from typing import TYPE_CHECKING
from aiohttp import client_exceptions
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
from music_assistant_models.enums import (
AlbumType,
ConfigEntryType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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
+from music_assistant_models.config_entries import ConfigEntry, MultiValueConfigEntry
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
}
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
"""
# ruff: noqa: ARG001 D205
return (
- ConfigEntry(
+ MultiValueConfigEntry(
# 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.
label=CONF_STORED_RADIOS,
default_value=[],
required=False,
- multi_value=True,
hidden=True,
),
)
from collections.abc import AsyncGenerator, Awaitable, Sequence
from typing import TYPE_CHECKING, Any, cast
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueTypes
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
key=CONF_SXM_REGION,
type=ConfigEntryType.STRING,
default_value="US",
- options=(
+ options=[
ConfigValueOption(title="United States", value="US"),
ConfigValueOption(title="Canada", value="CA"),
- ),
+ ],
label="Region",
required=True,
),
from music_assistant_models.config_entries import (
ConfigEntry,
ConfigValueOption,
- ConfigValueType,
+ ConfigValueTypes,
PlayerConfig,
)
from music_assistant_models.enums import (
key=CONF_VISUALIZATION,
type=ConfigEntryType.STRING,
default_value=DEFAULT_VISUALIZATION,
- options=tuple(
+ options=[
ConfigValueOption(title=x.name.replace("_", " ").title(), value=x.value)
for x in SlimVisualisationType
- ),
+ ],
required=False,
label="Visualization type",
description="The type of visualization to show on the display "
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueTypes
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, ConfigValueType] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueTypes] | None = None, # noqa: ARG001
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
ConfigEntry(
key=CONF_SERVER_TRANSPORT_CODEC,
type=ConfigEntryType.STRING,
- options=(
+ options=[
ConfigValueOption(
title="FLAC",
value="flac",
title="PCM",
value="pcm",
),
- ),
+ ],
default_value="flac",
label="Snapserver default transport codec",
required=False,
from .provider import CONF_IPS, SonosPlayerProvider
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
from music_assistant_models.enums import (
ConfigEntryType,
PlayerFeature,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
from music_assistant_models.enums import (
AlbumType,
ConfigEntryType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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 ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueTypes, 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, ConfigValueType] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueTypes] | None = None, # noqa: ARG001
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
label="Connected Music Assistant Player",
description="Select the player for which you want to enable Spotify Connect.",
multi_value=False,
- options=tuple(
+ options=[
ConfigValueOption(x.display_name, x.player_id)
for x in mass.players.all(False, False)
- ),
+ ],
required=True,
),
# ConfigEntry(
from music_assistant.models.music_provider import MusicProvider
if TYPE_CHECKING:
- from music_assistant_models.config_entries import ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueTypes, 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, ConfigValueType] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueTypes] | 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 ConfigValueType, ProviderConfig
+ from music_assistant_models.config_entries import ConfigValueTypes, 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, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueTypes
from music_assistant_models.enums import (
AlbumType,
CacheCategory,
mass: MusicAssistant,
instance_id: str | None = None, # noqa: ARG001
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | None = None,
) -> tuple[ConfigEntry, ...]:
"""
Return Config entries to setup this provider.
label=CONF_QUALITY,
required=True,
hidden=True,
- default_value=values.get(CONF_QUALITY, TidalQualityEnum.HI_RES.value),
- value=values.get(CONF_QUALITY),
+ value=cast(str, values.get(CONF_QUALITY) or TidalQualityEnum.HI_RES.value),
+ default_value=cast(str, values.get(CONF_QUALITY) or TidalQualityEnum.HI_RES.value),
),
)
else:
label="Quality setting for Tidal:",
required=True,
description="HIGH_LOSSLESS = 16bit 44.1kHz, HI_RES = Up to 24bit 192kHz",
- options=tuple(ConfigValueOption(x.value, x.name) for x in TidalQualityEnum),
+ options=[ConfigValueOption(x.value, x.name) for x in TidalQualityEnum],
default_value=TidalQualityEnum.HI_RES.value,
- value=values.get(CONF_QUALITY) if values else None,
+ value=cast(str, values.get(CONF_QUALITY)) if values else None,
),
ConfigEntry(
key=LABEL_START_PKCE_LOGIN,
action=CONF_ACTION_START_PKCE_LOGIN,
depends_on=CONF_QUALITY,
action_label="Starts the auth process via PKCE on Tidal.com",
- value=values.get(CONF_TEMP_SESSION) if values else None,
+ value=cast(str, values.get(CONF_TEMP_SESSION)) if values else None,
hidden=action == CONF_ACTION_START_PKCE_LOGIN,
),
ConfigEntry(
label="Temporary session for Tidal",
hidden=True,
required=False,
- value=values.get(CONF_TEMP_SESSION) if values else None,
+ value=cast(str, values.get(CONF_TEMP_SESSION)) if values else None,
),
ConfigEntry(
key=LABEL_OOPS_URL,
" Tidal.com and being redirected to a page that prominently displays"
" 'Oops' at the top.",
depends_on=CONF_ACTION_START_PKCE_LOGIN,
- value=values.get(CONF_OOPS_URL) if values else None,
+ value=cast(str, values.get(CONF_OOPS_URL)) if values else None,
hidden=action != CONF_ACTION_START_PKCE_LOGIN,
),
ConfigEntry(
label="Authentication token for Tidal",
description="You need to link Music Assistant to your Tidal account.",
hidden=True,
- value=values.get(CONF_AUTH_TOKEN) if values else None,
+ value=cast(str, values.get(CONF_AUTH_TOKEN)) if values else None,
),
ConfigEntry(
key=CONF_REFRESH_TOKEN,
label="Refresh token for Tidal",
description="You need to link Music Assistant to your Tidal account.",
hidden=True,
- value=values.get(CONF_REFRESH_TOKEN) if values else None,
+ value=cast(str, values.get(CONF_REFRESH_TOKEN)) if values else None,
),
ConfigEntry(
key=CONF_EXPIRY_TIME,
type=ConfigEntryType.STRING,
label="Expiry time of auth token for Tidal",
hidden=True,
- value=values.get(CONF_EXPIRY_TIME) if values else None,
+ value=cast(str, values.get(CONF_EXPIRY_TIME)) if values else None,
),
ConfigEntry(
key=CONF_USER_ID,
label="Your Tidal User ID",
description="This is your unique Tidal user ID.",
hidden=True,
- value=values.get(CONF_USER_ID) if values else None,
+ value=cast(str, values.get(CONF_USER_ID)) if values else None,
),
)
from typing import TYPE_CHECKING
-from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
from music_assistant_models.enums import (
ConfigEntryType,
ContentType,
mass: MusicAssistant,
instance_id: str | None = None,
action: str | None = None,
- values: dict[str, ConfigValueType] | None = None,
+ values: dict[str, ConfigValueTypes] | 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, ConfigValueType
+from music_assistant_models.config_entries import ConfigEntry, ConfigValueTypes
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, ConfigValueType] | None = None, # noqa: ARG001
+ values: dict[str, ConfigValueTypes] | 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.27",
+ "music-assistant-models==1.1.28",
"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.27
+music-assistant-models==1.1.28
mutagen==1.47.0
orjson==3.10.12
pillow==11.1.0
projects / music-assistant-server.git / commitdiff