Yt Dlp

#!/usr/bin/env python3
"""
Video downloader using yt-dlp.
Supports downloading videos from various platforms.
"""

import sys
import os
import subprocess
import json
import argparse
from pathlib import Path
from urllib.parse import urlparse

VALID_DOMAINS = [
    'youtube.com', 'youtu.be', 'twitter.com', 'x.com', 'vimeo.com',
    'tiktok.com', 'instagram.com', 'facebook.com', 'fb.watch',
    'twitch.tv', 'dailymotion.com', 'nicovideo.jp', 'bilibili.com',
    'reddit.com', 'streamable.com', 'clips.twitch.tv', 'video.twimg.com'
]

def is_video_url(url):
    """Check if URL looks like a video URL."""
    try:
        parsed = urlparse(url)
        domain = parsed.netloc.lower()

        # Remove www. prefix
        if domain.startswith('www.'):
            domain = domain[4:]

        # Check if it's a valid video domain
        for valid_domain in VALID_DOMAINS:
            if valid_domain in domain:
                return True

        return False
    except:
        return False

def extract_video_info(url):
    """Extract video information using yt-dlp."""
    try:
        cmd = [
            'yt-dlp',
            '--no-download',
            '--dump-json',
            '--flat-playlist',
            url
        ]

        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
        if result.returncode != 0:
            return None

        # Try to parse the first line as JSON
        lines = result.stdout.strip().split('\n')
        if lines:
            data = json.loads(lines[0])
            return data

        return None
    except Exception as e:
        print(f"Error extracting video info: {e}", file=sys.stderr)
        return None

def download_video(url, output_dir=None, format=None, quality=None):
    """Download video using yt-dlp."""
    if output_dir is None:
        output_dir = os.getcwd()

    # Build yt-dlp command
    cmd = ['yt-dlp', url]

    # Set output template
    cmd.extend(['-o', f'{output_dir}/%(title)s.%(ext)s'])

    # Handle format and quality
    if format:
        cmd.extend(['-f', format])
    elif quality:
        # Map quality to format selector
        quality_map = {
            'best': 'best',
            '1080p': 'bestvideo[height<=1080]+bestaudio/best',
            '720p': 'bestvideo[height<=720]+bestaudio/best',
            '480p': 'bestvideo[height<=480]+bestaudio/best',
            'audio': 'bestaudio'
        }
        if quality in quality_map:
            cmd.extend(['-f', quality_map[quality]])

    # Add some useful options
    cmd.extend([
        '--no-playlist',  # Only download single video
        '--write-info-json',  # Save metadata
        '--write-thumbnail'  # Save thumbnail
    ])

    print(f"Downloading video from: {url}", file=sys.stderr)
    print(f"Output directory: {output_dir}", file=sys.stderr)

    try:
        result = subprocess.run(cmd, check=True)
        return result.returncode == 0
    except subprocess.CalledProcessError as e:
        print(f"Download failed: {e}", file=sys.stderr)
        return False
    except Exception as e:
        print(f"Error during download: {e}", file=sys.stderr)
        return False

def main():
    parser = argparse.ArgumentParser(description='Download video using yt-dlp')
    parser.add_argument('url', help='Video URL to download')
    parser.add_argument('-o', '--output', help='Output directory', default=os.getcwd())
    parser.add_argument('-f', '--format', help='Video format selector')
    parser.add_argument('-q', '--quality',
                       choices=['best', '1080p', '720p', '480p', 'audio'],
                       help='Video quality')
    parser.add_argument('--info-only', action='store_true',
                       help='Only extract video info, do not download')

    args = parser.parse_args()

    # Validate URL
    if not is_video_url(args.url):
        print(f"Warning: URL does not appear to be from a known video platform: {args.url}", file=sys.stderr)
        print("Will attempt download anyway.", file=sys.stderr)

    if args.info_only:
        # Only extract info
        info = extract_video_info(args.url)
        if info:
            print(json.dumps(info, indent=2))
            sys.exit(0)
        else:
            sys.exit(1)
    else:
        # Download video
        success = download_video(args.url, args.output, args.format, args.quality)
        sys.exit(0 if success else 1)

if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Extract audio from video using yt-dlp and ffmpeg.
"""

import sys
import os
import subprocess
import argparse
from pathlib import Path

def extract_audio(url, output_dir=None, format='mp3', quality='192'):
    """Extract audio from video."""
    if output_dir is None:
        output_dir = os.getcwd()

    # Build yt-dlp command
    cmd = ['yt-dlp', url]

    # Set output template for audio
    cmd.extend(['-o', f'{output_dir}/%(title)s.{format}'])

    # Set format to extract audio only
    cmd.extend(['-f', 'bestaudio[ext=m4a]/bestaudio'])

    # Add post-processing to convert to desired format
    cmd.extend([
        '--extract-audio',
        '--audio-format', format,
        '--audio-quality', quality
    ])

    # Add useful metadata options
    cmd.extend([
        '--write-info-json',
        '--write-thumbnail'
    ])

    print(f"Extracting audio from: {url}", file=sys.stderr)
    print(f"Output format: {format}", file=sys.stderr)
    print(f"Output directory: {output_dir}", file=sys.stderr)

    try:
        result = subprocess.run(cmd, check=True)
        return result.returncode == 0
    except subprocess.CalledProcessError as e:
        print(f"Audio extraction failed: {e}", file=sys.stderr)
        return False
    except Exception as e:
        print(f"Error during audio extraction: {e}", file=sys.stderr)
        return False

def main():
    parser = argparse.ArgumentParser(description='Extract audio from video using yt-dlp')
    parser.add_argument('url', help='Video URL')
    parser.add_argument('-o', '--output', help='Output directory', default=os.getcwd())
    parser.add_argument('-f', '--format', help='Audio format', default='mp3',
                       choices=['mp3', 'm4a', 'opus', 'flac', 'wav'])
    parser.add_argument('-q', '--quality', help='Audio quality', default='192')
    args = parser.parse_args()

    success = extract_audio(args.url, args.output, args.format, args.quality)
    sys.exit(0 if success else 1)

if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Extract video URLs from text or files.
"""

import sys
import re
import json
from urllib.parse import urlparse

# Video domains to look for
VIDEO_DOMAINS = [
    r'youtube\.com',
    r'youtu\.be',
    r'twitter\.com',
    r'x\.com',
    r'vimeo\.com',
    r'tiktok\.com',
    r'instagram\.com',
    r'facebook\.com',
    r'fb\.watch',
    r'twitch\.tv',
    r'dailymotion\.com',
    r'nicovideo\.jp',
    r'bilibili\.com',
    r'reddit\.com',
    r'streamable\.com',
    r'clips\.twitch\.tv',
    r'video\.twimg\.com'
]

def extract_urls_from_text(text):
    """Extract all URLs from text and filter video URLs."""
    # URL pattern
    url_pattern = r'https?://(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&//=]*)'

    # Find all URLs
    all_urls = re.findall(url_pattern, text, re.IGNORECASE)

    # Filter video URLs
    video_urls = []
    for url in all_urls:
        parsed = urlparse(url)
        domain = parsed.netloc.lower()

        # Remove www. prefix
        if domain.startswith('www.'):
            domain = domain[4:]

        # Check if it's a video domain
        for video_domain in VIDEO_DOMAINS:
            if re.search(video_domain, domain):
                video_urls.append(url)
                break

    return video_urls

def extract_urls_from_file(file_path):
    """Extract URLs from a file."""
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            content = f.read()
        return extract_urls_from_text(content)
    except Exception as e:
        print(f"Error reading file {file_path}: {e}", file=sys.stderr)
        return []

def main():
    if len(sys.argv) < 2:
        print("Usage: extract_urls.py <text_or_file>", file=sys.stderr)
        print("       If the argument is a file path, URLs will be extracted from the file.", file=sys.stderr)
        print("       Otherwise, URLs will be extracted from the provided text.", file=sys.stderr)
        sys.exit(1)

    input_arg = sys.argv[1]

    # Check if input is a file path
    if len(sys.argv) == 2 and not sys.stdin.isatty():
        # Read from stdin
        content = sys.stdin.read()
        urls = extract_urls_from_text(content)
    elif input_arg.startswith('http') or ' ' in input_arg:
        # It's likely text with a URL
        urls = extract_urls_from_text(input_arg)
    else:
        # Try as file first
        try:
            urls = extract_urls_from_file(input_arg)
        except:
            # Fall back to treating as text
            urls = extract_urls_from_text(input_arg)

    # Output as JSON
    print(json.dumps(urls, indent=2))

if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Test script for yt-dlp functionality.
"""

import subprocess
import sys

def test_yt_dlp_installed():
    """Check if yt-dlp is installed."""
    try:
        result = subprocess.run(['yt-dlp', '--version'], capture_output=True, text=True)
        if result.returncode == 0:
            print(f"✓ yt-dlp is installed: version {result.stdout.strip()}")
            return True
        else:
            print("✗ yt-dlp command failed")
            return False
    except FileNotFoundError:
        print("✗ yt-dlp is not installed")
        print("  Install with: pip install yt-dlp")
        return False

def test_ffmpeg_installed():
    """Check if ffmpeg is installed."""
    try:
        result = subprocess.run(['ffmpeg', '-version'], capture_output=True, text=True)
        if result.returncode == 0:
            print(f"✓ ffmpeg is installed")
            return True
        else:
            print("✗ ffmpeg command failed")
            return False
    except FileNotFoundError:
        print("✗ ffmpeg is not installed (required for format conversion)")
        print("  Install with: brew install ffmpeg (macOS) or apt install ffmpeg (Linux)")
        return False

def test_extract_urls():
    """Test URL extraction."""
    import extract_urls

    test_cases = [
        ("Check out https://youtube.com/watch?v=test", 1),
        ("Multiple: https://youtu.be/abc and https://vimeo.com/123", 2),
        ("No video links here", 0),
    ]

    print("\nTesting URL extraction:")
    all_passed = True

    for text, expected_count in test_cases:
        urls = extract_urls.extract_urls_from_text(text)
        if len(urls) == expected_count:
            print(f"✓ Found {expected_count} URL(s) in: '{text}'")
        else:
            print(f"✗ Expected {expected_count} URLs, got {len(urls)} in: '{text}'")
            all_passed = False

    return all_passed

def test_video_url_detection():
    """Test video URL detection."""
    import download_video

    test_cases = [
        ("https://youtube.com/watch?v=abc", True),
        ("https://youtu.be/xyz", True),
        ("https://twitter.com/user/status/123", True),
        ("https://example.com/video.mp4", False),
        ("https://google.com", False),
    ]

    print("\nTesting video URL detection:")
    all_passed = True

    for url, expected in test_cases:
        result = download_video.is_video_url(url)
        if result == expected:
            print(f"✓ Correctly identified {url} as {'video' if expected else 'non-video'}")
        else:
            print(f"✗ Wrong classification for {url}")
            all_passed = False

    return all_passed

def main():
    print("Testing yt-dlp Skill Setup\n")
    print("=" * 50)

    # Check dependencies
    yt_dlp_ok = test_yt_dlp_installed()
    ffmpeg_ok = test_ffmpeg_installed()

    # Test modules
    try:
        extract_urls_ok = test_extract_urls()
        detection_ok = test_video_url_detection()
    except Exception as e:
        print(f"\n✗ Module test failed: {e}")
        extract_urls_ok = detection_ok = False

    print("\n" + "=" * 50)

    # Summary
    if yt_dlp_ok and ffmpeg_ok:
        print("✓ Basic setup looks good!")
        print("  The skill is ready to use.")
    else:
        print("✗ Please install missing dependencies before using the skill.")
        sys.exit(1)

    if extract_urls_ok and detection_ok:
        print("✓ All module tests passed!")
    else:
        print("✗ Some module tests failed.")
        sys.exit(1)

if __name__ == '__main__':
    main()