Add niconico video Provider

.github/workflows/nicovideo-fixtures-update-and-test.yml

@@ -0,0 +1,119 @@
+name: nicovideo Provider Fixtures Update and Test
+description: "To use it, you need to set the GitHub secret variable NICONICO_SESSION to the test account session."
+
+on:
+  # Daily execution
+  # Requires GitHub repository variable ENABLE_NICOVIDEO_SCHEDULABLE_FIXTURE_UPDATES to enable scheduled fixture updates
+  schedule:
+    - cron:  '00 0 * * *'
+
+  # Manual execution
+  workflow_dispatch:
+    inputs:
+      provider:
+        description: 'Provider to update fixtures for'
+        required: true
+        default: 'nicovideo'
+        type: choice
+        options:
+          - nicovideo
+
+      run_tests:
+        description: 'Run tests after updating fixtures'
+        required: true
+        default: true
+        type: boolean
+
+env:
+  PYTHON_VERSION: "3.12"
+
+jobs:
+  setup-and-update-fixtures:
+    name: Update NicoVideo Fixtures and Run Tests
+    runs-on: ubuntu-latest
+    if: (vars.ENABLE_NICOVIDEO_SCHEDULABLE_FIXTURE_UPDATES == 'true' && github.event_name == 'schedule') || (github.event.inputs.provider == 'nicovideo' || github.event_name == 'push')
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ env.PYTHON_VERSION }}
+        uses: actions/[email protected]
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+
+      - name: Cache Python dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/pip
+          key: ${{ runner.os }}-python-${{ env.PYTHON_VERSION }}-${{ hashFiles('**/pyproject.toml', '**/requirements*.txt') }}
+          restore-keys: |
+            ${{ runner.os }}-python-${{ env.PYTHON_VERSION }}-
+            ${{ runner.os }}-python-
+
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y ffmpeg
+
+      - name: Install Python dependencies
+        run: |
+          python -m pip install --upgrade pip build setuptools
+          pip install .[server] .[test] -r requirements_all.txt
+
+      - name: Verify environment setup
+        run: |
+          python --version
+          pip --version
+          echo "Environment setup completed successfully"
+
+      - name: Update NicoVideo fixtures
+        env:
+          NICONICO_SESSION: ${{ secrets.NICONICO_SESSION }}
+        run: |
+          cd tests/providers/nicovideo/fixtures/scripts
+          set -o pipefail
+          python main.py 2>&1 | tee fixture-update.log
+
+      - name: Check for fixture changes
+        id: check_changes
+        run: |
+          if git diff --quiet; then
+            echo "changes=false" >> $GITHUB_OUTPUT
+            echo "No fixture changes detected"
+          else
+            echo "changes=true" >> $GITHUB_OUTPUT
+            echo "Fixture changes detected"
+            git diff --name-only
+          fi
+
+      - name: Run NicoVideo Tests
+        if: steps.check_changes.outputs.changes == 'true' && (github.event.inputs.run_tests == 'true' || github.event_name == 'schedule' || github.event_name == 'push')
+        run: |
+          pytest --durations 10 \
+                 --cov-report term-missing \
+                 --cov=music_assistant.providers.nicovideo \
+                 --cov-report=xml \
+                 tests/providers/nicovideo/ \
+                 -v \
+                 --tb=short
+
+      - name: Upload fixture artifacts
+        if: failure() || steps.check_changes.outputs.changes == 'true'
+        uses: actions/upload-artifact@v4
+        with:
+          name: updated-nicovideo-fixtures
+          path: tests/providers/nicovideo/fixtures/scripts/fixture-update.log
+          retention-days: 30
+
+      - name: Upload test results
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-results
+          path: pytest-results.xml
+          retention-days: 30
+
+    outputs:
+      fixtures-updated: ${{ steps.check_changes.outputs.changes }}

.vscode/launch.json

@@ -21,6 +21,14 @@
       "justMyCode": false,
       "args": ["tests"]
     },
+    {
+      "name": "Music Assistant: Snapshot Update",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "pytest",
+      "justMyCode": false,
+      "args": ["tests","--snapshot-update"]
+    },
     {
       "name": "Python Debugger: Current File",
       "type": "debugpy",

music_assistant/providers/nicovideo/__init__.py

@@ -0,0 +1,59 @@
+"""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 = {
+    # Track mixin
+    ProviderFeature.LIBRARY_TRACKS,
+    ProviderFeature.LIBRARY_TRACKS_EDIT,
+    # Artist mixin
+    ProviderFeature.ARTIST_TOPTRACKS,
+    ProviderFeature.ARTIST_ALBUMS,
+    ProviderFeature.LIBRARY_ARTISTS,
+    ProviderFeature.LIBRARY_ARTISTS_EDIT,
+    # Album mixin
+    ProviderFeature.LIBRARY_ALBUMS,
+    # 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)