mirror of
https://github.com/MCV-Software/TWBlue.git
synced 2024-11-23 03:38:08 -06:00
562 lines
21 KiB
Python
562 lines
21 KiB
Python
# -*- coding: utf-8 -*-
|
|
""" The main session object. Here are the twitter functions to interact with the "model" of TWBlue."""
|
|
import wx
|
|
import urllib2
|
|
import config
|
|
import twitter
|
|
from keys import keyring
|
|
import session_exceptions as Exceptions
|
|
import paths
|
|
import output
|
|
import time
|
|
import sound
|
|
import logging
|
|
from twitter import utils, compose
|
|
from twython import TwythonError, TwythonRateLimitError, TwythonAuthError
|
|
import config_utils
|
|
import shelve
|
|
import application
|
|
import os
|
|
from mysc.thread_utils import stream_threaded, call_threaded
|
|
from pubsub import pub
|
|
log = logging.getLogger("sessionmanager.session")
|
|
from long_tweets import tweets, twishort
|
|
from wxUI import authorisationDialog
|
|
|
|
sessions = {}
|
|
|
|
class Session(object):
|
|
""" A session object where we will save configuration, the twitter object and a local storage for saving the items retrieved through the Twitter API methods"""
|
|
|
|
# Decorators.
|
|
|
|
def _require_login(fn):
|
|
|
|
""" Decorator for checking if the user is logged in(a twitter object has credentials) on twitter.
|
|
Some functions may need this to avoid making unneeded twitter API calls."""
|
|
|
|
def f(self, *args, **kwargs):
|
|
if self.logged == True:
|
|
fn(self, *args, **kwargs)
|
|
else:
|
|
raise Exceptions.NotLoggedSessionError("You are not logged in yet.")
|
|
return f
|
|
|
|
def _require_configuration(fn):
|
|
|
|
""" Check if the user has a configured session."""
|
|
|
|
def f(self, *args, **kwargs):
|
|
if self.settings != None:
|
|
fn(self, *args, **kwargs)
|
|
else:
|
|
raise Exceptions.NotConfiguredSessionError("Not configured.")
|
|
return f
|
|
|
|
def order_buffer(self, name, data, ignore_older=True):
|
|
|
|
""" Put the new items in the local database.
|
|
name str: The name for the buffer stored in the dictionary.
|
|
data list: A list with tweets.
|
|
returns the number of items that have been added in this execution"""
|
|
|
|
num = 0
|
|
last_id = None
|
|
if self.db.has_key(name) == False:
|
|
self.db[name] = []
|
|
if self.db.has_key("users") == False:
|
|
self.db["users"] = {}
|
|
if ignore_older and len(self.db[name]) > 0:
|
|
if self.settings["general"]["reverse_timelines"] == False:
|
|
last_id = self.db[name][0]["id"]
|
|
else:
|
|
last_id = self.db[name][-1]["id"]
|
|
for i in data:
|
|
if ignore_older and last_id != None:
|
|
if i["id"] < last_id:
|
|
log.error("Ignoring an older tweet... Last id: {0}, tweet id: {1}".format(last_id, i["id"]))
|
|
continue
|
|
if utils.find_item(i["id"], self.db[name]) == None and utils.is_allowed(i, self.settings, name) == True:
|
|
i = self.check_quoted_status(i)
|
|
i = self.check_long_tweet(i)
|
|
if i == False: continue
|
|
if self.settings["general"]["reverse_timelines"] == False: self.db[name].append(i)
|
|
else: self.db[name].insert(0, i)
|
|
num = num+1
|
|
if i.has_key("user") == True:
|
|
if self.db["users"].has_key(i["user"]["id"]) == False:
|
|
self.db["users"][i["user"]["id"]] = i["user"]
|
|
return num
|
|
|
|
def order_cursored_buffer(self, name, data):
|
|
|
|
""" Put the new items on the local database. Useful for cursored buffers (followers, friends, users of a list and searches)
|
|
name str: The name for the buffer stored in the dictionary.
|
|
data list: A list with items and some information about cursors.
|
|
returns the number of items that have been added in this execution"""
|
|
|
|
num = 0
|
|
if self.db.has_key(name) == False:
|
|
self.db[name] = {}
|
|
self.db[name]["items"] = []
|
|
# if len(self.db[name]["items"]) > 0:
|
|
for i in data:
|
|
if utils.find_item(i["id"], self.db[name]["items"]) == None:
|
|
if self.settings["general"]["reverse_timelines"] == False: self.db[name]["items"].append(i)
|
|
else: self.db[name]["items"].insert(0, i)
|
|
num = num+1
|
|
return num
|
|
|
|
def __init__(self, session_id):
|
|
|
|
""" session_id (str): The name of the folder inside the config directory where the session is located."""
|
|
|
|
super(Session, self).__init__()
|
|
self.session_id = session_id
|
|
self.logged = False
|
|
self.settings = None
|
|
self.twitter = twitter.twitter.twitter()
|
|
self.db={}
|
|
self.reconnection_function_active = False
|
|
self.counter = 0
|
|
self.lists = []
|
|
pub.subscribe(self.add_friends, "friends-receibed")
|
|
|
|
@property
|
|
def is_logged(self):
|
|
return self.logged
|
|
|
|
def get_configuration(self):
|
|
|
|
""" Gets settings for a session."""
|
|
|
|
file_ = "%s/session.conf" % (self.session_id,)
|
|
# try:
|
|
log.debug("Creating config file %s" % (file_,))
|
|
self.settings = config_utils.load_config(paths.config_path(file_), paths.app_path("Conf.defaults"))
|
|
self.init_sound()
|
|
self.deshelve()
|
|
# except:
|
|
# log.exception("The session configuration has failed.")
|
|
# self.settings = None
|
|
|
|
def init_sound(self):
|
|
try: self.sound = sound.soundSystem(self.settings["sound"])
|
|
except: pass
|
|
|
|
@_require_configuration
|
|
def login(self, verify_credentials=True):
|
|
|
|
""" Log into twitter using credentials from settings.
|
|
if the user account isn't authorised, it needs to call self.authorise() before login."""
|
|
|
|
if self.settings["twitter"]["user_key"] != None and self.settings["twitter"]["user_secret"] != None:
|
|
try:
|
|
log.debug("Logging in to twitter...")
|
|
self.twitter.login(self.settings["twitter"]["user_key"], self.settings["twitter"]["user_secret"], verify_credentials)
|
|
self.logged = True
|
|
log.debug("Logged.")
|
|
self.counter = 0
|
|
except:
|
|
log.error("The login attempt failed.")
|
|
self.logged = False
|
|
else:
|
|
self.logged = False
|
|
raise Exceptions.RequireCredentialsSessionError
|
|
|
|
@_require_configuration
|
|
def authorise(self):
|
|
|
|
""" Authorises a Twitter account. This function needs to be called for each new session, after self.get_configuration() and before self.login()"""
|
|
|
|
if self.logged == True:
|
|
raise Exceptions.AlreadyAuthorisedError("The authorisation process is not needed at this time.")
|
|
else:
|
|
self.twitter.authorise()
|
|
self.authorisation_dialog = authorisationDialog()
|
|
self.authorisation_dialog.cancel.Bind(wx.EVT_BUTTON, self.authorisation_cancelled)
|
|
self.authorisation_dialog.ok.Bind(wx.EVT_BUTTON, self.authorisation_accepted)
|
|
self.authorisation_dialog.ShowModal()
|
|
|
|
def authorisation_cancelled(self, *args, **kwargs):
|
|
self.authorisation_dialog.Destroy()
|
|
del self.authorisation_dialog
|
|
|
|
def authorisation_accepted(self, *args, **kwargs):
|
|
pincode = self.authorisation_dialog.text.GetValue()
|
|
self.twitter.verify_authorisation(self.settings, pincode)
|
|
self.authorisation_dialog.Destroy()
|
|
|
|
def get_more_items(self, update_function, users=False, dm=False, name=None, *args, **kwargs):
|
|
results = []
|
|
data = getattr(self.twitter.twitter, update_function)(*args, **kwargs)
|
|
if users == True:
|
|
if type(data) == dict and data.has_key("next_cursor"):
|
|
self.db[name]["cursor"] = data["next_cursor"]
|
|
for i in data["users"]: results.append(i)
|
|
elif type(data) == list:
|
|
results.extend(data[1:])
|
|
elif dm == True:
|
|
self.db[name]["cursor"] = data["next_cursor"]
|
|
for i in data["events"]: results.append(i)
|
|
else:
|
|
results.extend(data[1:])
|
|
return results
|
|
|
|
def api_call(self, call_name, action="", _sound=None, report_success=False, report_failure=True, preexec_message="", *args, **kwargs):
|
|
|
|
""" Make a call to the Twitter API. If there is a connectionError or another exception not related to Twitter, It will call the method again at least 25 times, waiting a while between calls. Useful for post methods.
|
|
If twitter returns an error, it will not call the method anymore.
|
|
call_name str: The method to call
|
|
action str: What you are doing on twitter, it will be reported to the user if report_success is set to True.
|
|
for example "following @tw_blue2" will be reported as "following @tw_blue2 succeeded".
|
|
_sound str: a sound to play if the call is executed properly.
|
|
report_success and report_failure bool: These are self explanatory. True or False.
|
|
preexec_message str: A message to speak to the user while the method is running, example: "trying to follow x user"."""
|
|
|
|
finished = False
|
|
tries = 0
|
|
if preexec_message:
|
|
output.speak(preexec_message, True)
|
|
while finished==False and tries < 25:
|
|
try:
|
|
val = getattr(self.twitter.twitter, call_name)(*args, **kwargs)
|
|
finished = True
|
|
except TwythonError as e:
|
|
output.speak(e.message)
|
|
if e.error_code != 403 and e.error_code != 404:
|
|
tries = tries+1
|
|
time.sleep(5)
|
|
elif report_failure and hasattr(e, 'message'):
|
|
output.speak(_("%s failed. Reason: %s") % (action, e.message))
|
|
finished = True
|
|
# except:
|
|
# tries = tries + 1
|
|
# time.sleep(5)
|
|
if report_success:
|
|
output.speak(_("%s succeeded.") % action)
|
|
if _sound != None: self.sound.play(_sound)
|
|
return val
|
|
|
|
def search(self, name, *args, **kwargs):
|
|
tl = self.twitter.twitter.search(*args, **kwargs)
|
|
tl["statuses"].reverse()
|
|
return tl["statuses"]
|
|
|
|
@_require_login
|
|
def get_favourites_timeline(self, name, *args, **kwargs):
|
|
|
|
""" Gets favourites for the authenticated user or a friend or follower.
|
|
name str: Name for storage in the database."""
|
|
|
|
tl = self.call_paged(self.twitter.twitter.get_favorites, *args, **kwargs)
|
|
return self.order_buffer(name, tl)
|
|
|
|
def call_paged(self, update_function, *args, **kwargs):
|
|
|
|
""" Makes a call to the Twitter API methods several times. Useful for get methods.
|
|
this function is needed for retrieving more than 200 items.
|
|
update_function str: The function to call. This function must be child of self.twitter.twitter
|
|
returns a list with all items retrieved."""
|
|
|
|
if application.streaming_lives():
|
|
max = int(self.settings["general"]["max_api_calls"])-1
|
|
else:
|
|
max = 0
|
|
results = []
|
|
data = getattr(self.twitter.twitter, update_function)(count=self.settings["general"]["max_tweets_per_call"], *args, **kwargs)
|
|
results.extend(data)
|
|
for i in range(0, max):
|
|
if i == 0: max_id = results[-1]["id"]
|
|
else: max_id = results[0]["id"]
|
|
data = getattr(self.twitter.twitter, update_function)(max_id=max_id, count=self.settings["general"]["max_tweets_per_call"], *args, **kwargs)
|
|
results.extend(data)
|
|
results.reverse()
|
|
return results
|
|
|
|
@_require_login
|
|
def get_user_info(self):
|
|
|
|
""" Retrieves some information required by TWBlue for setup."""
|
|
f = self.twitter.twitter.get_account_settings()
|
|
sn = f["screen_name"]
|
|
self.settings["twitter"]["user_name"] = sn
|
|
self.db["user_name"] = sn
|
|
self.db["user_id"] = self.twitter.twitter.show_user(screen_name=sn)["id_str"]
|
|
try:
|
|
self.db["utc_offset"] = f["time_zone"]["utc_offset"]
|
|
except KeyError:
|
|
self.db["utc_offset"] = -time.timezone
|
|
# Get twitter's supported languages and save them in a global variable
|
|
#so we won't call to this method once per session.
|
|
if len(application.supported_languages) == 0:
|
|
application.supported_languages = self.twitter.twitter.get_supported_languages()
|
|
self.get_lists()
|
|
self.get_muted_users()
|
|
self.settings.write()
|
|
|
|
@_require_login
|
|
def get_lists(self):
|
|
|
|
""" Gets the lists that the user is subscribed to and stores them in the database. Returns None."""
|
|
|
|
self.db["lists"] = self.twitter.twitter.show_lists(reverse=True)
|
|
|
|
@_require_login
|
|
def get_muted_users(self):
|
|
|
|
""" Gets muted users (oh really?)."""
|
|
|
|
self.db["muted_users"] = self.twitter.twitter.list_mute_ids()["ids"]
|
|
|
|
@_require_login
|
|
def get_stream(self, name, function, *args, **kwargs):
|
|
|
|
""" Retrieves the items for a regular stream.
|
|
name str: Name to save items to the database.
|
|
function str: A function to get the items."""
|
|
|
|
last_id = -1
|
|
if self.db.has_key(name):
|
|
try:
|
|
if self.db[name][0]["id"] > self.db[name][-1]["id"]:
|
|
last_id = self.db[name][0]["id"]
|
|
else:
|
|
last_id = self.db[name][-1]["id"]
|
|
except IndexError:
|
|
pass
|
|
tl = self.call_paged(function, sinze_id=last_id, *args, **kwargs)
|
|
self.order_buffer(name, tl)
|
|
|
|
def get_cursored_stream(self, name, function, items="users", get_previous=False, *args, **kwargs):
|
|
|
|
""" Gets items for API calls that require using cursors to paginate the results.
|
|
name str: Name to save it in the database.
|
|
function str: Function that provides the items.
|
|
items: When the function returns the list with results, items will tell how the order function should be look.
|
|
for example get_followers_list returns a list and users are under list["users"], here the items should point to "users"."""
|
|
|
|
items_ = []
|
|
try:
|
|
if self.db[name].has_key("cursor") and get_previous:
|
|
cursor = self.db[name]["cursor"]
|
|
else:
|
|
cursor = -1
|
|
except KeyError:
|
|
cursor = -1
|
|
if cursor != -1:
|
|
tl = getattr(self.twitter.twitter, function)(cursor=cursor, count=self.settings["general"]["max_tweets_per_call"], *args, **kwargs)
|
|
else:
|
|
tl = getattr(self.twitter.twitter, function)(count=self.settings["general"]["max_tweets_per_call"], *args, **kwargs)
|
|
tl[items].reverse()
|
|
num = self.order_cursored_buffer(name, tl[items])
|
|
# Recently, Twitter's new endpoints have cursor if there are more results.
|
|
if tl.has_key("next_cursor"):
|
|
self.db[name]["cursor"] = tl["next_cursor"]
|
|
return num
|
|
|
|
def start_streaming(self):
|
|
|
|
""" Start the streaming for sending tweets in realtime."""
|
|
if application.streaming_lives():
|
|
if not hasattr(self, "main_stream"):
|
|
self.get_timelines()
|
|
if not hasattr(self, "timelinesStream"):
|
|
self.get_main_stream()
|
|
|
|
def get_main_stream(self):
|
|
if application.streaming_lives():
|
|
log.debug("Starting the main stream...")
|
|
self.main_stream = twitter.buffers.stream.streamer(keyring.get("api_key"), keyring.get("api_secret"), self.settings["twitter"]["user_key"], self.settings["twitter"]["user_secret"], self)
|
|
stream_threaded(self.main_stream.user, self.session_id)
|
|
|
|
def get_timelines(self):
|
|
if application.streaming_lives():
|
|
log.debug("Starting the timelines stream...")
|
|
self.timelinesStream = twitter.buffers.indibidual.timelinesStreamer(keyring.get("api_key"), keyring.get("api_secret"), self.settings["twitter"]["user_key"], self.settings["twitter"]["user_secret"], session=self)
|
|
ids = ""
|
|
for i in self.settings["other_buffers"]["timelines"]:
|
|
ids = ids + "%s, " % (self.db[i+"-timeline"][0]["user"]["id_str"])
|
|
for i in self.lists:
|
|
for z in i.users:
|
|
ids += str(z) + ", "
|
|
if ids != "":
|
|
stream_threaded(self.timelinesStream.statuses.filter, self.session_id, follow=ids)
|
|
|
|
def add_friends(self):
|
|
if application.streaming_lives():
|
|
try:
|
|
self.timelinesStream.set_friends(self.main_stream.friends)
|
|
except AttributeError:
|
|
pass
|
|
|
|
def listen_stream_error(self):
|
|
if hasattr(self, "main_stream") and application.streaming_lives():
|
|
log.debug("Disconnecting the main stream...")
|
|
self.main_stream.disconnect()
|
|
del self.main_stream
|
|
if hasattr(self, "timelinesStream") and application.streaming_lives():
|
|
log.debug("disconnecting the timelines stream...")
|
|
self.timelinesStream.disconnect()
|
|
del self.timelinesStream
|
|
|
|
def check_connection(self):
|
|
log.debug("Executing check connection...")
|
|
instan = 0
|
|
self.counter += 1
|
|
if self.counter >= 4:
|
|
log.debug("Restarting connection after 5 minutes.")
|
|
del self.twitter
|
|
self.logged = False
|
|
self.twitter = twitter.twitter.twitter()
|
|
self.login(False)
|
|
self.counter = 0
|
|
if self.reconnection_function_active == True: return
|
|
self.reconnection_function_active = True
|
|
if not hasattr(self, "main_stream") and application.streaming_lives():
|
|
self.get_main_stream()
|
|
if not hasattr(self, "timelinesStream") and application.streaming_lives():
|
|
self.get_timelines()
|
|
self.reconnection_function_active = False
|
|
if hasattr(self, "timelinesStream") and not hasattr(self.timelinesStream, "friends"):
|
|
self.add_friends()
|
|
# try:
|
|
# urllib2.urlopen("http://74.125.228.231", timeout=5)
|
|
# except urllib2.URLError:
|
|
# pub.sendMessage("stream-error", session=self.session_id)
|
|
|
|
def remove_stream(self, stream):
|
|
if application.streaming_lives():
|
|
if stream == "timelinesStream":
|
|
if hasattr(self, "timelinesStream"):
|
|
self.timelinesStream.disconnect()
|
|
del self.timelinesStream
|
|
else:
|
|
self.main_stream.disconnect()
|
|
del self.main_stream
|
|
|
|
def shelve(self):
|
|
"Shelve the database to allow for persistance."
|
|
shelfname=paths.config_path(str(self.session_id)+"/cache.db")
|
|
if self.settings["general"]["persist_size"] == 0:
|
|
if os.path.exists(shelfname):
|
|
os.remove(shelfname)
|
|
return
|
|
try:
|
|
if not os.path.exists(shelfname):
|
|
output.speak("Generating database, this might take a while.",True)
|
|
shelf=shelve.open(paths.config_path(shelfname),'c')
|
|
for key,value in self.db.items():
|
|
if type(key) != str and type(key) != unicode:
|
|
output.speak("Uh oh, while shelving the database, a key of type " + str(type(key)) + " has been found. It will be converted to type str, but this will cause all sorts of problems on deshelve. Please bring this to the attention of the " + application.name + " developers immediately. More information about the error will be written to the error log.",True)
|
|
log.error("Uh oh, " + str(key) + " is of type " + str(type(key)) + "!")
|
|
# Convert unicode objects to UTF-8 strings before shelve these objects.
|
|
if type(value) == list and self.settings["general"]["persist_size"] != -1 and len(value) > self.settings["general"]["persist_size"]:
|
|
shelf[str(key.encode("utf-8"))]=value[self.settings["general"]["persist_size"]:]
|
|
else:
|
|
shelf[str(key.encode("utf-8"))]=value
|
|
shelf.close()
|
|
except:
|
|
output.speak("An exception occurred while shelving the " + application.name + " database. It will be deleted and rebuilt automatically. If this error persists, send the error log to the " + application.name + " developers.",True)
|
|
log.exception("Exception while shelving" + shelfname)
|
|
os.remove(shelfname)
|
|
|
|
def deshelve(self):
|
|
"Import a shelved database."
|
|
shelfname=paths.config_path(str(self.session_id)+"/cache.db")
|
|
if self.settings["general"]["persist_size"] == 0:
|
|
if os.path.exists(shelfname):
|
|
os.remove(shelfname)
|
|
return
|
|
try:
|
|
shelf=shelve.open(paths.config_path(shelfname),'c')
|
|
for key,value in shelf.items():
|
|
self.db[key]=value
|
|
shelf.close()
|
|
except:
|
|
output.speak("An exception occurred while deshelving the " + application.name + " database. It will be deleted and rebuilt automatically. If this error persists, send the error log to the " + application.name + " developers.",True)
|
|
log.exception("Exception while deshelving" + shelfname)
|
|
try:
|
|
os.remove(shelfname)
|
|
except:
|
|
pass
|
|
|
|
def check_quoted_status(self, tweet):
|
|
status = tweets.is_long(tweet)
|
|
if status != False and config.app["app-settings"]["handle_longtweets"]:
|
|
quoted_tweet = self.get_quoted_tweet(tweet)
|
|
return quoted_tweet
|
|
return tweet
|
|
|
|
def get_quoted_tweet(self, tweet):
|
|
quoted_tweet = tweet
|
|
if tweet.has_key("full_text"):
|
|
value = "full_text"
|
|
else:
|
|
value = "text"
|
|
urls = utils.find_urls_in_text(quoted_tweet[value])
|
|
for url in range(0, len(urls)):
|
|
try: quoted_tweet[value] = quoted_tweet[value].replace(urls[url], quoted_tweet["entities"]["urls"][url]["expanded_url"])
|
|
except IndexError: pass
|
|
if quoted_tweet.has_key("quoted_status"):
|
|
original_tweet = quoted_tweet["quoted_status"]
|
|
elif quoted_tweet.has_key("retweeted_status") and quoted_tweet["retweeted_status"].has_key("quoted_status"):
|
|
original_tweet = quoted_tweet["retweeted_status"]["quoted_status"]
|
|
else:
|
|
return quoted_tweet
|
|
original_tweet = self.check_long_tweet(original_tweet)
|
|
if original_tweet.has_key("full_text"):
|
|
value = "full_text"
|
|
elif original_tweet.has_key("message"):
|
|
value = "message"
|
|
else:
|
|
value = "text"
|
|
urls = utils.find_urls_in_text(original_tweet[value])
|
|
for url in range(0, len(urls)):
|
|
try: original_tweet[value] = original_tweet[value].replace(urls[url], original_tweet["entities"]["urls"][url]["expanded_url"])
|
|
except IndexError: pass
|
|
return compose.compose_quoted_tweet(quoted_tweet, original_tweet)
|
|
|
|
def check_long_tweet(self, tweet):
|
|
long = twishort.is_long(tweet)
|
|
if long != False and config.app["app-settings"]["handle_longtweets"]:
|
|
message = twishort.get_full_text(long)
|
|
if tweet.has_key("quoted_status"):
|
|
tweet["quoted_status"]["message"] = message
|
|
if tweet["quoted_status"]["message"] == False: return False
|
|
tweet["quoted_status"]["twishort"] = True
|
|
for i in tweet["quoted_status"]["entities"]["user_mentions"]:
|
|
if "@%s" % (i["screen_name"]) not in tweet["quoted_status"]["message"] and i["screen_name"] != tweet["user"]["screen_name"]:
|
|
if tweet["quoted_status"].has_key("retweeted_status") and tweet["retweeted_status"]["user"]["screen_name"] == i["screen_name"]:
|
|
continue
|
|
tweet["quoted_status"]["message"] = u"@%s %s" % (i["screen_name"], tweet["message"])
|
|
else:
|
|
tweet["message"] = message
|
|
if tweet["message"] == False: return False
|
|
tweet["twishort"] = True
|
|
for i in tweet["entities"]["user_mentions"]:
|
|
if "@%s" % (i["screen_name"]) not in tweet["message"] and i["screen_name"] != tweet["user"]["screen_name"]:
|
|
if tweet.has_key("retweeted_status") and tweet["retweeted_status"]["user"]["screen_name"] == i["screen_name"]:
|
|
continue
|
|
return tweet
|
|
|
|
def get_user(self, id):
|
|
if self.db.has_key("users") == False or self.db["users"].has_key(id) == False:
|
|
user = self.twitter.twitter.show_user(id=id)
|
|
self.db["users"][user["id_str"]] = user
|
|
return user
|
|
else:
|
|
return self.db["users"][id]
|
|
|
|
def get_user_by_screen_name(self, screen_name):
|
|
if self.db.has_key("users") == False:
|
|
user = utils.if_user_exists(self.twitter.twitter, screen_name)
|
|
self.db["users"][user["id_str"]] = user
|
|
return user["id_str"]
|
|
else:
|
|
for i in self.db["users"].keys():
|
|
if self.db["users"][i]["screen_name"] == screen_name:
|
|
return self.db["users"][i]["id_str"]
|
|
user = utils.if_user_exists(self.twitter.twitter, screen_name)
|
|
self.db["users"][user["id_str"]] = user
|
|
return user["id_str"] |