chatterbot 0.2.0

data/examples/config.yml.example

@@ -0,0 +1,6 @@
+---
+:consumer_secret: CONSUMER SECRET GOES HERE. THIS IS YOUR TWITTER API SECRET
+:consumer_key: CONSUMER KEY GOES HERE. THIS IS YOUR TWITTER API KEY
+:secret: SECRET GOES HERE. YOU GET THIS AFTER AUTHORIZING THE BOT
+:token: TOKEN GOES HERE. YOU GET THIS AFTER AUTHORIZING THE BOT
+:since_id: 1234567

data/examples/dsl_test.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'chatterbot/dsl'
+
+exclude ["foo", "bar"]
+search("foo") do |tweet|
+# #  reply "@#{tweet['from_user']} I am serious, and don't call me Shirley!", tweet
+  puts tweet.inspect
+end

data/examples/echoes_bot.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+
+#
+# require the dsl lib to include all the methods you see below.
+#
+require 'chatterbot/dsl'
+
+puts "Loading echoes_bot.rb"
+
+##
+## If I wanted to exclude some terms from triggering this bot, I would list them here.
+## For now, we'll block URLs to keep this from being a source of spam
+##
+exclude "http://"
+
+blacklist "mean_user, private_user"
+
+puts "checking for replies to me"
+replies do |tweet|
+  
+  # replace the incoming username with the handle of the user who tweeted us
+  src = tweet[:text].gsub(/@echoes_bot/, tweet_user(tweet))
+
+  # send it back!
+  reply src, tweet
+end

data/lib/chatterbot.rb

@@ -0,0 +1,50 @@
+require 'yaml'
+require 'twitter_oauth'
+
+#
+# Try and load Sequel, but don't freak out if it's not there
+begin
+  require 'sequel'
+rescue Exception
+end
+
+
+#
+# extend Hash class to turn keys into symbols
+#
+class Hash
+  #
+  # turn keys in this hash into symbols
+  def symbolize_keys!
+    replace(inject({}) do |hash,(key,value)|
+      hash[key.to_sym] = value.is_a?(Hash) ? value.symbolize_keys! : value
+      hash
+    end)
+  end
+end
+
+#
+# the big kahuna!
+module Chatterbot
+
+  #
+  # load in our assorted modules
+  def self.load
+    require "chatterbot/config"
+    require "chatterbot/db"
+    require "chatterbot/logging"
+    require "chatterbot/blacklist"
+    require "chatterbot/client"
+    require "chatterbot/search"
+    require "chatterbot/tweet"
+    require "chatterbot/reply"
+    require "chatterbot/helpers"    
+
+    require "chatterbot/bot"
+  end
+end
+
+
+# mount up
+Chatterbot.load
+

data/lib/chatterbot/blacklist.rb

@@ -0,0 +1,69 @@
+module Chatterbot
+
+  #
+  # methods for preventing the bot from spamming people who don't want to hear from it
+  module Blacklist
+    attr_accessor :exclude, :blacklist
+
+    # return a list of text strings which we will check for in incoming tweets.
+    # If the text is listed, we won't use this tweet
+    def exclude
+      @exclude || []
+    end
+    
+    # A list of Twitter users that don't want to hear from the bot.
+    def blacklist
+      @blacklist || []
+    end
+    def blacklist=(b)
+      @blacklist = b
+    end
+    
+    #
+    # Based on the text of this tweet, should it be skipped?
+    def skip_me?(s)
+      search = s.is_a?(Hash) ? s[:text] : s
+      exclude.detect { |e| search.downcase.include?(e) } != nil
+    end
+
+    #
+    # Pull the username from a tweet hash -- this is different depending on
+    # if we're doing a search, or parsing through replies/mentions.
+    def tweet_user(s)
+      s.has_key?(:from_user) ? s[:from_user] : s[:user][:screen_name]
+    end
+    
+    #
+    # Is this tweet from a user on our blacklist?
+    def on_blacklist?(s)
+      search = (s.is_a?(Hash) ? tweet_user(s) : s).downcase
+      blacklist.any? { |b| search.include?(b.downcase) } ||
+        on_global_blacklist?(search)
+    end
+
+    #
+    # Is this user on our global blacklist?
+    def on_global_blacklist?(user)
+      return false if ! has_db?
+      db[:blacklist].where(:user => user).count > 0
+    end
+
+    #
+    # add the specified user to the global blacklist
+    def add_to_blacklist(user)    
+      user = user.is_a?(Hash) ? user[:from_user] : user
+      
+      # don't try and add if we don't have a DB connection, or if the
+      # user is already on the list
+      return if ! has_db? || on_global_blacklist?(user)
+
+      # make sure we don't have an @ at the beginning of the username
+      user.gsub!(/^@/, "")
+
+      debug "adding #{user} to blacklist"
+
+      db[:blacklist].insert({ :user => user, :created_at => Time.now }) # 
+    end
+    
+  end
+end

data/lib/chatterbot/bot.rb

@@ -0,0 +1,29 @@
+module Chatterbot
+
+  #
+  # primary Bot object, includes all the other modules
+  class Bot
+    include Blacklist
+    include Config
+    include Logging
+    include Search
+    include Tweet
+    include Reply
+    include Client
+    include DB
+    include Helpers
+
+    #
+    # Create a new bot. No options for now.
+    def initialize(params={})
+      @config = load_config(params)
+      
+      # update config when we exit
+      at_exit do
+        raise $! if $!
+        update_config
+      end   
+    end
+    
+  end
+end

data/lib/chatterbot/client.rb

@@ -0,0 +1,123 @@
+module Chatterbot
+  
+  #
+  # routines for connecting to Twitter and validating the bot
+  module Client
+
+    # the Twitter client
+    attr_accessor :client
+
+    #
+    # default options when querying twitter -- this could be extended
+    # with a language, etc.
+    def default_opts
+      {
+        :since_id => since_id
+      }
+    end
+    
+
+    #
+    # Initialize the Twitter client
+    def init_client
+      @client ||= TwitterOAuth::Client.new(client_params)
+    end
+    
+    #
+    # Re-initialize with Twitter, handy during the auth process
+    def reset_client
+      @client = nil
+      init_client
+    end
+    
+    #
+    # Call this before doing anything that requires an authorized Twitter
+    # connection.
+    def require_login
+      init_client
+      login
+    end
+
+    #
+    # print out a message about getting a PIN from twitter, then output
+    # the URL the user needs to visit to authorize
+    #
+    def get_oauth_verifier(request_token)
+      puts "Please go to the following URL and authorize the bot.\n"        
+      puts "#{request_token.authorize_url}\n"
+
+      puts "Paste your PIN and hit enter when you have completed authorization."
+      STDIN.readline.chomp
+    end
+
+    #
+    # Ask the user to get an API key from Twitter.
+    def get_api_key
+      puts "****************************************"
+      puts "****************************************"
+      puts "****        API SETUP TIME!         ****"
+      puts "****************************************"
+      puts "****************************************"      
+      
+      puts "Hey, looks like you need to get an API key from Twitter before you can get started."
+      puts "Please go to this URL: https://twitter.com/apps/new"
+
+      puts "\nChoose 'Client' as the app type."
+      puts "Choose 'Read & Write' access."
+
+      print "\n\n\nPaste the 'Consumer Key' here: "
+      STDOUT.flush
+      config[:consumer_key] = STDIN.readline.chomp
+
+      print "Paste the 'Consumer Secret' here: "
+      STDOUT.flush
+      config[:consumer_secret] = STDIN.readline.chomp
+      
+      reset_client
+      
+      #
+      # capture ctrl-c and exit without a stack trace
+      #
+    rescue Interrupt => e
+#      exit
+    end
+
+    #
+    # error message for auth
+    def display_oauth_error
+      debug "Oops!  Looks like something went wrong there, please try again!"
+#      exit
+    end
+    
+    #
+    # handle oauth for this request.  if the client isn't authorized, print
+    # out the auth URL and get a pin code back from the user
+    def login
+      if needs_api_key?
+        get_api_key
+      end
+
+      if needs_auth_token?
+        request_token = client.request_token
+
+        pin = get_oauth_verifier(request_token)
+        access_token = client.authorize(
+                                         request_token.token,
+                                         request_token.secret,
+                                         :oauth_verifier => pin
+                                         )
+
+        if client.authorized?
+          config[:token] = access_token.token
+          config[:secret] = access_token.secret
+          update_config
+        else
+          display_oauth_error
+          return false
+        end
+      end
+
+      true
+    end
+  end
+end

data/lib/chatterbot/config.rb

@@ -0,0 +1,259 @@
+module Chatterbot
+
+  #
+  # routines for storing config information for the bot
+  module Config  
+    attr_accessor :config
+    
+    #
+    # the entire config for the bot, loaded from YAML files and the DB if applicable
+    def config
+      @config ||= load_config
+    end   
+
+    #
+    # has the config been loaded yet?
+    def has_config?
+      ! @config.nil?
+    end   
+
+    #
+    # should we log tweets to the database?
+    def log_tweets?
+      config.has_key?(:db_uri)
+    end
+
+    #
+    # Check to see if Sequel was loaded successfully.  If not, we won't make any DB calls
+    def has_sequel?
+      ! defined?(Sequel).nil?
+    end
+    
+    #
+    # do we have a DB connection string?
+    def has_db?
+      has_sequel? && config.has_key?(:db_uri)
+    end
+
+    #
+    # are we in debug mode?
+    def debug_mode?
+      config[:debug_mode] || false
+    end
+
+    #
+    # Should we run any config updates?
+    def update_config?
+      config[:dry_run] || true
+    end
+
+    #
+    # should we write to a log file?
+    def logging?
+      has_config? && config.has_key?(:log_dest)
+    end
+
+    #
+    # destination for log entries
+    def log_dest
+      config[:log_dest]
+    end
+
+    #
+    # store since_id to a different key so that it doesn't actually
+    # get updated until the bot is done running
+    def since_id=(x)
+      config[:tmp_since_id] = x
+    end
+
+    #
+    # return the ID of the most recent tweet pulled up in searches
+    def since_id
+      config[:since_id] || 1
+    end   
+
+    #
+    # write out our config file
+    def update_config
+      return if ! update_config?
+
+      # don't update flat file if we can store to the DB instead
+      if has_db?
+        store_database_config
+      else
+        store_local_config
+      end
+    end
+
+    #
+    # update the since_id with either the highest ID of the specified
+    # tweets, unless it is lower than what we have already
+    def update_since_id(search)
+      unless search.nil?
+        tmp_id = case
+                   # incoming tweets
+                 when search.has_key?(:id) then search[:id]
+                   
+                   # incoming searches
+                 when search.has_key?("max_id") then search["max_id"]
+
+                   # other?
+                 else 1
+                 end.to_i
+        config[:tmp_since_id] = [config[:tmp_since_id].to_i, tmp_id].max        
+      end
+    end
+
+    #
+    # return a hash of the params we need to connect to the Twitter API
+    def client_params
+      { 
+        :consumer_key => config[:consumer_key],
+        :consumer_secret => config[:consumer_secret],
+        :token => config[:token].nil? ? nil : config[:token],
+        :secret => config[:secret].nil? ? nil : config[:secret]
+      }
+    end
+
+    #
+    # do we have an API key specified?
+    def needs_api_key?
+      config[:consumer_key].nil? || config[:consumer_secret].nil?
+    end
+
+    #
+    # has this script validated with Twitter OAuth?
+    def needs_auth_token?
+      config[:token].nil?
+    end
+
+    #
+    # figure out what config file to load based on the name of the bot
+    def config_file
+      File.join(File.expand_path(File.dirname($0)), "#{botname}.yml")
+    end
+
+    #
+    # load in a config file
+    def slurp_file(f)
+      f = File.expand_path(f)
+
+      tmp = {}
+
+      if File.exist?(f)
+        File.open( f ) { |yf| 
+          tmp = YAML::load( yf ) 
+        }
+      end
+      tmp.symbolize_keys! unless tmp == false
+    end
+
+    #
+    # our list of "global config files"
+    def global_config_files
+      [
+       # a system-wide global path
+       "/etc/chatterbot.yml",
+       
+       # a file specified in ENV
+       ENV["chatterbot_config"],
+       
+       # 'global' config file local to the path of the ruby script
+       File.join(File.dirname(File.expand_path($0)), "global.yml")
+      ].compact
+    end
+
+    #
+    # get any config from our global config files
+    def global_config
+      tmp = {}
+      global_config_files.each { |f|
+        tmp.merge!(slurp_file(f) || {})      
+      }
+      tmp
+    end
+
+    #
+    # bot-specific config settings
+    def bot_config
+      slurp_file(config_file) || { }
+    end
+
+    #
+    # load the config settings from the db, if possible
+    def db_config
+      return {} if db.nil?
+      db[:config][:id => botname]
+    end
+
+    #
+    # figure out what we should save to the local config file.  we don't
+    # save anything that exists in the global config, unless it's been modified
+    # for this particular bot.
+    def config_to_save
+      # remove keys that are duped in the global config
+      tmp = config.delete_if { |k, v| global_config.has_key?(k) && global_config[k] == config[k] }
+
+      # let's not store these, they're just command-line options
+      tmp.delete(:debug_mode)
+      tmp.delete(:dry_run)
+
+      
+      # update the since_id now
+      tmp[:since_id] = tmp.delete(:tmp_since_id) unless ! tmp.has_key?(:tmp_since_id)
+
+      tmp
+    end
+    
+    
+    #
+    # load in the config from the assortment of places it can be specified.
+    def load_config(params={})
+      # load the flat-files first
+      @config  = global_config.merge(bot_config).merge(params)
+      @config[:db_uri] ||= ENV["chatterbot_db"] unless ENV["chatterbot_db"].nil?
+
+      # if we have a key to load from the DB, do that now
+      if @config.has_key?(:db_uri) && @config[:db_uri]
+        tmp = db_config
+        @config = @config.merge(tmp) unless tmp.nil?
+      end
+      @config
+    end
+
+    #
+    # write out the config file for this bot
+    def store_local_config
+      File.open(config_file, 'w') { |f| YAML.dump(config_to_save, f) }
+    end
+
+    #
+    # store config settings in the database, if possible
+    def store_database_config
+      return false if db.nil?
+
+      configs = db[:config]
+      data = {
+        :since_id => config[:since_id],
+        :token => config[:token],
+        :secret => config[:secret],
+        :consumer_secret => config[:consumer_secret],
+        :consumer_key => config[:consumer_key],
+        :updated_at => Time.now #:NOW.sql_function
+      }
+
+      row = configs.filter('id = ?', botname)
+
+      if row.count > 0
+        row.update(data)
+      else
+        data[:id] = botname
+        data[:created_at] = Time.now #:NOW.sql_function
+        configs.insert data
+      end
+      
+      true
+    end
+
+  end
+end