twitchy 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 31af3d06423eafae96cc9dbf8b82607916ce868d
+  data.tar.gz: 665136e25a38df7a546bc6f9be18e568bfdc5fb3
+SHA512:
+  metadata.gz: 4c8dc487aa64b1cb843c42f742014d0c27f7c3f53feace988bd4864edf44716043f89d8843f270ac02f9544373d5e9015b861b1a4d622e0f75152befa27e8ef4
+  data.tar.gz: 742a133b912a3bc5b290d301fafd219285856820fd8ce3e618c23aa8e9b2f4d97fa6c90df5a4bbbd80901303cf44166dd88d6cf0b63fc496f0ad40a5163a8758

data/README.md

@@ -0,0 +1,28 @@
+# twitchy
+
+A little Ruby wrapper around livestreamer
+
+## Documentation
+
+```
+Usage: twitchy [options] [channel ..]
+    -p, --player PLAYER              Set video player
+    -c, --chat                       Open popout chat with the stream
+    -u, --user USER                  Show subs for a user
+    -q, --quality QUALITY            Set desired quality
+    -v, --videos                     List archives instead of streams
+    -l, --limit LIMIT                Number to fetch at once
+    -g, --game GAME                  Add top streamers for GAME
+        --highlights                 Only show highlights when fetching videos
+    -h, --help                       Show this message
+```
+## Dependencies
+
+Requires [`livestreamer`](https://github.com/chrippa/livestreamer) (obviously), and currently the [`colorize`](https://github.com/fazibear/colorize) gem.
+
+## Todo
+
+I plan on gemifying this soon. Also, a lot of usage is unclear (pagination in 
+archives, quality options, https://github.com/fazibear/colorizeetc).
+
+I have greatly reduced API requests from earlier versions, but I'm always keeping an eye out for ways to bring the number of those calls down further. There's a way to get all the videos from subscriptions of a user, but it requires authentication and isn't very flexible, for example, so right now I'm making calls for each requested channel.

data/bin/twitchy

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require 'twitchy/twitchy'
+
+trap ("SIGINT") { exit! }
+
+t = Twitchy.new(ARGV)
+
+if t.streamers.empty?
+    if t.options.user
+        puts "User follows no streamers"
+    else
+        puts t.banner
+    end
+    exit
+end
+
+if t.options.videos
+    t.get_archives
+else
+    t.check_status
+    if t.online.empty?
+        puts "All streamers are offline"
+        exit
+    end
+end
+
+t.puts_streams
+t.get_choice
+
+#vim: ft=rb

data/lib/twitchy/dstruct.rb

@@ -0,0 +1,29 @@
+require 'ostruct'
+
+class DeepStruct < OpenStruct
+  def initialize(hash=nil)
+    @table = {}
+    @hash_table = {}
+
+    if hash
+      hash.each do |k,v|
+        @table[k.to_sym] = v
+
+        @table[k.to_sym] = v.map do |o|
+            o.is_a?(Hash) ? self.class.new(o) : o
+        end if v.is_a? Array
+
+        @table[k.to_sym] = self.class.new(v) if v.is_a? Hash
+
+        @hash_table[k.to_sym] = v
+
+        new_ostruct_member(k)
+      end
+    end
+  end
+
+  def to_h
+    @hash_table
+  end
+
+end

data/lib/twitchy/livestreamer.rb

@@ -0,0 +1,28 @@
+require 'json'
+
+module Livestreamer
+    @@sort = ["best","source","high","medium","low","mobile","worst"]
+
+    def self.get_available_streams(channel)
+        @@sort & JSON.parse(`livestreamer -j twitch.tv/#{channel}`)["streams"].keys
+    end
+
+    def self.start_stream(channel, player, quality, chat)
+        stream = "livestreamer -Q -p '#{player}' "\
+                 "twitch.tv/#{channel} #{quality} & "
+        popout_chat = "firefox -new-window "\
+               "'http://www.twitch.tv/chat/embed"\
+               "?channel=#{channel}&popout_chat=true' "\
+               "&> /dev/null & "
+        cmd = stream
+        cmd += popout_chat if chat
+
+        exec cmd
+    end
+
+    def self.start_video(url, player)
+        exec "livestreamer -Q -p '#{player}' "\
+             "#{url} best &"
+    end
+end
+

data/lib/twitchy/twitch_api.rb

@@ -0,0 +1,72 @@
+require 'open-uri'
+require 'twitchy/dstruct'
+require 'json'
+
+module TwitchAPI
+    @@PREFIX = "https://api.twitch.tv/kraken/"
+
+    def self.get_follow_data(user)
+        catch_exception(OpenURI::HTTPError) do
+            get_as_struct("users/#{user}/follows/channels").follows
+        end
+    end
+
+    def self.get_stream_status(streamers)
+        query = "streams?channel=#{streamers.join(",")}"
+        catch_exception(OpenURI::HTTPError, default: {}) do
+            get_as_struct(query).streams.map do |s|
+                [s.channel.name, s]
+            end.to_h
+        end
+    end
+
+    def self.get_stream_data(streamer)
+        catch_exception(OpenURI::HTTPError) do
+            get_as_struct("streams/#{streamer}").stream
+        end
+    end
+
+    def self.get_videos(streamer, limit: 10, offset: 0, highlights: false)
+        catch_exception(OpenURI::HTTPError) do
+            query = "channels/#{streamer}/videos"\
+                    "?broadcasts=#{!highlights}"\
+                    "&limit=#{limit}&offset=#{offset}"
+            get_as_struct(query).videos.each do |v|
+                v.recorded_at = DateTime.parse(v.recorded_at)
+            end
+        end
+    end
+
+    def self.get_streamers_for_game(game, limit: 10, offset: 0)
+        catch_exception(OpenURI::HTTPError) do
+            query = "streams?game=#{URI.encode(game)}&limit=#{limit}&offset=#{offset}"
+            get_as_struct(query).streams.map{|s| s.channel.name}
+        end
+    end
+
+    private
+    def self.catch_exception(exception, default: nil, &block)
+        if block
+            begin
+                yield
+            rescue exception
+                default
+            end
+        else
+            default
+        end
+    end
+
+    def self.get(request)
+        open( @@PREFIX + request ).each_line.to_a.join
+    end
+
+    def self.get_as_json(request)
+        JSON.parse(get(request))
+    end
+
+    def self.get_as_struct(request)
+        DeepStruct.new(get_as_json(request))
+    end
+
+end

data/lib/twitchy/twitchy.rb

@@ -0,0 +1,278 @@
+require 'colorize'
+require 'optparse'
+require 'ostruct'
+require 'twitchy/livestreamer'
+require 'twitchy/twitch_api'
+
+class Twitchy
+    attr_reader :options, :streamers, :online
+
+    def initialize(args)
+        parse_options(args)
+
+        @streamers = args.map{|s| s.dup}
+        @streamers += fetch_subs(@options.user) if @options.user
+        @streamers += TwitchAPI.get_streamers_for_game(
+            @options.game, limit: @options.limit
+        ) if @options.game
+    end
+
+    def parse_options(args)
+        @options = OpenStruct.new(
+            player:     "vlc --no-video-title-show",
+            quality:    "best",
+            chat:       false,
+            videos:     false,
+            limit:      20,
+            highlights: false,
+            game:       nil
+        )
+        @optparser = OptionParser.new do |opts|
+            opts.banner = "Usage: twitchy [options] [channel ..]"
+
+            opts.on("-p", "--player PLAYER", "Set video player") do |p|
+                @options.player = p
+            end
+
+            opts.on("-c", "--chat", "Open popout chat with the stream") do
+                @options.chat = true
+            end
+
+            opts.on("-u", "--user USER", "Show subs for a user") do |u|
+                @options.user = u
+            end
+
+            opts.on("-q", "--quality QUALITY", "Set desired quality") do |q|
+                @options.quality = q
+            end
+
+            opts.on("-v", "--videos", "List archives instead of streams") do
+                @options.videos = true
+            end
+
+            opts.on("-l", "--limit LIMIT", Integer, "Number to fetch at once") do |l|
+                @options.limit = l
+            end
+
+            opts.on("-g", "--game GAME", "Add top streamers for GAME") do |g|
+                @options.game = g
+            end
+
+            opts.on("--highlights", "Only show highlights when fetching videos") do
+                @options.highlights = true
+            end
+
+            opts.on_tail("-h", "--help", "Show this message") do
+                puts opts
+                exit
+            end
+        end
+
+        @optparser.parse!(args)
+    end
+
+    def fetch_subs(user)
+        puts "Fetching subscriptions".bold
+        TwitchAPI.get_follow_data(user).map do |follow|
+            follow.channel.name
+        end.reverse!
+    end
+
+    def check_status
+        puts "Checking streamer status...".bold
+        @online = TwitchAPI.get_stream_status(@streamers)
+        @online.each do |streamer, data|
+            print "Getting quality options for #{streamer} "
+            data.streams = Livestreamer.get_available_streams(streamer)
+            clearln
+        end
+        @online_streamers = @online.keys.sort_by!{|s| @online[s].viewers}.reverse!
+    end
+
+    def get_archives
+        puts "Requesting archives".bold
+        @archives = []
+        @archive_count = Hash.new(0)
+        streamers.each do |streamer|
+            print streamer
+            vods = TwitchAPI.get_videos(
+                streamer, limit: @options.limit, highlights: @options.highlights
+            )
+            @archives += vods
+            @archive_count[streamer] += vods.to_a.size
+            clearln
+            puts streamer.green
+        end
+    end
+
+
+    def banner
+        @optparser.help()
+    end
+
+    def clearln
+        print "\r\e[K"
+    end
+
+    def puts_streams(offset: 0)
+        puts
+        puts "Streams available:".bold
+        index = 0
+
+        if @options.videos
+            @archives.sort_by!{|v| v.recorded_at}.reverse!
+            @archives.drop(offset).take(@options.limit).each do |video|
+                streamer = video.channel.display_name
+                index += 1
+                puts_stream_info(index, streamer, video.title.to_s, video.game.to_s, time: video.length)
+            end
+        else
+            @online_streamers.each do |streamer|
+                info = @online[streamer].channel
+                streamer_name = info.display_name
+                index += 1
+                qualities = @online[streamer].streams
+                qualities = nil if qualities.include? @options.quality
+                puts_stream_info(index, streamer_name, info.status.to_s, info.game.to_s, qualities: qualities)
+            end
+        end
+    end
+
+    def puts_stream_info(index, streamer, title, game, qualities: nil, time: nil)
+        def abbrev(str, length=77)
+            short = str.chomp[0...length]
+            short += "..." if str.length > 77
+            short
+        end
+        title = abbrev(title)
+        puts "#{index.to_s.bold}. #{streamer} - "\
+             "#{"(#{format_time(time)}) " if time}"\
+             "'#{title.sub(game, game.underline)}' "\
+             "#{"playing #{game.underline}" unless title.include? game if game}"
+        puts "   [ #{qualities.map{ |q|
+            if q == @options.quality then q.bold else q end
+        }.join(' | ')} ]" if qualities
+    end
+
+    def get_choice
+        if @options.videos
+            get_video_choice
+        else
+            get_stream_choice
+        end
+    end
+
+    def get_stream_choice
+        prompt = "Select stream number [and quality] to watch: ".bold
+        print prompt
+
+        loop do
+            response = ($stdin.gets || "").chomp.split
+
+            response, quality = case response.length
+            when 0
+                ["", nil]
+            when 1
+                [response[0], @options.quality]
+            else
+                response[0,2]
+            end
+
+            break if response.downcase == "q"
+
+            choice = Integer(response) rescue nil
+            if choice && choice > 0 && choice <= @online_streamers.length
+                streamer = @online_streamers[choice - 1]
+                if @online[streamer].streams.include? quality
+                    launch_stream(streamer, quality)
+                else
+                    print "Requested quality not available, options are "
+                    puts "[#{@online[streamer].streams.join(", ")}]"
+                end
+            else
+                print "Invalid choice, try again"
+            end
+
+            #print "\r\e[A\e[K\r" + prompt
+            print prompt
+        end
+    end
+
+    def get_video_choice
+        prompt = "Select stream number to watch: ".bold
+        print prompt
+        offset = 0
+        streamer_offset = Hash.new{0}
+        loop do
+            response = $stdin.gets.chomp
+
+            break if response.downcase == "q"
+            if response == ":n" or response == ":next"
+                puts "Getting next page".bold
+                streamer_count = @archives.drop(offset).take(@options.limit).group_by{|v| v.channel.name}.map{|k,v| [k, v.size]}
+                offset += @options.limit
+                streamer_count.each do |s, o|
+                    streamer_offset[s] += o
+                    if streamer_offset[s] + @options.limit > @archive_count[s]
+                        @archives += TwitchAPI.get_videos(
+                            s, limit: o, offset: streamer_offset[s]
+                        )
+                        @archive_count[s] += o
+                    end
+                end
+                puts_streams(offset: offset)
+                print prompt
+                next
+            end
+
+            if response == ":b" or response == ":back"
+                puts "Getting previous page".bold
+                streamer_count = @archives.drop(offset).take(@options.limit).group_by{|v| v.channel.name}.map{|k,v| [k, v.size]}
+                streamer_count.each do |s, o|
+                    streamer_offset[s] -= o
+                    streamer_offset[s] = 0 if streamer_offset[s] < 0
+                end
+                offset -= @options.limit
+                offset = 0 if offset < 0
+                puts_streams(offset: offset)
+                print prompt
+                next
+            end
+
+            choice = Integer(response) rescue nil
+            if choice && 0 < choice && choice <= 20
+                stream = @archives[offset + choice - 1]
+                launch_video(stream.url)
+            else
+                print "Invalid choice, try again"
+            end
+
+            print "\r\e[A\e[K\r" + prompt
+        end
+    end
+
+    def launch_stream(streamer, quality)
+        opts = @options.dup
+        opts.quality = quality
+        Livestreamer.start_stream(
+            streamer, @options.player, @options.quality, @options.chat
+        )
+    end
+
+    def launch_video(url)
+        Livestreamer.start_video(url, @options.player)
+    end
+
+    def format_time(seconds)
+        s = seconds % 60
+        minutes = seconds / 60
+        m = minutes % 60
+        h = minutes / 60
+        if h > 0
+            "%d:%02d:%02d" % [h,m,s]
+        else
+            "%d:%02d" % [m,s]
+        end
+    end
+end
+

data/twitchy.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |s|
+  s.name        = 'twitchy'
+  s.version     = '0.1.1'
+  s.date        = '2014-02-11'
+  s.summary     = "A Ruby wrapper around livestreamer"
+  s.description = "Twitchy provides for a system to query the TwitchAPI "\
+                  "for use with livestreamer. List online channels, "\
+                  "archived videos, and more."
+  s.authors     = ["blkbsstt"]
+  s.email       = 'blkbsstt+twitchy@gmail.com'
+  s.executables << 'twitchy'
+  s.files       = [
+      "README.md",
+      "twitchy.gemspec",
+      "lib/twitchy/twitchy.rb",
+      "lib/twitchy/livestreamer.rb",
+      "lib/twitchy/dstruct.rb",
+      "lib/twitchy/twitch_api.rb",
+      "bin/twitchy"
+  ]
+  s.add_runtime_dependency "colorize", "~> 0.6"
+  s.homepage    = 'http://www.github.com/blkbsstt/twitchy'
+  s.license     = 'MIT'
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: twitchy
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- blkbsstt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: Twitchy provides for a system to query the TwitchAPI for use with livestreamer.
+  List online channels, archived videos, and more.
+email: blkbsstt+twitchy@gmail.com
+executables:
+- twitchy
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/twitchy
+- lib/twitchy/dstruct.rb
+- lib/twitchy/livestreamer.rb
+- lib/twitchy/twitch_api.rb
+- lib/twitchy/twitchy.rb
+- twitchy.gemspec
+homepage: http://www.github.com/blkbsstt/twitchy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A Ruby wrapper around livestreamer
+test_files: []