rutube 0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dcbfc16dadfbb4964e347092236508a5678aeffb
+  data.tar.gz: 7db89d0aa31c0f1a2b31fa993ede058ce63662f7
+SHA512:
+  metadata.gz: 355babb9207902c387b7f011ffd470e0b48f90da3abf3f8e7f25fc6a4558aad12c1009bbc0ecd9bf0638d657af251f990f2f95dc4c07334f4e75c413332b733d
+  data.tar.gz: 76c69493473b225d0717c5622b565a3234dcd9fdd18fb3ec6f82a101a3df9d4d3f6674d84fa3a012648cf9c174028c6539d51e2621e1c8819dcc6b47db0d20ab

data/lib/rutube.rb

@@ -0,0 +1,7 @@
+module Rutube
+
+  require 'youtube'
+  require 'video'
+  require 'util'
+
+end

data/lib/util.rb

@@ -0,0 +1,111 @@
+require 'net/http'
+require 'json'
+require 'openssl'
+require 'video'
+require 'uri'
+
+class Array
+  def iterate!(code)
+    self.each_with_index do |n, i|
+      self[i] = code.call(n)
+    end
+  end
+end
+
+module Util
+
+  YT_BASE_URL = 'http://www.youtube.com/get_video_info'
+  OpenSSL::SSL::VERIFY_PEER = OpenSSL::SSL::VERIFY_NONE
+
+# YouTube quality and codecs id map.
+# source: http://en.wikipedia.org/wiki/YouTube#Quality_and_codecs
+  YT_ENCODING = {
+      # Flash Video
+      5 => ["flv", "240p", "Sorenson H.263", "N/A", "0.25", "MP3", "64"],
+      6 => ["flv", "270p", "Sorenson H.263", "N/A", "0.8", "MP3", "64"],
+      34 => ["flv", "360p", "H.264", "Main", "0.5", "AAC", "128"],
+      35 => ["flv", "480p", "H.264", "Main", "0.8-1", "AAC", "128"],
+
+      # 3GP
+      36 => ["3gp", "240p", "MPEG-4 Visual", "Simple", "0.17", "AAC", "38"],
+      13 => ["3gp", "N/A", "MPEG-4 Visual", "N/A", "0.5", "AAC", "N/A"],
+      17 => ["3gp", "144p", "MPEG-4 Visual", "Simple", "0.05", "AAC", "24"],
+
+      # MPEG-4
+      18 => ["mp4", "360p", "H.264", "Baseline", "0.5", "AAC", "96"],
+      22 => ["mp4", "720p", "H.264", "High", "2-2.9", "AAC", "192"],
+      37 => ["mp4", "1080p", "H.264", "High", "3-4.3", "AAC", "192"],
+      38 => ["mp4", "3072p", "H.264", "High", "3.5-5", "AAC", "192"],
+      82 => ["mp4", "360p", "H.264", "3D", "0.5", "AAC", "96"],
+      83 => ["mp4", "240p", "H.264", "3D", "0.5", "AAC", "96"],
+      84 => ["mp4", "720p", "H.264", "3D", "2-2.9", "AAC", "152"],
+      85 => ["mp4", "1080p", "H.264", "3D", "2-2.9", "AAC", "152"],
+
+      # WebM
+      43 => ["webm", "360p", "VP8", "N/A", "0.5", "Vorbis", "128"],
+      44 => ["webm", "480p", "VP8", "N/A", "1", "Vorbis", "128"],
+      45 => ["webm", "720p", "VP8", "N/A", "2", "Vorbis", "192"],
+      46 => ["webm", "1080p", "VP8", "N/A", "N/A", "Vorbis", "192"],
+      100 => ["webm", "360p", "VP8", "3D", "N/A", "Vorbis", "128"],
+      101 => ["webm", "360p", "VP8", "3D", "N/A", "Vorbis", "192"],
+      102 => ["webm", "720p", "VP8", "3D", "N/A", "Vorbis", "192"]
+  }
+
+# The keys corresponding to the quality/codec map above.
+  YT_ENCODING_KEYS = [
+      'extension',
+      'resolution',
+      'video_codec',
+      'profile',
+      'video_bitrate',
+      'audio_codec',
+      'audio_bitrate'
+  ]
+
+  def parse_stream_map(text)
+    videoinfo = {
+        "itag" => [],
+        "url" => [],
+        "quality" => [],
+        "fallback_host" => [],
+        "s" => [],
+        "type" => []
+    }
+
+    videos = text.split(",")
+    videos.iterate!(lambda { |video| video.split("&") })
+    for video in videos
+      for kv in video
+        key, value = kv.split("=")[0], URI.unescape(kv.split("=")[1])
+        videoinfo[key].index(value) == nil ? videoinfo[key].push(value) : ""
+      end
+    end
+    return videoinfo
+  end
+
+  module_function :parse_stream_map
+
+  def _extract_fmt(url)
+    fmt_data = Hash.new
+    if itag = url.match('itag=\d+').to_s.match('\d+').to_s.to_i
+      attr = YT_ENCODING[itag]
+      if attr == nil
+        return itag, fmt_data
+      end
+      lambda { |x, y| x.each_with_index { |i, j| fmt_data[i] = y[j] } }.call(YT_ENCODING_KEYS, attr)
+      return itag, fmt_data
+    end
+  end
+
+  module_function :_extract_fmt
+
+  def sanitize_filename(file_name)
+    file_name.gsub(/[^\w\.\-]/,"_")
+  end
+
+  module_function :sanitize_filename
+
+  def _cipher(s, url)
+    # TODO need to handle this by invoking js from ruby
+  end
+end

data/lib/video.rb

@@ -0,0 +1,41 @@
+require 'net/http'
+require 'uri'
+
+OpenSSL::SSL::VERIFY_PEER = OpenSSL::SSL::VERIFY_NONE
+
+class Video
+  attr_accessor :url, :filename, :fmt_data
+
+  def initialize(url, filename, fmt_data)
+    @url, @filename, @fmt_data = url, filename, fmt_data
+  end
+
+  def download(dir=Dir.pwd)
+    Thread.new(dir){_download(dir)}
+  end
+
+  def _download(dir)
+    if !Dir.exist?(dir)
+      raise "Directory doesn't exist"
+    end
+
+    file_name = File.join(dir, @filename+"."+@fmt_data["extension"])
+
+    if (File.exist?(file_name))
+      raise "File Already Exists"
+    end
+
+    uri = URI(@url)
+    begin
+      Net::HTTP.get_response(uri) { |res|
+        if res != nil && res.is_a?(Net::HTTPSuccess)
+          f = File.new(file_name, "wb")
+          res.read_body do |chunk|
+            f.write(chunk)
+          end
+          f.close()
+        end
+      }
+    end
+  end
+end

data/lib/youtube.rb

@@ -0,0 +1,105 @@
+require 'util'
+
+class Youtube
+  attr_accessor :file_name, :video_url, :video_id, :fmt_values, :videos, :title
+
+  def initialize(video_url)
+    @video_url = video_url
+    initialize_video_info(self)
+  end
+
+  def initialize_video_info(yt)
+    yt.title = ""
+    yt.videos = []
+    uri = URI(yt.video_url)
+    response = Net::HTTP.get_response(uri)
+
+    if response.is_a?(Net::HTTPMovedPermanently) && uri.scheme == "http"
+      puts "Changing the url scheme to https since redirections are not handled by ruby"
+      uri.scheme = "https"
+      uri.port = 443
+      response = Net::HTTP.get_response(uri)
+    end
+
+    if response != nil && response.is_a?(Net::HTTPSuccess)
+      content = response.body
+      player_conf = content[17 + content.index("ytplayer.config = ")..content.length]
+      bracket_count = 0
+      index = 0
+      player_conf.each_char.with_index { |char, i|
+        index = i
+        if char == "{"
+          bracket_count += 1
+        elsif char == "}"
+          bracket_count -= 1
+          if bracket_count == 0
+            break
+          end
+        end
+      }
+
+      index = index+1
+      data = JSON.parse(player_conf[0, index])
+
+      is_vevo = false
+      if ['vevo', 'dashmpd'].include?(data["args"]["pk"])
+        is_vevo = true
+      end
+
+      stream_map = Util.parse_stream_map(data["args"]["url_encoded_fmt_stream_map"])
+      yt.title = data["args"]["title"]
+      js_url = "http:" + data["assets"]["js"]
+      video_urls = stream_map["url"]
+      self.file_name = Util.sanitize_filename(yt.title)
+
+      yt.videos, yt.fmt_values = [], []
+
+      video_urls.each_with_index { |url, index|
+        begin
+          fmt, fmt_data = Util._extract_fmt(url)
+        rescue StandardError
+          puts $!, $@
+        end
+
+        if url.index('signature=') == nil
+          if is_vevo
+            ## TODO : need to handle it differently
+          else
+            signature = _cipher(stream_map["s"][i], js_url)
+            url = "%url&signature=%sig".gsub('url', url).gsub('sig', signature)
+          end
+        end
+
+        yt.videos.push(Video.new(url, yt.file_name, fmt_data))
+        yt.fmt_values.push(fmt)
+      }
+    end
+    return yt
+  rescue JSON::JSONError
+    puts "cannot decode json"
+  end
+
+
+  def get(type, resoln=nil)
+    return_videos = []
+    for video in @videos
+      if video.fmt_data["extension"] == type && (resoln == nil || (resoln != nil && resoln == video.fmt_data["resolution"]))
+        return_videos.push(video)
+        break
+      end
+    end
+    if return_videos.length == 1
+      return return_videos[0]
+    else
+      puts "no video present for the given format #{type}"
+      return nil
+    end
+  end
+
+  def list_formats
+    for video in @videos
+      puts "Video : #{video.fmt_data["video_codec"]} (.#{video.fmt_data["extension"]}) - #{video.fmt_data["resolution"]}"
+    end
+    return nil
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: rutube
+version: !ruby/object:Gem::Version
+  version: '0.3'
+platform: ruby
+authors:
+- Vidyuth Dandu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-30 00:00:00.000000000 Z
+dependencies: []
+description: Ruby port of pytube for downloading youtube videos
+email:
+- vidyuth.bitsgoa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rutube.rb
+- lib/util.rb
+- lib/video.rb
+- lib/youtube.rb
+homepage: http://github.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Download youtube videos using rutube
+test_files: []