youtube-rb 0.2.0

data/lib/youtube-rb/video_info.rb

@@ -0,0 +1,179 @@
+module YoutubeRb
+  class VideoInfo
+    attr_reader :id, :title, :description, :uploader, :uploader_id,
+                :duration, :view_count, :like_count, :upload_date,
+                :thumbnail, :formats, :subtitles, :url, :ext,
+                :webpage_url, :fulltitle
+
+    def initialize(data)
+      @id = data['id'] || data[:id]
+      @title = data['title'] || data[:title]
+      @fulltitle = data['fulltitle'] || data[:fulltitle] || @title
+      @description = data['description'] || data[:description]
+      @uploader = data['uploader'] || data[:uploader]
+      @uploader_id = data['uploader_id'] || data[:uploader_id]
+      @duration = parse_duration(data['duration'] || data[:duration])
+      @view_count = data['view_count'] || data[:view_count]
+      @like_count = data['like_count'] || data[:like_count]
+      @upload_date = data['upload_date'] || data[:upload_date]
+      @thumbnail = data['thumbnail'] || data[:thumbnail]
+      @formats = parse_formats(data['formats'] || data[:formats] || [])
+      @subtitles = parse_subtitles(data['subtitles'] || data[:subtitles] || {})
+      @url = data['url'] || data[:url]
+      @ext = data['ext'] || data[:ext]
+      @webpage_url = data['webpage_url'] || data[:webpage_url]
+    end
+
+    def available_formats
+      @formats.map { |f| f[:format_id] }
+    end
+
+    def available_qualities
+      @formats.map { |f| f[:quality] }.uniq.compact
+    end
+
+    def available_subtitle_languages
+      @subtitles.keys
+    end
+
+    def best_format
+      @formats.max_by { |f| format_priority(f) }
+    end
+
+    def worst_format
+      @formats.min_by { |f| format_priority(f) }
+    end
+
+    def best_video_format
+      video_formats.max_by { |f| format_priority(f) }
+    end
+
+    def best_audio_format
+      audio_formats.max_by { |f| format_priority(f) }
+    end
+
+    def video_formats
+      @formats.select { |f| f[:vcodec] && f[:vcodec] != 'none' }
+    end
+
+    def audio_formats
+      @formats.select { |f| f[:acodec] && f[:acodec] != 'none' }
+    end
+
+    def get_format(format_id)
+      @formats.find { |f| f[:format_id] == format_id }
+    end
+
+    def get_subtitle(lang)
+      @subtitles[lang]
+    end
+
+    def duration_in_seconds
+      @duration
+    end
+
+    def duration_formatted
+      return nil unless @duration
+      
+      hours = @duration / 3600
+      minutes = (@duration % 3600) / 60
+      seconds = @duration % 60
+
+      if hours > 0
+        format("%02d:%02d:%02d", hours, minutes, seconds)
+      else
+        format("%02d:%02d", minutes, seconds)
+      end
+    end
+
+    def to_h
+      {
+        id: @id,
+        title: @title,
+        fulltitle: @fulltitle,
+        description: @description,
+        uploader: @uploader,
+        uploader_id: @uploader_id,
+        duration: @duration,
+        duration_formatted: duration_formatted,
+        view_count: @view_count,
+        like_count: @like_count,
+        upload_date: @upload_date,
+        thumbnail: @thumbnail,
+        formats: @formats,
+        subtitles: @subtitles,
+        url: @url,
+        ext: @ext,
+        webpage_url: @webpage_url
+      }
+    end
+
+    private
+
+    def parse_duration(duration)
+      return nil unless duration
+      duration.is_a?(Numeric) ? duration.to_i : duration.to_s.to_i
+    end
+
+    def parse_formats(formats_data)
+      return [] unless formats_data.is_a?(Array)
+
+      formats_data.map do |format|
+        {
+          format_id: format['format_id'] || format[:format_id],
+          format_note: format['format_note'] || format[:format_note],
+          ext: format['ext'] || format[:ext],
+          url: format['url'] || format[:url],
+          width: format['width'] || format[:width],
+          height: format['height'] || format[:height],
+          fps: format['fps'] || format[:fps],
+          vcodec: format['vcodec'] || format[:vcodec],
+          acodec: format['acodec'] || format[:acodec],
+          tbr: format['tbr'] || format[:tbr],
+          abr: format['abr'] || format[:abr],
+          vbr: format['vbr'] || format[:vbr],
+          filesize: format['filesize'] || format[:filesize],
+          quality: format['quality'] || format[:quality],
+          protocol: format['protocol'] || format[:protocol]
+        }
+      end
+    end
+
+    def parse_subtitles(subtitles_data)
+      return {} unless subtitles_data.is_a?(Hash)
+
+      subtitles_data.transform_values do |subtitle_formats|
+        subtitle_formats.map do |sub|
+          {
+            ext: sub['ext'] || sub[:ext],
+            url: sub['url'] || sub[:url],
+            name: sub['name'] || sub[:name]
+          }
+        end
+      end
+    end
+
+    def format_priority(format)
+      # Priority calculation based on multiple factors
+      priority = 0
+      
+      # Video quality
+      if format[:height]
+        priority += format[:height] * 100
+      end
+      
+      # Bitrate
+      if format[:tbr]
+        priority += format[:tbr]
+      end
+      
+      # Prefer certain codecs
+      if format[:vcodec]
+        priority += 10 if format[:vcodec].include?('avc')
+        priority += 5 if format[:vcodec].include?('vp9')
+      end
+      
+      priority
+    end
+  end
+end

data/lib/youtube-rb/ytdlp_wrapper.rb

@@ -0,0 +1,269 @@
+require 'open3'
+require 'json'
+require 'shellwords'
+
+module YoutubeRb
+  class YtdlpWrapper
+    class YtdlpNotFoundError < StandardError; end
+    class YtdlpError < StandardError; end
+
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options.is_a?(Options) ? options : Options.new(**options)
+      check_ytdlp_installation!
+    end
+
+    # Extract video information using yt-dlp
+    # @param url [String] Video URL
+    # @return [Hash] Video information
+    def extract_info(url)
+      args = build_info_args(url)
+      output, status = execute_ytdlp(args)
+
+      raise YtdlpError, "Failed to extract info: #{output}" unless status.success?
+
+      JSON.parse(output)
+    rescue JSON::ParserError => e
+      raise YtdlpError, "Failed to parse yt-dlp output: #{e.message}"
+    end
+
+    # Download video using yt-dlp
+    # @param url [String] Video URL
+    # @param output_path [String] Output file path
+    # @return [String] Path to downloaded file
+    def download(url, output_path = nil)
+      args = build_download_args(url, output_path)
+      output, status = execute_ytdlp(args, show_progress: true)
+
+      unless status.success?
+        raise YtdlpError, "Download failed: #{output}"
+      end
+
+      # Return the actual output path
+      output_path || detect_output_file(output)
+    end
+
+    # Download video segment using yt-dlp
+    # @param url [String] Video URL
+    # @param start_time [Integer] Start time in seconds
+    # @param end_time [Integer] End time in seconds
+    # @param output_path [String, nil] Output file path
+    # @return [String] Path to downloaded segment
+    def download_segment(url, start_time, end_time, output_path = nil)
+      args = build_segment_args(url, start_time, end_time, output_path)
+      output, status = execute_ytdlp(args, show_progress: true)
+
+      unless status.success?
+        raise YtdlpError, "Segment download failed: #{output}"
+      end
+
+      output_path || detect_output_file(output)
+    end
+
+    # Check if yt-dlp is installed
+    # @return [Boolean]
+    def self.available?
+      system('which yt-dlp > /dev/null 2>&1') || 
+      system('which youtube-dl > /dev/null 2>&1')
+    end
+
+    # Get yt-dlp version
+    # @return [String] Version string
+    def self.version
+      output, status = Open3.capture2('yt-dlp', '--version')
+      status.success? ? output.strip : 'unknown'
+    rescue
+      'not installed'
+    end
+
+    private
+
+    def check_ytdlp_installation!
+      unless self.class.available?
+        raise YtdlpNotFoundError, <<~MSG
+          yt-dlp is not installed. Please install it:
+          
+          # Using pip:
+          pip install -U yt-dlp
+          
+          # Or using pipx:
+          pipx install yt-dlp
+          
+          # Or using homebrew (macOS):
+          brew install yt-dlp
+          
+          # Or download binary from:
+          https://github.com/yt-dlp/yt-dlp/releases
+        MSG
+      end
+    end
+
+    def build_info_args(url)
+      args = ['yt-dlp', '--dump-json', '--no-playlist']
+      
+      # Add cookies file if specified
+      if @options.cookies_file && File.exist?(@options.cookies_file)
+        args += ['--cookies', @options.cookies_file]
+      end
+      
+      # Add user agent
+      if @options.user_agent
+        args += ['--user-agent', @options.user_agent]
+      end
+      
+      # Add referer
+      if @options.referer
+        args += ['--referer', @options.referer]
+      end
+      
+      # Add authentication
+      if @options.username && @options.password
+        args += ['--username', @options.username, '--password', @options.password]
+      end
+      
+      # Add retries
+      args += ['--retries', @options.retries.to_s]
+      
+      args << url
+      args
+    end
+
+    def build_download_args(url, output_path)
+      args = ['yt-dlp']
+      
+      # Output template
+      if output_path
+        args += ['-o', output_path]
+      else
+        template = @options.output_template
+        output_dir = @options.output_path
+        full_template = File.join(output_dir, template)
+        args += ['-o', full_template]
+      end
+      
+      # Format selection
+      if @options.extract_audio
+        args += ['-x', '--audio-format', @options.audio_format]
+        args += ['--audio-quality', @options.audio_quality] if @options.audio_quality
+      else
+        format = build_format_string
+        args += ['-f', format] if format
+      end
+      
+      # Subtitles
+      if @options.write_subtitles
+        args << '--write-subs'
+        args += ['--sub-langs', @options.subtitle_langs.join(',')]
+        args += ['--sub-format', @options.subtitle_format]
+      end
+      
+      if @options.write_auto_sub
+        args << '--write-auto-subs'
+      end
+      
+      # Metadata
+      args << '--write-info-json' if @options.write_info_json
+      args << '--write-thumbnail' if @options.write_thumbnail
+      args << '--write-description' if @options.write_description
+      
+      # Cookies and authentication
+      if @options.cookies_file && File.exist?(@options.cookies_file)
+        args += ['--cookies', @options.cookies_file]
+      end
+      
+      if @options.username && @options.password
+        args += ['--username', @options.username, '--password', @options.password]
+      end
+      
+      # Network options
+      args += ['--user-agent', @options.user_agent] if @options.user_agent
+      args += ['--referer', @options.referer] if @options.referer
+      args += ['--retries', @options.retries.to_s]
+      args += ['--rate-limit', @options.rate_limit] if @options.rate_limit
+      
+      # Filesystem options
+      args << '--no-overwrites' if @options.no_overwrites
+      args << '--continue' if @options.continue_download
+      args << '--no-part' if @options.no_part
+      
+      # Playlist handling
+      args << '--no-playlist' if @options.no_playlist
+      args << '--yes-playlist' if @options.yes_playlist
+      
+      args << url
+      args
+    end
+
+    def build_segment_args(url, start_time, end_time, output_path)
+      args = build_download_args(url, output_path)
+      
+      # Add download sections for segment
+      # yt-dlp format: *start_time-end_time
+      section = "*#{start_time}-#{end_time}"
+      args.insert(-2, '--download-sections', section)
+      
+      # Segment cutting mode:
+      # :fast (default) - Stream copy mode, cuts at keyframes (10x faster, ±2-5s accuracy)
+      # :precise - Re-encoding mode, exact timestamps (slow, frame-perfect)
+      #
+      # Fast mode: Uses stream copy (ffmpeg -c copy) which is very fast but cuts only at
+      #           keyframe positions. This means segments may be a few seconds longer.
+      # Precise mode: Uses --force-keyframes-at-cuts which forces re-encoding to get
+      #              frame-accurate cuts. This is VERY slow (especially for 4K video).
+      if @options.segment_mode == :precise
+        args.insert(-2, '--force-keyframes-at-cuts')
+      end
+      # For :fast mode, we don't add any flags - yt-dlp uses stream copy by default
+      
+      args
+    end
+
+    def build_format_string
+      case @options.quality
+      when 'best'
+        'bestvideo+bestaudio/best'
+      when 'worst'
+        'worstvideo+worstaudio/worst'
+      when /^\d+p$/
+        # e.g., "720p", "1080p"
+        height = @options.quality.to_i
+        "bestvideo[height<=#{height}]+bestaudio/best[height<=#{height}]"
+      else
+        @options.format || 'best'
+      end
+    end
+
+    def execute_ytdlp(args, show_progress: false)
+      # Escape arguments for shell
+      escaped_args = args.map { |arg| Shellwords.escape(arg) }
+      
+      if show_progress && @options.respond_to?(:verbose) && @options.verbose
+        # Show yt-dlp output in real-time
+        puts "Executing: #{args.join(' ')}" if ENV['DEBUG']
+        system(*args)
+        status = $?
+        ['', status]
+      else
+        # Capture output
+        stdout, stderr, status = Open3.capture3(*args)
+        output = stdout.empty? ? stderr : stdout
+        [output, status]
+      end
+    end
+
+    def detect_output_file(output)
+      # Try to detect the output file from yt-dlp output
+      # yt-dlp outputs: [download] Destination: filename.ext
+      if match = output.match(/\[download\] Destination: (.+)/)
+        return match[1].strip
+      end
+      
+      # Fallback: try to find the file in output directory
+      # This is less reliable but better than nothing
+      output_dir = @options.output_path
+      files = Dir.glob(File.join(output_dir, '*')).sort_by { |f| File.mtime(f) }
+      files.last
+    end
+  end
+end

data/lib/youtube-rb.rb

@@ -0,0 +1,69 @@
+require_relative "youtube-rb/version"
+require_relative "youtube-rb/options"
+require_relative "youtube-rb/video_info"
+require_relative "youtube-rb/extractor"
+require_relative "youtube-rb/ytdlp_wrapper"
+require_relative "youtube-rb/downloader"
+require_relative "youtube-rb/client"
+
+module YoutubeRb
+  class Error < StandardError; end
+  class ExtractionError < Error; end
+  class DownloadError < Error; end
+  class ValidationError < Error; end
+
+  # Convenience method to create a new client
+  # @param options [Hash] Client options
+  # @return [Client] New client instance
+  def self.new(**options)
+    Client.new(**options)
+  end
+
+  # Quick download method
+  # @param url [String] Video URL
+  # @param options [Hash] Download options
+  # @return [String] Path to downloaded file
+  def self.download(url, **options)
+    client = Client.new(**options)
+    client.download(url)
+  end
+
+  # Quick info extraction method
+  # @param url [String] Video URL
+  # @return [VideoInfo] Video information
+  def self.info(url)
+    client = Client.new
+    client.info(url)
+  end
+
+  # Quick segment download method
+  # @param url [String] Video URL
+  # @param start_time [Integer] Start time in seconds
+  # @param end_time [Integer] End time in seconds
+  # @param options [Hash] Download options
+  # @return [String] Path to downloaded segment
+  def self.download_segment(url, start_time, end_time, **options)
+    client = Client.new(**options)
+    client.download_segment(url, start_time, end_time, **options)
+  end
+
+  # Quick batch segment download method
+  # @param url [String] Video URL
+  # @param segments [Array<Hash>] Array of segment definitions
+  # @param options [Hash] Download options
+  # @return [Array<String>] Paths to downloaded segments
+  def self.download_segments(url, segments, **options)
+    client = Client.new(**options)
+    client.download_segments(url, segments, **options)
+  end
+
+  # Quick subtitles download method
+  # @param url [String] Video URL
+  # @param langs [Array<String>, nil] Languages to download
+  # @param options [Hash] Download options
+  # @return [void]
+  def self.download_subtitles(url, langs: nil, **options)
+    client = Client.new(**options)
+    client.download_subtitles(url, langs: langs, **options)
+  end
+end