lib.py

   1 # -*- coding: utf-8 -*-
   2
   3 import codecs
   4
   5 from twython import Twython
   6 import twitter_text
   7 from ConfigParser import SafeConfigParser
   8 import MySQLdb
   9 from jinja2 import Environment, FileSystemLoader
  10
  11 class ReadNewTweets:
  12
  13     """We use the Twython module to issue a GET statuses/user_timeline
  14     request. The tweets of the response are returned by the method
  15     read_user_timeline as list of Unicode strings.
  16
  17     These are some API 1.1 docs about the GET statuses/user_timeline requests:
  18     https://dev.twitter.com/docs/api/1.1/get/statuses/user_timeline
  19
  20     In our tests we found that OAUTH authentication is a prerequisite for GET
  21     statuses/timeline requests. The Twython docs are vague about this, cf the
  22     comments of the get_user_timeline.py example: "We won't authenticate for
  23     this, but sometimes it's necessary"
  24     https://raw.github.com/ryanmcgrath/twython/master/core_examples/get_user_timeline.py
  25
  26     This class expects three arguments:
  27     1. The location of a configuration file with the necessary data for
  28     authentication. We use ConfigParser to read the configuration file. See
  29     config.sample.ini file.
  30     2. A twitter screen_name: "The screen name of the user for whom to return
  31     results for"
  32     3. A GET statuses/user_timeline count parameter: "Specifies the number of
  33     tweets to try and retrieve [...]".
  34
  35     At the moment, the HTML jinja2 template expects 70 tweets. Argument #3 may
  36     be overkill...
  37
  38     """
  39
  40     def __init__(self, config_file, screen_name, count):
  41         """config_file is a string and should point to a configuration file
  42         with the necessary credentials for OAUTH. We use ConfigParser to read
  43         the configuration file.
  44
  45         screen_name is a string and corresponds to the user whose timeline we
  46         will read.
  47
  48         count is an integer and corresponds to the number of tweets we will
  49         read.
  50
  51         """
  52         self.config_file = config_file
  53         self.screen_name = screen_name
  54         self.count = count
  55
  56     def read_config_file(self):
  57         """We use ConfigParser to read the configuration file with the
  58         necessary credentials for OAUTH.
  59
  60         """
  61         parser = SafeConfigParser()
  62         parser.read('config.ini')
  63
  64         self.app_key = parser.get('Twitter_OAUTH', 'app_key')
  65         self.app_secret = parser.get('Twitter_OAUTH', 'app_secret')
  66         self.oauth_token = parser.get('Twitter_OAUTH', 'oauth_token')
  67         self.oauth_token_secret = parser.get('Twitter_OAUTH', 'oauth_token_secret')
  68
  69     def read_user_timeline(self):
  70         """We connect to twitter, and issue a GET statuses/user_timeline
  71         request with self.screen_name and self.count parameters.
  72
  73         A response's u'text' field corresponds to a "tweet".  See the API 1.1
  74         docs for a map of a typical response:
  75         https://dev.twitter.com/docs/api/1.1/get/statuses/user_timeline
  76
  77         This method's return value is some tweets packaged as list of Unicode
  78         strings.
  79
  80         """
  81         twitter = Twython(app_key=self.app_key, app_secret=self.app_secret,
  82                 oauth_token=self.oauth_token,
  83                 oauth_token_secret=self.oauth_token_secret)
  84
  85         tweets = twitter.getUserTimeline(screen_name=self.screen_name, count=self.count)
  86
  87         list_of_tweets = []
  88         for tweet in tweets:
  89             list_of_tweets.append(tweet[u'text'])
  90
  91         return list_of_tweets
  92
  93 class WriteNewTweetsToDB:
  94
  95     """We write some tweets to a database.
  96
  97     This class expects two arguments:
  98     1. The location of a configuration file with the usual MySQL connection
  99     stuff (host, user, pwd, db name). We use ConfigParser to read the
 100     configuration file. See config.sample.ini file.
 101     2. A list of some tweets as say returned by the read_user_timeline method
 102     of ReadNewTweets. The read_user_timeline method returns a list of Unicode
 103     type instances, Unicode strings, u'☺☻'
 104
 105     The list_of_tweets strings will be written to the database of the
 106     configuration file.
 107
 108     This class is not really Twitter-dependent and the strings of Argument #2
 109     could be anything...
 110
 111     """
 112
 113     def __init__(self, config_file, list_of_tweets):
 114         """config_file is a string and should point to a configuration file
 115         with the usual MySQL connection stuff. See config.sample.ini file...
 116
 117         We use ConfigParser to read the configuration file.
 118
 119         list_of_tweets is a list as say generated by the read_user_timeline
 120         method of the ReadNewTweets class.
 121
 122         """
 123         self.config_file = config_file
 124         self.list_of_tweets = list_of_tweets
 125
 126     def read_config_file(self):
 127         """We use ConfigParser to fetch the usual MySQL connection stuff"""
 128         parser = SafeConfigParser()
 129         parser.read(self.config_file)
 130
 131         self.db_host = parser.get('MySQL', 'host')
 132         self.db_user = parser.get('MySQL', 'user')
 133         self.db_password = parser.get('MySQL', 'password')
 134         self.db_database = parser.get('MySQL', 'database')
 135
 136     def write_tweets_to_db(self):
 137         """We write some tweets to the database.
 138
 139         We loop over the self.list_of_tweets list, and write each tweet to the
 140         database.
 141
 142         For the Unicode tweaks, we read the following:
 143         http://dev.mysql.com/doc/refman/5.0/en/charset-applications.html
 144         http://stackoverflow.com/questions/8365660/python-mysql-unicode-and-encoding
 145
 146         """
 147         connection = MySQLdb.connect(host = self.db_host,
 148                 user = self.db_user,
 149                 passwd = self.db_password,
 150                 db = self.db_database,
 151                 charset = 'utf8',
 152                 use_unicode = True)
 153
 154         cursor = connection.cursor()
 155         sql_statement = "CREATE TABLE IF NOT EXISTS tweets (Id INT PRIMARY KEY AUTO_INCREMENT, tweet VARCHAR(140))"
 156         cursor.execute(sql_statement)
 157
 158         for tweet in self.list_of_tweets:
 159             cursor.execute('INSERT INTO tweets(tweet) VALUES(%s)', (tweet,))
 160
 161 class ReadTweetsFromDB:
 162
 163     """We read some tweets from a database and return a list of tweets.
 164
 165     This class expects one argument:
 166     1. The location of a configuration file with the usual MySQL connection
 167     stuff (host, user, pwd, db name). We use ConfigParser to read the
 168     configuration file. See config.sample.ini file.
 169
 170     The database has been created by say the write_tweets_to_db method of the
 171     WriteTweetsToDB class.
 172
 173     The read_tweets_from_db method returns a list of tweets...
 174
 175     """
 176
 177     def __init__(self, config_file):
 178         """config_file is a string and should point to a configuration file
 179         with the usual MySQL connection stuff. See config.sample.ini file...
 180
 181         We use ConfigParser to read the configuration file.
 182         """
 183         self.config_file = config_file
 184
 185     def read_config_file(self):
 186         """We use ConfigParser to fetch the usual MySQL connection stuff"""
 187         parser = SafeConfigParser()
 188         parser.read(self.config_file)
 189
 190         self.db_host = parser.get('MySQL', 'host')
 191         self.db_user = parser.get('MySQL', 'user')
 192         self.db_password = parser.get('MySQL', 'password')
 193         self.db_database = parser.get('MySQL', 'database')
 194
 195     def read_tweets_from_db(self):
 196         """We connect to the database and retrieve some tweets.
 197
 198         This method's return value is some tweets packaged as list of Unicode
 199         strings.
 200
 201         """
 202         connection = MySQLdb.connect(host = self.db_host,
 203                 user = self.db_user,
 204                 passwd = self.db_password,
 205                 db = self.db_database,
 206                 charset = 'utf8',
 207                 use_unicode = True)
 208
 209         cursor = connection.cursor()
 210         cursor.execute("SELECT * FROM tweets")
 211
 212         tweets = cursor.fetchall()
 213         list_of_tweets = []
 214         for row in tweets:
 215             list_of_tweets.append(row[1])
 216
 217         return list_of_tweets
 218
 219 class WriteTweetsToHTMLFile:
 220
 221     """We display some tweets on a HTML file via Jinja templating.
 222
 223     This class expects four arguments:
 224     1. A string that points to a location in the file system where Jinja
 225     templates are stored. We use the "FileSystemLoader" Jinja loader. The
 226     Jinja documentation says: "The loader takes the path to the templates as
 227     string" http://jinja.pocoo.org/docs/api/#jinja2.FileSystemLoader
 228     2. A string that points to a Jinja template file in the location specified
 229     by Argument #1.
 230     3. A list of some tweets as say returned by the read_tweets_from_db method
 231     of ReadTweetsFromDB. The read_user_timeline method returns a list of Unicode
 232     type instances, Unicode strings, u'☺☻'. FWIW read_user_timeline of
 233     ReadNewTweets returns the same type of tweet lists...
 234     4. A string that points to a location in the file system where we can
 235     store our HTML.
 236
 237     """
 238
 239     def __init__(self, template_search_path, template_name, list_of_tweets,
 240             html_file):
 241         """template_search_path is a Jinja templates folder; and template_name
 242         is a template therein.
 243
 244         list_of_tweets is our list of tweets
 245
 246         If it doesn't exist already, the file html_file will be created and
 247         our Jinja-generated HTML will be written to it.
 248         """
 249
 250         self.template_search_path = template_search_path
 251         self.template_name = template_name
 252         self.list_of_tweets = list_of_tweets
 253         self.html_file = html_file
 254
 255     def autolink_list_of_tweets(self):
 256         """We auto link the plain text aspects of tweets. See "Twitter text
 257         conformance":
 258         https://github.com/twitter/twitter-text-conformance
 259
 260         We use the twitter-text-py module:
 261         pip install twitter-text-py
 262
 263         We need to do this in order to render the tweets on the browser...
 264         """
 265
 266         self.list_of_tweets_autolinked = []
 267         for tweet in self.list_of_tweets:
 268             my_autolink = twitter_text.Autolink(tweet)
 269             self.list_of_tweets_autolinked.append(my_autolink.auto_link())
 270
 271     def write_html_file(self):
 272         """We write the autolinked tweets to a HTML file via Jinja templating.
 273
 274         The HTML will be written to a new file. The new file's name is
 275         self.html_file
 276
 277         We pass the list_of_tweets_autolinked list to Jinja's render() method
 278         for templates.
 279
 280         See also our Jinja template: template.html
 281         """
 282
 283         env = Environment(loader=FileSystemLoader(self.template_search_path))
 284         template = env.get_template(self.template_name)
 285         f = codecs.open(self.html_file, mode="w", encoding='utf-8')
 286         f.write(template.render(list_of_tweets=self.list_of_tweets_autolinked))