tweet_watch 0.1.0 → 0.2.1.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1cf0ec161d2977390ad7ea92acc576b99c868a76
-  data.tar.gz: 92ab838aecde143611dc953925ff4ba0ce1d4183
+  metadata.gz: d74bc0d2d02588fbfac1ef6b5531997844e8e350
+  data.tar.gz: bddd89e90b54464df74c7d07b3c3a186f56affa6
 SHA512:
-  metadata.gz: 1677ab58dbb77b18a7479cbdbef2c6ce6e4b2ff9fe25147f04385421fe6642bea09aaac5e5128bdeb7b47cdedb81645de052468a09230327e12ab64e0f05e5c7
-  data.tar.gz: 50c0d295f4980e36ad4199c96522dfd040bcef9acba2d03fe52fd55d66a94c0fa04cb5f9ac2b95475ab65739a4df254ed96fe41d769ccfb622ec7dc30b1ca069
+  metadata.gz: 4ab9c6739f914f3d8b0d319953e7fb481c159da299bdd30616b8c359cc7489b8abbc97e02a2c3f67c3dd425b80630fdcfd18c39643f54375d82bd15ed769d5e7
+  data.tar.gz: facc27d954fc5773c5531777a4b5b74bdf1a761fada7a270401244a7f282a6b312662ea36c4c79a48a864b6faedd2dff17cb88e966c1c7119d298abcf71d4fb5

data/.gitignore

@@ -7,3 +7,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+*.csv
+config-real.yml

data/config.yml

@@ -1,15 +1,26 @@
-credentials:
-  consumer_key: jKgFRB9dossgVmyRB1P4Wm5J7CN
-  consumer_secret: oMswt4MMBJxrta3fQ27JkmbuLfHMvkZKrlSpIcT8AdmubJcSjlpT
-
-users:
+# Configure all the accounts you want to track.
+# You can go to dev https://apps.twitter.com/ to 
+# create an app.  This will get you credentials.
+# You then have to go into the app to generate access
+# tokens.
+#
+# Add multiple accounts here and pass -u command to 
+# select the tracking user
+accounts:
   - screen_name: ajoabraham
-    access_token: 17609705-Fd9WcmbEEFFftfasEwxxFvF1FOgtZ1S4E1YNnj0XcPyc  
-    access_token_secret: VIge9jyWlz9k9qe0jVaaK3gHoSwqMlgsi0cRZwZEYpWXu6G
+    access_token: YOUR_ACCESS_TOKEN 
+    access_token_secret: YOUR_ACCESS_TOKEN_SECRET
+    consumer_key: YOUR_CONSUMER_KEY
+    consumer_secret: YOUR_CONSUMER_SECRET
   - screen_name: lodr_io
-    access_token: 797120884146311169asdf-OggIoXEHI1SqnTDuKmp87HSd3O22bw4
-    access_token_secret: Zsl1Pbl7snrmjwfdsv7q2cZpVTAeYCjzDlu3C4k2eEtWMxh1
+    access_token: YOUR_ACCESS_TOKEN 
+    access_token_secret: YOUR_ACCESS_TOKEN_SECRET
+    consumer_key: YOUR_CONSUMER_KEY
+    consumer_secret: YOUR_CONSUMER_SECRET
  
+# When using the watch command you can choose
+# tweets from cerntail users to be recorded as CSV
+# The following tweeters will be recorded
 tweeters:
  - scottadamsays
  - jaketapper

data/exe/tweet_watch

@@ -2,4 +2,8 @@
 
 require 'tweet_watch'
 
-TweetWatch::CLI.start(ARGV)
+begin
+  TweetWatch::CLI.start(ARGV)
+rescue Interrupt
+  puts "\nExiting..."
+end

data/lib/tweet_watch/account.rb

@@ -0,0 +1,20 @@
+module TweetWatch
+  
+  class Account
+    attr_accessor :screen_name, :access_token, :access_token_secret,
+                  :consumer_key, :consumer_secret
+    
+    def initialize(screen_name, consumer_key, 
+                    consumer_secret, access_token, 
+                    access_token_secret)
+                    
+      @screen_name = screen_name
+      @consumer_key = consumer_key
+      @consumer_secret = consumer_secret
+      @access_token = access_token
+      @access_token_secret = access_token_secret      
+    end
+    
+  end
+  
+end

data/lib/tweet_watch/cli.rb

@@ -1,19 +1,22 @@
+require 'colorize'
+
 module TweetWatch
-  
-  def self.print_tweet(tw)
-      puts "\n---"
-      puts "from: @#{tw.user.screen_name}"
-      puts tw.text
-      puts "created #{Time.now - tw.created_at} seconds ago \n"
-  end
-  
+    
   class CLI < Thor
     include Client
+    include Utils
+    
+    class_option :screen_name, aliases: "-u", 
+            desc: "The screename of the account. If not included, will select the first account from the config file."
+    class_option :config_file, aliases: "-c",  required: true,
+                    desc: "Yaml config file path"
+    
           
     desc "limits", "Print out the current rate limits"
     def limits
+      load_config(options)
       resp = Twitter::REST::Request.new(client, 'get', "/1.1/application/rate_limit_status.json" ).perform
-      puts resp.inspect
+      
       current_time = Time.now.to_i
       template = "   %-40s %5d remaining, resets in %3d seconds\n"
       resp.body[:resources].each do |category,resources|
@@ -24,46 +27,73 @@ module TweetWatch
       end
     end
     
-    desc "timeline", "Prints out the first users timeline. 20 tweets."
-    option :s, desc: "will stream the first users timeline"
-    option :u, desc: "the screename of the user to authenticate access for"
+    desc "timeline", "Prints out an accounts timeline"
+    option :stream, aliases: "-s", 
+            desc: "Will stream a tweets as they come in instead of printing the latest timeline."
+    option :count, aliases: "-c", default: 50, type: :numeric,
+            desc: "Number of past tweets to print out. Max history is 200"
     def timeline
-      if options[:s]
-        streaming_client(options[:u]).user do |obj|
+      load_config(options)
+      
+      if options[:stream]
+        sc = streaming_client(options)
+        puts "Starting stream...".colorize(:light_cyan)
+        sc.user do |obj|
           if obj.class == Twitter::Tweet
-            TweetWatch.print_tweet obj
+            print_tweet obj
+          elsif obj.class == Twitter::DirectMessage
+            print_dm obj
           end
         end
       else
-        client(options[:u]).home_timeline.each do |tw|
-          TweetWatch.print_tweet(tw)
+        client(options).home_timeline.each do |tw|
+          print_tweet(tw)
         end
       end 
       
     end    
     
-    desc "watch", "Watches a stream to track tweets from specific tweeters"
-    option :o, desc: "output file - will append if files exists", default: "tweet_watch.csv"
-    option :u, desc: "the screename of the user to authenticate access for"
-    def watch        
-      file = File.open(options[:o], "a+")
+    desc "watch", "Watches a stream and records tweets. Filter which tweets are recorded by providing a tweeters list."
+    option :output, aliases: "-o", 
+            desc: "output file - will append if files exists", default: "tweet_watch.csv"
+    option :tweeters, aliases: "-t", type: :array,
+            desc: "list of tweeters to filter recorded tweets by"
+    option :tweeters_only, aliases: "-f",
+            desc: "only prints to screen provided list of tweeters"
+    def watch
+      load_config(options)
+              
+      sc = streaming_client(options)
+      file = File.open(options[:output], "a+")
       tw_config = TweetWatch.config
       
+      tweeters = options[:tweeters] ? options[:tweeters] : tw_config.tweeters
+      
       unless file.size > 0
         file.puts "timelined_at, tweet_id, screen_name, text, tweet_created_at, is_reply, is_quote"
       end
-      
-      streaming_client(options[:u]).user do |obj|
+            
+      puts "Starting stream...".colorize(:light_cyan)
+      sc.user do |obj|
         time = Time.now
-        if obj.class == Twitter::Tweet
-          TweetWatch.print_tweet obj
-          
-          if tw_config.tweeters.include?(obj.user.screen_name)
-            puts "recording tweet data"            
-            file.puts "\"#{time.utc}\", \"#{obj.id}\", \"#{obj.user.screen_name}\", \"#{obj.text}\", \"#{obj.created_at.getutc}\",\"#{obj.user.screen_name}\", \"#{obj.reply?}\", \"#{obj.quote?}\""
+        
+        if obj.class == Twitter::Tweet          
+          if options[:tweeters_only].nil? || (options[:tweeters_only] && tweeters.include?(obj.account.screen_name))
+            print_tweet obj
           end
           
+          if tw_config.tweeters.empty? || tweeters.include?(obj.user.screen_name)
+            puts "recording tweet data".colorize(:red)            
+            file.puts "#{time.utc}, #{obj.id}, \"#{escape_str(obj.user.screen_name)}\", \"#{escape_str(obj.text)}\", #{obj.created_at.getutc},\"#{escape_str(obj.user.screen_name)}\", #{obj.reply?}, #{obj.quote?}"
+          end
+        elsif obj.class == Twitter::DirectMessage
+          print_dm obj
+        elsif obj.class == Twitter::Streaming::StallWarning
+          warn "Falling behind!"
+        else
+          puts "untracked tweet obj #{obj.class}".colorize(color: :black, background: :light_white)
         end
+      
       end
     end
     

data/lib/tweet_watch/client.rb

@@ -1,63 +1,28 @@
 module TweetWatch
   module Client
     
-    def config
-      tw_config = TweetWatch::config
-      
-      unless tw_config.valid?
-        # try to load a local config.yml
-        puts "trying to load config from current directory..."
-        path = 'config.yml'
-        if File.exists?(path)
-          tw_config.load_from_path(path)
-        else
-          raise ArgumentError.new("Invalid configuration: " + tw_config.error_message)
-        end
-      end
-      
-      tw_config
-    end
-    
-    def client(screen_name = nil)
-      tw_config = config
-      user = get_user(screen_name)
+    def client(options)      
+      account = TweetWatch.config.get_account(options[:screen_name])
             
       @client ||= Twitter::REST::Client.new do |config|
-        config.consumer_key        = tw_config.consumer_key
-        config.consumer_secret     = tw_config.consumer_secret
-        config.access_token        = user.access_token
-        config.access_token_secret = user.access_token_secret
+        config.consumer_key        = account.consumer_key
+        config.consumer_secret     = account.consumer_secret
+        config.access_token        = account.access_token
+        config.access_token_secret = account.access_token_secret
       end
     end
     
-    def streaming_client(screen_name = nil)
-      tw_config = config   
-      user = get_user(screen_name)
+    def streaming_client(options)
+      account = TweetWatch.config.get_account(options[:screen_name])
          
       @client ||= Twitter::Streaming::Client.new do |config|
-        config.consumer_key        = tw_config.consumer_key
-        config.consumer_secret     = tw_config.consumer_secret
-        config.access_token        = user.access_token
-        config.access_token_secret = user.access_token_secret
+        config.consumer_key        = account.consumer_key
+        config.consumer_secret     = account.consumer_secret
+        config.access_token        = account.access_token
+        config.access_token_secret = account.access_token_secret
       end
     end
-    
-    def load_config(path)
-      TweetWatch::config.load_from_path(path)
-    end
-    
-    def get_user(screen_name)
-      user = config.users.first
-      
-      unless screen_name.nil?
-        res = config.users.select { |u| u.screen_name.strip() == screen_name.strip() }
-        user = res.first if res.size > 0
-      end
-      
-      return user
-      
-    end
-    
+        
   end
   
 end

data/lib/tweet_watch/config.rb

@@ -1,30 +1,29 @@
 module TweetWatch
   class Config
-    attr_accessor :consumer_key, :consumer_secret, :count, 
-      :users, :tweeters
+    attr_accessor :count, :accounts, :tweeters, :path
     
     attr_reader :error_message
     
     def initialize
-      @users = []
+      @accounts = []
       @tweeters = []
       @count = 50
       @error_message = ""
     end
     
-    def load_from_path(config_path)
-      c = YAML.load_file(config_path)
-      
-      unless c["credentials"].nil?
-        cc = c["credentials"]
-        self.consumer_key = cc["consumer_key"] unless cc["consumer_key"].nil?
-        self.consumer_secret = cc["consumer_secret"] unless cc["consumer_secret"].nil?
-        self.count = cc["count"] unless cc["count"].nil?
+    def load_from_path(path)
+      unless File.exists?(path)
+        raise ArgumentError.new("The provided config file could not be located: #{path}")
       end
+      
+      @path = path
+      c = YAML.load_file(@path)
                   
-      unless c["users"].nil?
-        c["users"].each do |f|
-          self.users << User.new(f["screen_name"], f["access_token"], f["access_token_secret"])
+      unless c["accounts"].nil?
+        c["accounts"].each do |f|
+          self.accounts << Account.new(f["screen_name"], 
+            f["consumer_key"], f["consumer_secret"],
+            f["access_token"], f["access_token_secret"])
         end        
       end
       
@@ -34,19 +33,25 @@ module TweetWatch
         end        
       end
       
-      return c
+      self
     end
     
     def valid?
       @error_message = ""
-      [:consumer_key, :consumer_secret].each do |m|
-        if self.send(m).nil?
-          @error_message += "#{m.to_s.capitalize} is missing \n"
-        end
+      @error_message += "There should be at least one account" if accounts.size ==0
+      @error_message.strip().length == 0
+    end
+    
+    def get_account(screen_name = nil)
+      account = @accounts.first
+      
+      unless screen_name.nil?
+        res = @accounts.select { |u| u.screen_name.strip() == screen_name.strip() }
+        account = res.first if res.size > 0
       end
       
-      @error_message += "There should be at least one user" if users.size ==0
-      @error_message.strip().length == 0
+      return account
+      
     end
     
   end

data/lib/tweet_watch/utils.rb

@@ -0,0 +1,42 @@
+module TweetWatch
+  
+  module Utils
+    def load_config(options)
+      if options[:config_file]
+        TweetWatch.config.load_from_path(options[:config_file])
+      else
+        TweetWatch.config.load_from_path("config.yml")
+      end
+    end
+    
+    def escape_str(str)
+      str2 = str.gsub('"', '\"')
+      str2.gsub(/\\(.)/) do |s|
+        case $1
+        when "n"
+          "\n"
+        when "t"
+          "\t"
+        else
+          $1
+        end
+      end      
+    end  
+    
+    def print_tweet(tw)
+        puts "\n---".colorize(:light_red)
+        puts "#{tw.user.name} (@#{tw.user.screen_name})".colorize(:light_yellow) + " FW: #{tw.user.followers_count}".colorize(:green)
+        puts tw.text.colorize(:light_cyan)
+        puts "#{(Time.now - tw.created_at).round(2)} secs ago".colorize(:light_red) +" RT: #{tw.retweet_count} LK: #{tw.favorite_count}\n".colorize(:green)
+    end
+  
+    def print_dm(tw)
+        puts "\nDM --- DM".colorize(color: :light_white, background: :red)
+        puts "#{tw.sender.name} (@#{tw.sender.screen_name})".colorize(color: :light_yellow, background: :red) + " FW: #{tw.sender.followers_count}".colorize(color: :green, background: :red)
+        puts tw.text.colorize(color: :white, background: :red)
+        puts "#{(Time.now - tw.created_at).round(2)} secs ago".colorize(color: :yellow, background: :red)
+    end
+    
+  end
+  
+end

data/lib/tweet_watch/version.rb

@@ -1,3 +1,3 @@
 module TweetWatch
-  VERSION = "0.1.0"
+  VERSION = "0.2.1.pre"
 end

data/lib/tweet_watch.rb

@@ -4,8 +4,9 @@ require 'thor'
 
 require "tweet_watch/version"
 require "tweet_watch/config"
-require "tweet_watch/user"
+require "tweet_watch/account"
 require "tweet_watch/client"
+require "tweet_watch/utils"
 require "tweet_watch/cli"
 
 

data/tweet_watch.gemspec

@@ -35,4 +35,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_dependency "twitter", "~> 6.1"
   spec.add_dependency 'thor'
+  spec.add_dependency 'colorize'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tweet_watch
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1.pre
 platform: ruby
 authors:
 - Ajo Abraham
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-17 00:00:00.000000000 Z
+date: 2017-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: The generated files can be loaded into a database to study twitter behaviour.
 email:
 - abraham.ajo@gmail.com
@@ -100,10 +114,11 @@ files:
 - config.yml
 - exe/tweet_watch
 - lib/tweet_watch.rb
+- lib/tweet_watch/account.rb
 - lib/tweet_watch/cli.rb
 - lib/tweet_watch/client.rb
 - lib/tweet_watch/config.rb
-- lib/tweet_watch/user.rb
+- lib/tweet_watch/utils.rb
 - lib/tweet_watch/version.rb
 - tweet_watch.gemspec
 homepage: http://rubygems.org/gems/tweet_watch
@@ -121,9 +136,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1

data/lib/tweet_watch/user.rb

@@ -1,14 +0,0 @@
-module TweetWatch
-  
-  class User
-    attr_accessor :screen_name, :access_token, :access_token_secret
-    
-    def initialize(screen_name, token, secret)
-      @screen_name = screen_name
-      @access_token = token
-      @access_token_secret = secret      
-    end
-    
-  end
-  
-end