mcp-server-youtube-info 0.1.6__tar.gz → 0.1.8__tar.gz

{mcp_server_youtube_info-0.1.6 → mcp_server_youtube_info-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-server-youtube-info
-Version: 0.1.6
+Version: 0.1.8
 Summary: A YouTube information retrieval server implementation for Model Context Protocol (MCP)
 Author-email: yareyaredesuyo <yareyaredesuyo@gmail.com>
 License-Expression: MIT
@@ -81,7 +81,7 @@ Add to your Claude settings:
 ```json
 {
   "mcpServers": {
-    "testing": {
+    "youtube-info": {
       "command": "uvx",
       "args": ["mcp-server-youtube-info"]
     }

{mcp_server_youtube_info-0.1.6 → mcp_server_youtube_info-0.1.8}/README.md

@@ -60,7 +60,7 @@ Add to your Claude settings:
 ```json
 {
   "mcpServers": {
-    "testing": {
+    "youtube-info": {
       "command": "uvx",
       "args": ["mcp-server-youtube-info"]
     }

{mcp_server_youtube_info-0.1.6 → mcp_server_youtube_info-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcp-server-youtube-info"
-version = "0.1.6"
+version = "0.1.8"
 description = "A YouTube information retrieval server implementation for Model Context Protocol (MCP)"
 readme = "README.md"
 requires-python = ">=3.10"

{mcp_server_youtube_info-0.1.6 → mcp_server_youtube_info-0.1.8}/src/mcp_server_youtube_info/server.py

@@ -1,33 +1,10 @@
 from fastmcp import FastMCP, Image
-import yt_dlp
 import io
 import httpx
 from PIL import Image as PILImage
-
+from mcp_server_youtube_info.util import VideoInfoExtractor
 mcp = FastMCP("MCP YouTube Info Server", dependencies=["httpx", "Pillow"])
 
-def _extract_info(video_id: str) -> dict:
-    """Retrieve meta info of YouTube video using yt-dlp.
-
-    Args:
-        video_id (str): YouTube video ID
-
-    Returns:
-        dict: Video meta information
-    """
-    ydl_opts = {
-        'quiet': True,
-        'no_warnings': True,
-        'extract_flat': True,
-    }
-    
-    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-        try:
-            url = f"https://www.youtube.com/watch?v={video_id}"
-            info = ydl.extract_info(url, download=False)
-            return info
-        except Exception as e:
-            raise Exception(f"Failed to retrieve video information: {str(e)}")
 
 @mcp.tool()
 def youtube_metainfo(video_id: str) -> dict:
@@ -40,10 +17,17 @@ def youtube_metainfo(video_id: str) -> dict:
         dict: Video meta information
     """
     try:
-        return _extract_info(video_id)
+        # Create extractor
+        extractor = VideoInfoExtractor()
+
+        # Get video information
+        raw_info = extractor.get_video_info(video_id)
+
+        return extractor.format_info(raw_info)
     except Exception as e:
         raise Exception(f"Failed to retrieve metadata: {str(e)}")
 
+
 @mcp.tool()
 def youtube_thumbnail_url(video_id: str) -> str:
     """Retrieve the thumbnail URL of a YouTube video.
@@ -55,41 +39,49 @@ def youtube_thumbnail_url(video_id: str) -> str:
         str: Thumbnail URL
     """
     try:
-        info = _extract_info(video_id)
-        thumbnail_url = info.get('thumbnail')
+        # Create extractor
+        extractor = VideoInfoExtractor()
+        # Get video information
+        raw_info = extractor.get_video_info(video_id)
+        thumbnail_url = raw_info.get('thumbnail')
         if not thumbnail_url:
             raise Exception("Cannot find thumbnail URL")
         return thumbnail_url
     except Exception as e:
         raise Exception(f"Failed to get thumbnail URL: {str(e)}")
 
+
 @mcp.tool()
 def youtube_thumbnail_image(video_id: str) -> Image:
     """
     Retrieve and download the thumbnail of a YouTube video as an Image.
-    
+
     Args:
         video_id: YouTube Video ID
     Returns:
         Image: Image object containing the thumbnail data
     """
     try:
-        info = _extract_info(video_id)
-        thumbnail_url = info.get('thumbnail')
+        # Create extractor
+        extractor = VideoInfoExtractor()
+
+        # Get video information
+        raw_info = extractor.get_video_info(video_id)
+        thumbnail_url = raw_info.get('thumbnail')
         if not thumbnail_url:
             raise Exception("Cannot find thumbnail URL")
     except Exception as e:
         raise Exception(f"Failed to get thumbnail URL: {str(e)}")
-    
+
     try:
         with httpx.Client() as client:
             response = client.get(thumbnail_url)
             response.raise_for_status()
-            
+
             image = PILImage.open(io.BytesIO(response.content)).convert('RGB')
             buffer = io.BytesIO()
             image.save(buffer, format="JPEG", quality=60, optimize=True)
-            
+
             return Image(data=buffer.getvalue(), format="jpeg")
     except httpx.HTTPStatusError as e:
         raise Exception(f"HTTP Error: {e.response.status_code}")

mcp_server_youtube_info-0.1.8/src/mcp_server_youtube_info/util.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""
+YouTube Video Metadata Retrieval Sample
+
+This script is a sample for retrieving metadata of YouTube videos.
+It only retrieves information without actual downloading.
+"""
+
+import sys
+from typing import Dict, Any, Optional
+import yt_dlp
+
+
+class VideoInfoExtractor:
+    """Class for retrieving YouTube video metadata"""
+
+    def __init__(self):
+        # yt-dlp settings (no download configuration)
+        self.ydl_opts = {
+            'quiet': True,                    # Suppress logs
+            'no_warnings': False,             # Show warnings
+            'extract_flat': False,            # Get detailed information
+            'simulate': True,                 # Simulation mode (no download)
+            'skip_download': True,            # Skip download
+        }
+
+    def get_video_info(self, video_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Retrieve video information for the specified video ID
+
+        Args:
+            video_id (str): YouTube video ID
+
+        Returns:
+            Dict[str, Any]: Video information dictionary, None if error occurs
+        """
+        try:
+            with yt_dlp.YoutubeDL(self.ydl_opts) as ydl:
+                # Get video information
+                url = f"https://www.youtube.com/watch?v={video_id}"
+                info = ydl.extract_info(url, download=False)
+                return info
+        except Exception as e:
+            print(f"An error occurred: {e}", file=sys.stderr)
+            return None
+
+    def format_info(self, info: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Format and return the retrieved information
+
+        Args:
+            info (Dict[str, Any]): Raw information retrieved from yt-dlp
+
+        Returns:
+            Dict[str, Any]: Formatted information
+        """
+        if not info:
+            return {}
+
+        # Extract basic information
+        formatted_info = {
+            'title': info.get('title', 'N/A'),
+            'uploader': info.get('uploader', 'N/A'),
+            'upload_date': info.get('upload_date', 'N/A'),
+            'duration': info.get('duration', 0),
+            'view_count': info.get('view_count', 0),
+            'like_count': info.get('like_count', 0),
+            'description': info.get('description', 'N/A')[:200] + '...' if info.get('description') else 'N/A',
+            'tags': info.get('tags', []),
+            'categories': info.get('categories', []),
+            'webpage_url': info.get('webpage_url', 'N/A'),
+            'thumbnail': info.get('thumbnail', 'N/A'),
+        }
+
+        # Available format information
+        formats = info.get('formats', [])
+        if formats:
+            # Summarize video format information concisely
+            video_formats = []
+            audio_formats = []
+
+            for fmt in formats:
+                if fmt.get('vcodec') != 'none' and fmt.get('acodec') != 'none':
+                    # Video + Audio
+                    video_formats.append({
+                        'format_id': fmt.get('format_id'),
+                        'ext': fmt.get('ext'),
+                        'resolution': f"{fmt.get('width', 'N/A')}x{fmt.get('height', 'N/A')}",
+                        'fps': fmt.get('fps'),
+                        'filesize': fmt.get('filesize'),
+                    })
+                elif fmt.get('acodec') != 'none':
+                    # Audio only
+                    audio_formats.append({
+                        'format_id': fmt.get('format_id'),
+                        'ext': fmt.get('ext'),
+                        'abr': fmt.get('abr'),
+                        'filesize': fmt.get('filesize'),
+                    })
+
+            formatted_info['available_formats'] = {
+                'video_count': len(video_formats),
+                'audio_count': len(audio_formats),
+                'video_formats': video_formats[:5],  # Show only the first 5
+                'audio_formats': audio_formats[:5],  # Show only the first 5
+            }
+
+        return formatted_info
+
+    def print_info(self, info: Dict[str, Any]) -> None:
+        """
+        Format and display information
+
+        Args:
+            info (Dict[str, Any]): Information to display
+        """
+        if not info:
+            print("Could not retrieve information.")
+            return
+
+        print("=" * 60)
+        print(f"Title: {info['title']}")
+        print(f"Uploader: {info['uploader']}")
+        print(f"Upload Date: {info['upload_date']}")
+        print(
+            f"Duration: {info['duration']} seconds ({info['duration']//60} min {info['duration'] % 60} sec)")
+        print(f"View Count: {info['view_count']:,}")
+        print(f"Like Count: {info['like_count']:,}")
+        print(f"URL: {info['webpage_url']}")
+        print("-" * 60)
+        print(f"Description: {info['description']}")
+        print("-" * 60)
+
+        if info['tags']:
+            print(f"Tags: {', '.join(info['tags'][:10])}")  # First 10 tags
+
+        if info['categories']:
+            print(f"Categories: {', '.join(info['categories'])}")
+
+        # Format information
+        if 'available_formats' in info:
+            formats = info['available_formats']
+            print("  Available formats:")
+            print(f"  Video format count: {formats['video_count']}")
+            print(f"  Audio format count: {formats['audio_count']}")
+
+            if formats['video_formats']:
+                print("  Main video formats:")
+                for fmt in formats['video_formats']:
+                    size_info = f" ({fmt['filesize']//1024//1024}MB)" if fmt['filesize'] else ""
+                    print(
+                        f"    - {fmt['format_id']}: {fmt['ext']}, {fmt['resolution']}, {fmt['fps']}fps{size_info}")
+
+        print("=" * 60)