Add niconico video Provider

music_assistant/providers/nicovideo/__init__.py

@@ -0,0 +1,53 @@
+"""nicovideo support for Music Assistant."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from music_assistant_models.enums import ProviderFeature
+
+from music_assistant.mass import MusicAssistant
+from music_assistant.models import ProviderInstanceType
+from music_assistant.providers.nicovideo.config import get_config_entries_impl
+from music_assistant.providers.nicovideo.provider import NicovideoMusicProvider
+
+if TYPE_CHECKING:
+    from music_assistant_models.config_entries import (
+        ConfigEntry,
+        ConfigValueType,
+        ProviderConfig,
+    )
+    from music_assistant_models.provider import ProviderManifest
+
+# Supported features collected from all mixins
+SUPPORTED_FEATURES = {
+    # Artist mixin
+    ProviderFeature.ARTIST_TOPTRACKS,
+    ProviderFeature.ARTIST_ALBUMS,
+    ProviderFeature.LIBRARY_ARTISTS,
+    # Playlist mixin
+    ProviderFeature.LIBRARY_PLAYLISTS,
+    ProviderFeature.PLAYLIST_TRACKS_EDIT,
+    ProviderFeature.PLAYLIST_CREATE,
+    # Explorer mixin
+    ProviderFeature.SEARCH,
+    ProviderFeature.RECOMMENDATIONS,
+    ProviderFeature.SIMILAR_TRACKS,
+}
+
+
+async def setup(
+    mass: MusicAssistant, manifest: ProviderManifest, config: ProviderConfig
+) -> ProviderInstanceType:
+    """Initialize provider(instance) with given configuration."""
+    return NicovideoMusicProvider(mass, manifest, config, SUPPORTED_FEATURES)
+
+
+async def get_config_entries(
+    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
+) -> tuple[ConfigEntry, ...]:
+    """Return Config entries to setup this provider."""
+    return await get_config_entries_impl()

music_assistant/providers/nicovideo/config/__init__.py

@@ -0,0 +1,25 @@
+"""Nicovideo provider configuration system."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .categories import AuthConfigCategory
+from .factory import get_config_entries_impl
+
+if TYPE_CHECKING:
+    from music_assistant.models.provider import Provider
+
+
+class NicovideoConfig:
+    """Configuration system for Nicovideo provider."""
+
+    def __init__(self, provider: Provider) -> None:
+        """Initialize with all category instances."""
+        self.auth = AuthConfigCategory(provider)
+
+
+__all__ = [
+    "NicovideoConfig",
+    "get_config_entries_impl",
+]

music_assistant/providers/nicovideo/config/categories/__init__.py

@@ -0,0 +1,9 @@
+"""Configuration categories for Nicovideo provider."""
+
+from .auth import AuthConfigCategory
+from .base import ConfigCategoryBase
+
+__all__ = [
+    "AuthConfigCategory",
+    "ConfigCategoryBase",
+]

music_assistant/providers/nicovideo/config/categories/auth.py

@@ -0,0 +1,59 @@
+"""Authentication configuration category for Nicovideo provider."""
+
+from __future__ import annotations
+
+from music_assistant.providers.nicovideo.config.categories.base import ConfigCategoryBase
+from music_assistant.providers.nicovideo.config.factory import ConfigFactory
+
+
+class AuthConfigCategory(ConfigCategoryBase):
+    """Authentication settings category."""
+
+    _auth = ConfigFactory("Authentication")
+
+    mail = _auth.str_config(
+        key="mail",
+        label="Email",
+        default=None,
+        description="Your NicoNico account email address.",
+    )
+
+    password = _auth.secure_str_or_none_config(
+        key="password",
+        label="Password",
+        description="Your NicoNico account password.",
+    )
+
+    mfa = _auth.str_config(
+        key="mfa",
+        label="MFA Code (One-Time Password)",
+        default=None,
+        description="Enter the 6-digit confirmation code from your 2-step verification app.",
+    )
+
+    user_session = _auth.secure_str_or_none_config(
+        key="user_session",
+        label="User Session ( 'user_session' in Cookie)",
+        description=(
+            "Enter the user_session cookie value.\n"
+            "If invalid, it will be automatically set from your email and password."
+        ),
+    )
+
+    def save_user_session(self, value: str) -> None:
+        """Save user session to config."""
+        self.writer.set_raw_provider_config_value(
+            self.provider.instance_id,
+            "user_session",
+            value,
+            True,
+        )
+
+    def clear_mfa_code(self) -> None:
+        """Clear MFA code after successful use (one-time password should not be reused)."""
+        self.writer.set_raw_provider_config_value(
+            self.provider.instance_id,
+            "mfa",
+            None,
+            True,
+        )

music_assistant/providers/nicovideo/config/categories/base.py

@@ -0,0 +1,36 @@
+"""Base class for configuration categories."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, override
+
+from music_assistant.controllers.config import ConfigController
+from music_assistant.providers.nicovideo.config.descriptor import ConfigReader
+
+if TYPE_CHECKING:
+    from music_assistant_models.config_entries import ConfigValueType, ProviderConfig
+
+    from music_assistant.models.provider import Provider
+
+
+class ConfigCategoryBase(ConfigReader):
+    """Base class for config categories."""
+
+    def __init__(self, provider: Provider) -> None:
+        """Initialize category with provider instance."""
+        self.provider = provider
+
+    @property
+    def reader(self) -> ProviderConfig:
+        """Get the config reader interface."""
+        return self.provider.config
+
+    @property
+    def writer(self) -> ConfigController:
+        """Get the config writer interface."""
+        return self.provider.mass.config
+
+    @override
+    def get_value(self, key: str) -> ConfigValueType:
+        """Get config value from provider."""
+        return self.reader.get_value(key)

music_assistant/providers/nicovideo/config/descriptor.py

@@ -0,0 +1,45 @@
+"""Configuration descriptor implementation for Nicovideo provider."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    from music_assistant_models.config_entries import ConfigEntry, ConfigValueType
+
+
+class ConfigReader(Protocol):
+    """Protocol for configuration readers."""
+
+    def get_value(self, key: str) -> ConfigValueType:
+        """Retrieve a configuration value by key."""
+        ...
+
+
+class ConfigDescriptor[T]:
+    """Typed config descriptor with embedded ConfigEntry."""
+
+    def __init__(
+        self,
+        cast: Callable[[ConfigValueType], T],
+        config_entry: ConfigEntry,
+    ) -> None:
+        """Initialize descriptor.
+
+        Args:
+            cast: Transformation/validation applied to raw value.
+            config_entry: ConfigEntry definition for this option.
+        """
+        self.cast = cast
+        self.config_entry = config_entry
+
+    @property
+    def key(self) -> str:
+        """Get the config key from the embedded ConfigEntry."""
+        return self.config_entry.key
+
+    def __get__(self, instance: ConfigReader, owner: type) -> T:
+        """Descriptor access."""
+        raw = instance.get_value(self.key)
+        return self.cast(raw)