niconico.py-ma 2.1.0.post1__tar.gz

niconico_py_ma-2.1.0.post1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Negima1072
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

niconico_py_ma-2.1.0.post1/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: niconico.py-ma
+Version: 2.1.0.post1
+Summary: API wrapper for NicoNico services (Music Assistant fork)
+License: MIT
+License-File: LICENSE
+Author: Shi-553
+Author-email: 58556078+Shi-553@users.noreply.github.com
+Requires-Python: >=3.8
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: pydantic (>=2.8.2,<3.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Project-URL: Repository, https://github.com/Shi-553/niconico.py
+Description-Content-Type: text/markdown
+
+![niconico](https://img.shields.io/badge/niconico-(%E5%B8%B0%E3%81%A3%E3%81%A6%E3%81%8D%E3%81%9F)-auto?logo=niconico&logoColor=%23e6e6e6&color=%23252525)
+
+[![PyPI](https://img.shields.io/pypi/v/niconico.py-ma?logo=pypi)](https://pypi.org/project/niconico.py-ma/)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/niconico.py-ma?logo=pypi)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/niconico.py-ma?logo=pypi)
+![PyPI - License](https://img.shields.io/pypi/l/niconico.py-ma?logo=pypi)
+
+[![Test](https://github.com/Shi-553/niconico.py/actions/workflows/release.yml/badge.svg)](https://github.com/Shi-553/niconico.py/actions/workflows/release.yml)
+[![Test](https://github.com/Shi-553/niconico.py/actions/workflows/pypi.yml/badge.svg)](https://github.com/Shi-553/niconico.py/actions/workflows/pypi.yml)
+
+# <img src="https://avatars.githubusercontent.com/u/113749892" height="30" /> niconico.py-ma
+
+niconico.py-ma is a Python library for retrieving Niconico video content and information, and is compatible with the latest version of Niconico.
+This is a Music Assistant fork with additional features and improvements.
+It allows you to download videos, retrieve information, get comments, and more.
+
+## Requirement
+
+To use the video download function, you need to install [FFmpeg](https://www.ffmpeg.org/) and set the path.
+
+## Installation
+
+You can install it using pip:
+```bash
+pip install niconico.py-ma
+```
+
+## Usage
+
+```python
+from niconico import NicoNico
+client = NicoNico()
+```
+
+### Examples
+
+All examples can be found [here](https://github.com/Shi-553/niconico.py/tree/main/examples).
+
+## Original Project
+
+This is a fork of [niconico.py](https://github.com/niconicolibs/niconico.py) by Negima1072, enhanced for Music Assistant integration.
+
+## Command
+
+Console commands are available, see the following commands for usage:
+```bash
+niconico -h
+```
+
+## Contributing
+
+All contributions are welcome, but please:
+- Use the `develop` branch.
+- Follow PEP8.
+- Be clear about the meaning and purpose of your issue or PR.
+
+## License
+
+[MIT License](LICENSE)
+

niconico_py_ma-2.1.0.post1/README.md

@@ -0,0 +1,59 @@
+![niconico](https://img.shields.io/badge/niconico-(%E5%B8%B0%E3%81%A3%E3%81%A6%E3%81%8D%E3%81%9F)-auto?logo=niconico&logoColor=%23e6e6e6&color=%23252525)
+
+[![PyPI](https://img.shields.io/pypi/v/niconico.py-ma?logo=pypi)](https://pypi.org/project/niconico.py-ma/)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/niconico.py-ma?logo=pypi)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/niconico.py-ma?logo=pypi)
+![PyPI - License](https://img.shields.io/pypi/l/niconico.py-ma?logo=pypi)
+
+[![Test](https://github.com/Shi-553/niconico.py/actions/workflows/release.yml/badge.svg)](https://github.com/Shi-553/niconico.py/actions/workflows/release.yml)
+[![Test](https://github.com/Shi-553/niconico.py/actions/workflows/pypi.yml/badge.svg)](https://github.com/Shi-553/niconico.py/actions/workflows/pypi.yml)
+
+# <img src="https://avatars.githubusercontent.com/u/113749892" height="30" /> niconico.py-ma
+
+niconico.py-ma is a Python library for retrieving Niconico video content and information, and is compatible with the latest version of Niconico.
+This is a Music Assistant fork with additional features and improvements.
+It allows you to download videos, retrieve information, get comments, and more.
+
+## Requirement
+
+To use the video download function, you need to install [FFmpeg](https://www.ffmpeg.org/) and set the path.
+
+## Installation
+
+You can install it using pip:
+```bash
+pip install niconico.py-ma
+```
+
+## Usage
+
+```python
+from niconico import NicoNico
+client = NicoNico()
+```
+
+### Examples
+
+All examples can be found [here](https://github.com/Shi-553/niconico.py/tree/main/examples).
+
+## Original Project
+
+This is a fork of [niconico.py](https://github.com/niconicolibs/niconico.py) by Negima1072, enhanced for Music Assistant integration.
+
+## Command
+
+Console commands are available, see the following commands for usage:
+```bash
+niconico -h
+```
+
+## Contributing
+
+All contributions are welcome, but please:
+- Use the `develop` branch.
+- Follow PEP8.
+- Be clear about the meaning and purpose of your issue or PR.
+
+## License
+
+[MIT License](LICENSE)

niconico_py_ma-2.1.0.post1/niconico/__init__.py

@@ -0,0 +1,6 @@
+"""niconico package."""
+
+from niconico.niconico import NicoNico
+
+__all__ = ("NicoNico",)
+__version__ = "2.1.0"

niconico_py_ma-2.1.0.post1/niconico/__main__.py

@@ -0,0 +1,126 @@
+"""Main module for niconico package."""
+
+import argparse
+import logging
+from pathlib import Path
+
+from niconico import NicoNico, __version__
+from niconico.exceptions import LoginFailureError, WatchAPIError
+
+logger = logging.getLogger("niconico.py")
+
+
+def command_details(args: argparse.Namespace) -> None:
+    """Show video details."""
+    logger.debug("Starting command: details with args: %s", args)
+    client = NicoNico()
+    video = client.video.get_video(args.id)
+    if video is None:
+        logger.error("Video not found")
+        return
+    logger.debug("Video: %s", video)
+    if args.output is None:
+        logger.info(video.model_dump_json(indent=2, by_alias=True))
+    else:
+        with args.output.open("w") as f:
+            f.write(video.model_dump_json(by_alias=True))
+        logger.info("Saved to %s", args.output)
+
+
+def command_quality(args: argparse.Namespace) -> None:
+    """Show video quality."""
+    logger.debug("Starting command: quality with args: %s", args)
+    client = NicoNico()
+    if args.session is not None:
+        try:
+            client.login_with_session(args.session)
+            logger.debug("Logged in with session")
+        except LoginFailureError:
+            logger.exception("Login failed")
+        logger.debug("is_premium: %s", client.premium)
+    try:
+        watch_data = client.video.watch.get_watch_data(args.id)
+    except WatchAPIError:
+        logger.exception("An error has occurred")
+        return
+    logger.debug("Watch data: %s", watch_data)
+    outputs = client.video.watch.get_outputs(watch_data)
+    logger.info("Label\tVideo, Audio")
+    for output_key, output in outputs.items():
+        logger.info("%s:\t%s", output_key, ", ".join(output))
+
+
+def command_download(args: argparse.Namespace) -> None:
+    """Download video."""
+    logger.debug("Starting command: download with args: %s", args)
+    client = NicoNico()
+    if args.session is not None:
+        try:
+            client.login_with_session(args.session)
+            logger.debug("Logged in with session")
+        except LoginFailureError:
+            logger.exception("Login failed")
+        logger.debug("is_premium: %s", client.premium)
+    try:
+        watch_data = client.video.watch.get_watch_data(args.id)
+    except WatchAPIError:
+        logger.exception("An error has occurred")
+        return
+    logger.debug("Watch data: %s", watch_data)
+    outputs = client.video.watch.get_outputs(watch_data, audio_only=args.audio)
+    logger.debug("Outputs: %s", outputs)
+    if args.quality is not None:
+        if args.quality not in outputs:
+            logger.error("This quality is not supported")
+            return
+        quality = args.quality
+        logger.debug("Selected quality: %s", quality)
+    else:
+        quality = next(iter(outputs))
+        logger.debug("Selected quality: %s(best)", quality)
+    logger.debug("Downloading video...")
+    downloaded_path = client.video.watch.download_video(watch_data, quality, args.output, audio_only=args.audio)
+    logger.info("Downloaded to %s", downloaded_path)
+
+
+def main() -> None:
+    """Main function for niconico package."""
+    parser = argparse.ArgumentParser(
+        description="download video from niconico",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument("--debug", help="enable debug logging", action="store_true")
+
+    subparsers = parser.add_subparsers(title="commands")
+
+    parser_details = subparsers.add_parser("details", help="show video details")
+    parser_details.add_argument("id", help="video id", type=str)
+    parser_details.add_argument("-o", "--output", help="output file (default: stdout)", default=None, type=Path)
+    parser_details.set_defaults(func=command_details)
+
+    parser_quality = subparsers.add_parser("quality", help="show video quality")
+    parser_quality.add_argument("id", help="video id", type=str)
+    parser_quality.add_argument("-s", "--session", help="user_session cookie", default=None, type=str)
+    parser_quality.set_defaults(func=command_quality)
+
+    parser_download = subparsers.add_parser("download", help="download video")
+    parser_download.add_argument("id", help="video id", type=str)
+    parser_download.add_argument("-o", "--output", help="output file path", default=".", type=str)
+    parser_download.add_argument("-s", "--session", help="user_session cookie", default=None, type=str)
+    parser_download.add_argument("-q", "--quality", help="video quality (default: best)", default=None, type=str)
+    parser_download.add_argument("-a", "--audio", help="download audio only", action="store_true")
+    parser_download.set_defaults(func=command_download)
+
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.DEBUG if args.debug else logging.INFO, format="%(message)s")
+
+    if hasattr(args, "func"):
+        args.func(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

niconico_py_ma-2.1.0.post1/niconico/base/client.py

@@ -0,0 +1,22 @@
+"""This module contains the base client class."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from niconico.niconico import NicoNico
+
+
+class BaseClient:
+    """A class that represents a base client."""
+
+    niconico: NicoNico
+
+    def __init__(self, niconico: NicoNico) -> None:
+        """Initialize the base client."""
+        self.niconico = niconico
+
+    def log(self, type_: str, message: str) -> None:
+        """Log a message."""
+        return getattr(self.niconico.logger, type_)(message)

niconico_py_ma-2.1.0.post1/niconico/channel/__init__.py

@@ -0,0 +1,35 @@
+"""This module provides a class that represents a channel client."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import requests
+
+from niconico.base.client import BaseClient
+from niconico.channel.search import ChannelSearchClient
+from niconico.objects.channel import ChannelData, ChAPIResponse
+
+if TYPE_CHECKING:
+    from niconico.niconico import NicoNico
+
+
+class ChannelClient(BaseClient):
+    """A client that represents a channel client."""
+
+    search: ChannelSearchClient
+
+    def __init__(self, niconico: NicoNico) -> None:
+        """Initialize the client."""
+        super().__init__(niconico)
+        self.search = ChannelSearchClient(niconico)
+
+    def get_channel(self, channel_id: str) -> ChannelData | None:
+        """Get a channel."""
+        channel_id = channel_id.replace("ch", "")
+        res = self.niconico.get(f"https://public-api.ch.nicovideo.jp/v2/open/channels/{channel_id}")
+        if res.status_code == requests.codes.ok:
+            res_cls = ChAPIResponse[ChannelData](**res.json())
+            if res_cls.data is not None:
+                return res_cls.data
+        return None

niconico_py_ma-2.1.0.post1/niconico/channel/search.py

@@ -0,0 +1,55 @@
+"""Module for channel search client."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+import requests
+
+from niconico.base.client import BaseClient
+from niconico.objects.channel.search import ChannelSearchItem, ChSearchAPIResponse
+
+
+class ChannelSearchClient(BaseClient):
+    """Client for channel search."""
+
+    def search_channels(
+        self,
+        query: str,
+        *,
+        search_type: Literal["keyword", "tag"] = "keyword",
+        limit: int = 20,
+        offset: int = 0,
+        order: Literal["desc", "asc"] = "desc",
+        sort: Literal["updateTime"] | None = None,
+    ) -> list[ChannelSearchItem]:
+        """Search channels by query.
+
+        Args:
+            query (str): Query to search.
+            search_type (Literal["keyword", "tag"], optional): Search type. Defaults to "keyword".
+            limit (int, optional): Limit. Defaults to 20.
+            offset (int, optional): Offset. Defaults to 0.
+            order (Literal["desc", "asc"], optional): Order. Defaults to "desc".
+            sort (Literal["updateTime"], optional): Sort. Default is created time.
+
+        Returns:
+            list[ChannelSearchItem]: Channel search item list.
+        """
+        query_dict = {
+            "query": query,
+            "searchType": search_type,
+            "limit": str(limit),
+            "offset": str(offset),
+            "order": order,
+            "responseGroup": "detail",
+        }
+        if sort is not None:
+            query_dict["sort"] = sort
+        query_str = "&".join(f"{key}={value}" for key, value in query_dict.items())
+        res = self.niconico.get(f"https://public-api.ch.nicovideo.jp/v1/open/search/channels?{query_str}")
+        if res.status_code == requests.codes.ok:
+            res_cls = ChSearchAPIResponse(**res.json())
+            if res_cls.data is not None:
+                return res_cls.data
+        return []

niconico_py_ma-2.1.0.post1/niconico/decorators.py

@@ -0,0 +1,30 @@
+"""Decorators for the niconico package."""
+
+from __future__ import annotations
+
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
+
+from niconico.exceptions import LoginRequiredError, PremiumRequiredError
+
+if TYPE_CHECKING:
+    from niconico.base.client import BaseClient
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def login_required(*, premium: bool = False) -> Callable[[F], F]:
+    """A decorator that requires a login to be performed."""
+
+    def decorator(func: F) -> F:
+        @wraps(func)
+        def wrapper(self: BaseClient, *args: Any, **kwargs: Any) -> F:  # noqa: ANN401
+            if not self.niconico.logined:
+                raise LoginRequiredError(message="Login is required to use this function.")
+            if premium and not self.niconico.premium:
+                raise PremiumRequiredError(message="Premium account is required to use this function.")
+            return func(self, *args, **kwargs)
+
+        return wrapper  # type: ignore  # noqa: PGH003
+
+    return decorator

niconico_py_ma-2.1.0.post1/niconico/exceptions.py

@@ -0,0 +1,71 @@
+"""This module contains exceptions for the niconico package."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from niconico.objects.video.watch import WatchResponseError
+
+
+class LoginFailureError(Exception):
+    """An exception raised when login fails."""
+
+    def __init__(self, message: str) -> None:
+        """Initialize the exception."""
+        self.message = message
+        super().__init__(message)
+
+
+class DownloadError(Exception):
+    """An exception raised when download fails."""
+
+    def __init__(self, message: str) -> None:
+        """Initialize the exception."""
+        self.message = message
+        super().__init__(message)
+
+
+class NicoAPIError(Exception):
+    """An exception raised when an error occurs in the Nico API."""
+
+    def __init__(self, message: str) -> None:
+        """Initialize the exception."""
+        self.message = message
+        super().__init__(message)
+
+
+class LoginRequiredError(Exception):
+    """An exception raised when login is required."""
+
+    def __init__(self, message: str) -> None:
+        """Initialize the exception."""
+        self.message = message
+        super().__init__(message)
+
+
+class PremiumRequiredError(Exception):
+    """An exception raised when a premium account is required."""
+
+    def __init__(self, message: str) -> None:
+        """Initialize the exception."""
+        self.message = message
+        super().__init__(message)
+
+
+class WatchAPIError(Exception):
+    """An exception raised when an error occurs in the watch API."""
+
+    def __init__(self, response: WatchResponseError) -> None:
+        """Initialize the exception."""
+        self.response = response
+        super().__init__(response.error_code)
+
+
+class CommentAPIError(Exception):
+    """An exception raised when an error occurs in the comment API."""
+
+    def __init__(self, message: str | None) -> None:
+        """Initialize the exception."""
+        self.message = message
+        super().__init__(message)