# -*- coding: utf-8 -*-
import random
from twitterapi import TwitterAPI
from tweets import tweets
twitter = TwitterAPI()
last_tweets = twitter.timeline('abadbot', 5)
def get_random_tweet():
return random.choice(tweets)
def get_new_tweet():
new_tweet = get_random_tweet()
for tweet in last_tweets:
# Check if this was posted in one of the last
# 5 tweets
if new_tweet.get('text', '') in tweet.text:
return get_new_tweet()
return new_tweet
if __name__ == "__main__":
new_tweet = get_new_tweet()
if new_tweet.get('type') == 'text':
twitter.tweet_text(new_tweet.get('text'))
elif new_tweet.get('type') == 'image':
twitter.tweet_image(new_tweet.get('image'), new_tweet.get('text'))
def __init__(self, screen_name, keys):
# Gtk Multithread Setup
if sys.platform == "win32":
gobject.threads_init()
else:
gtk.gdk.threads_init()
if USE_NOTIFY:
pynotify.init("gwit")
# force change gtk icon settings
settings = gtk.settings_get_default()
if not getattr(settings.props, 'gtk_button_images', True):
settings.props.gtk_button_images = True
# init status timelines
self.timelines = list()
self.tlhash = dict()
self.timeline_mention = None
# Twitter class instance
self.twitter = TwitterAPI(screen_name, *keys)
self.twitter.on_tweet_event = self.refresh_tweet
self.twitter.on_notify_event = self.notify
self.read_settings()
# set event (show remaining api count)
self.twitter.on_twitterapi_requested = self.on_timeline_refresh
self.twitter.new_timeline = self.new_timeline
# Get configuration
self.twitter.update_configuration_bg()
# Get users
self.twitter.get_followers_bg()
if not self.userstream: self.twitter.get_following_bg()
# init icon store
IconStore.iconmode = self.iconmode
self.iconstore = IconStore()
# GtkBuilder instance
self.builder = gtk.Builder()
# Glade file input
gladefile = os.path.join(os.path.dirname(__file__), "ui/gwit.ui")
self.builder.add_from_file(gladefile)
# Connect signals
self.builder.connect_signals(self)
self.notebook = self.builder.get_object("notebook1")
self.textview = self.builder.get_object("textview1")
self.btnupdate = self.builder.get_object("button1")
self.charcount = self.builder.get_object("label1")
self.dsettings = self.builder.get_object("dialog_settings")
self.imgtable = self.builder.get_object("table_images")
self.menu_tweet = self.builder.get_object("menu_tweet")
self.builder.get_object("menuitem_tweet").set_submenu(self.menu_tweet)
self.menu_timeline = self.builder.get_object("menu_timeline")
self.builder.get_object("menuitem_timeline").set_submenu(
self.menu_timeline)
# set class variables
Timeline.twitter = self.twitter
StatusView.twitter = self.twitter
StatusView.iconstore = self.iconstore
StatusView.iconmode = self.iconmode
StatusView.pmenu = self.menu_tweet
BaseThread.twitter = self.twitter
StatusDetail.twitter = self.twitter
StatusDetail.iconstore = self.iconstore
ListsView.twitter = self.twitter
ListsView.iconstore = self.iconstore
UserSelection.twitter = self.twitter
UserSelection.iconstore = self.iconstore
GetFriendsWizard.twitter = self.twitter
IconThread.twitter = self.twitter
IconThread.use_icon_cache = self.iconcache
imgpath = os.path.join(os.path.dirname(__file__), "images/")
StatusView.favico_off = gtk.gdk.pixbuf_new_from_file(
imgpath + "favorite.png")
StatusView.favico_hover = gtk.gdk.pixbuf_new_from_file(
imgpath + "favorite_hover.png")
StatusView.favico_on = gtk.gdk.pixbuf_new_from_file(
imgpath + "favorite_on.png")
StatusView.rtico_off = gtk.gdk.pixbuf_new_from_file(
imgpath + "retweet.png")
StatusView.rtico_hover = gtk.gdk.pixbuf_new_from_file(
imgpath + "retweet_hover.png")
StatusView.rtico_on = gtk.gdk.pixbuf_new_from_file(
imgpath + "retweet_on.png")
self.initialize()
# -*- coding: utf-8 -*-
from twitterapi import TwitterAPI
twitter = TwitterAPI()
search = twitter.search('@abad')
for tweet in search:
print tweet.text
class Main(object):
# Default settings
interval = (300, 300, -1)
msgfooter = u""
alloc = gtk.gdk.Rectangle(0, 0, 240, 320)
scounts = (20, 200)
iconmode = True
iconcache = True
userstream = True
# My status, Mentions to me, Reply to, Reply to user, Selected user
status_color = ("#CCCCFF", "#FFCCCC", "#FFCC99", "#FFFFCC", "#CCFFCC")
# Tweet parameters
twparams = dict()
# Streaming API filter
_filter_tab = None
_toggle_change_flag = False
_text_delete_flag = False
# Constractor
def __init__(self, screen_name, keys):
# Gtk Multithread Setup
if sys.platform == "win32":
gobject.threads_init()
else:
gtk.gdk.threads_init()
if USE_NOTIFY:
pynotify.init("gwit")
# force change gtk icon settings
settings = gtk.settings_get_default()
if not getattr(settings.props, 'gtk_button_images', True):
settings.props.gtk_button_images = True
# init status timelines
self.timelines = list()
self.tlhash = dict()
self.timeline_mention = None
# Twitter class instance
self.twitter = TwitterAPI(screen_name, *keys)
self.twitter.on_tweet_event = self.refresh_tweet
self.twitter.on_notify_event = self.notify
self.read_settings()
# set event (show remaining api count)
self.twitter.on_twitterapi_requested = self.on_timeline_refresh
self.twitter.new_timeline = self.new_timeline
# Get configuration
self.twitter.update_configuration_bg()
# Get users
self.twitter.get_followers_bg()
if not self.userstream: self.twitter.get_following_bg()
# init icon store
IconStore.iconmode = self.iconmode
self.iconstore = IconStore()
# GtkBuilder instance
self.builder = gtk.Builder()
# Glade file input
gladefile = os.path.join(os.path.dirname(__file__), "ui/gwit.ui")
self.builder.add_from_file(gladefile)
# Connect signals
self.builder.connect_signals(self)
self.notebook = self.builder.get_object("notebook1")
self.textview = self.builder.get_object("textview1")
self.btnupdate = self.builder.get_object("button1")
self.charcount = self.builder.get_object("label1")
self.dsettings = self.builder.get_object("dialog_settings")
self.imgtable = self.builder.get_object("table_images")
self.menu_tweet = self.builder.get_object("menu_tweet")
self.builder.get_object("menuitem_tweet").set_submenu(self.menu_tweet)
self.menu_timeline = self.builder.get_object("menu_timeline")
self.builder.get_object("menuitem_timeline").set_submenu(
self.menu_timeline)
# set class variables
Timeline.twitter = self.twitter
StatusView.twitter = self.twitter
StatusView.iconstore = self.iconstore
StatusView.iconmode = self.iconmode
StatusView.pmenu = self.menu_tweet
BaseThread.twitter = self.twitter
StatusDetail.twitter = self.twitter
StatusDetail.iconstore = self.iconstore
ListsView.twitter = self.twitter
ListsView.iconstore = self.iconstore
UserSelection.twitter = self.twitter
UserSelection.iconstore = self.iconstore
GetFriendsWizard.twitter = self.twitter
IconThread.twitter = self.twitter
IconThread.use_icon_cache = self.iconcache
imgpath = os.path.join(os.path.dirname(__file__), "images/")
StatusView.favico_off = gtk.gdk.pixbuf_new_from_file(
imgpath + "favorite.png")
StatusView.favico_hover = gtk.gdk.pixbuf_new_from_file(
imgpath + "favorite_hover.png")
StatusView.favico_on = gtk.gdk.pixbuf_new_from_file(
imgpath + "favorite_on.png")
StatusView.rtico_off = gtk.gdk.pixbuf_new_from_file(
imgpath + "retweet.png")
StatusView.rtico_hover = gtk.gdk.pixbuf_new_from_file(
imgpath + "retweet_hover.png")
StatusView.rtico_on = gtk.gdk.pixbuf_new_from_file(
imgpath + "retweet_on.png")
self.initialize()
def main(self):
window = self.builder.get_object("window1")
# settings allocation
window.resize(self.alloc.width, self.alloc.height)
window.show_all()
# Start gtk main loop
gtk.main()
def read_settings(self):
# Read settings
d = Config.get_section("DEFAULT")
self.interval = eval(d.get("interval", str(self.interval)))
self.alloc = eval(d.get("allocation", str(self.alloc)))
self.scounts = eval(d.get("counts", str(self.scounts)))
self.iconmode = eval(d.get("iconmode", str(self.iconmode)))
self.iconcache = eval(d.get("iconcache", str(self.iconcache)))
self.userstream = eval(d.get("userstream", str(self.userstream)))
self.status_color = eval(d.get("color", str(self.status_color)))
u = Config.get_section(self.twitter.my_name)
self.msgfooter = u.get("footer", "")
# Initialize Tabs (in another thread)
def initialize(self):
# Set Status Views
for i in (("Home", "home_timeline", self.userstream),
("@Mentions", "mentions")):
# create new timeline and tab view
deny_close = {"deny_close" : True}
self.new_timeline(*i, **deny_close)
# Set statusbar (Show API Remaining)
self.label_apilimit = gtk.Label()
self.statusbar = self.builder.get_object("statusbar1")
self.statusbar.pack_start(self.label_apilimit,
expand = False, padding = 10)
self.statusbar.show_all()
# Users tab append
users = UserSelection()
self.new_tab(users, "Users", deny_close = True)
# Lists tab append
lists = ListsSelection()
self.new_tab(lists, "Lists", deny_close = True)
self.notebook.set_current_page(0)
# Window close event
def close(self, widget):
window = self.builder.get_object("window1")
# Save Allocation (window position, size)
alloc = repr(window.allocation)
Config.save("DEFAULT", "allocation", alloc)
# hide window
window.hide_all()
# Stop Icon Refresh
self.iconstore.stop()
def exit(self, widget):
# hide window quickly
while gtk.events_pending():
gtk.main_iteration()
# Stop Timeline
for i in self.timelines:
if i != None:
i.destroy()
if i.timeline != None: i.timeline.join(1)
if i.stream != None: i.stream.join(1)
gtk.main_quit()
self.save_settings()
# Create new Timeline and append to notebook
def new_timeline(self, label, method, userstream = False, *args, **kwargs):
# Create Timeline Object
tl = Timeline()
if method == "filter":
if self.get_filter_tab():
# filter method only one connection
self.message_dialog(
"May create only one standing connection to the Streaming API.\n"
"Please close existing Streaming API tab if you want.")
tl.destroy()
return
# set Streaming API stream
tl.set_stream("filter", kwargs)
else:
interval = self.get_default_interval(method)
tl.set_timeline(method, interval, self.scounts, args, kwargs)
# Put error to statubar
tl.timeline.on_twitterapi_error = self.on_twitterapi_error
# for Event
tl.view.new_timeline = self.new_timeline
# Add Notebook (Tab view)
uid = self.new_tab(tl, label, tl, kwargs.get("deny_close", False))
if method == "filter": self.set_filter_tab(uid)
# Set color
tl.view.set_color(self.status_color)
if method == "mentions":
# memory mentions tab_id
self.timeline_mention = uid
tl.on_status_added = self.on_mentions_added
else:
tl.on_status_added = self.on_status_added
# Put tweet information to statusbar
tl.view.on_status_selection_changed = self.on_status_selection_changed
# Reply on double click
tl.view.on_status_activated = self.on_status_activated
# Set UserStream parameter
if userstream:
tl.set_stream("user")
tl.start_stream()
tl.start_timeline()
# Append Tab to Notebook
def new_tab(self, widget, label, timeline = None, deny_close = False):
# close button
button = gtk.Button()
button.set_relief(gtk.RELIEF_NONE)
icon = gtk.image_new_from_stock("gtk-close", gtk.ICON_SIZE_MENU)
button.set_image(icon)
uid = uuid.uuid4().int
button.connect("clicked", self.on_tabclose_clicked, uid)
n = self.notebook.get_n_pages()
self.tlhash[uid] = n
self.timelines.append(timeline)
# Label
lbl = gtk.Label(label)
box = gtk.HBox()
box.pack_start(lbl, True, True)
if not deny_close:
box.pack_start(button, False, False)
box.show_all()
if timeline != None:
button.connect("button-press-event",
self.on_notebook_tabbar_button_press)
# append
self.notebook.append_page(widget, box)
self.notebook.show_all()
self.notebook.set_current_page(n)
return uid
def get_selected_status(self):
tab = self.get_current_tab()
if tab != None:
return tab.view.get_selected_status()
def get_current_tab_n(self):
return self.notebook.get_current_page()
def get_current_tab(self):
return self.timelines[self.notebook.get_current_page()]
# Get text
def get_textview(self):
buf = self.textview.get_buffer()
start, end = buf.get_start_iter(), buf.get_end_iter()
return buf.get_text(start, end)
# Set text
def set_textview(self, txt, focus = False):
buf = self.textview.get_buffer()
buf.set_text(txt)
if focus: self.textview.grab_focus()
# Add text at cursor
def add_textview(self, txt, focus = False):
buf = self.textview.get_buffer()
buf.insert_at_cursor(txt)
if focus: self.textview.grab_focus()
# Clear text
def clear_textview(self, focus = False):
self.set_textview("", focus)
# Reply to selected status
def reply_to_selected_status(self):
status = self.get_selected_status()
self.reply_to_status(status)
def reply_to_status(self, status):
self.twparams["reply_to"] = status.id
name = status.user.screen_name
buf = self.textview.get_buffer()
buf.set_text("@%s " % (name))
self.textview.grab_focus()
# Color selection dialog run for settings
def color_dialog_run(self, title, color, entry):
# Sample treeview setup
store = gtk.ListStore(gtk.gdk.Pixbuf, str, str)
treeview = gtk.TreeView(store)
cellp = gtk.CellRendererPixbuf()
colp = gtk.TreeViewColumn("icon", cellp, pixbuf = 0)
cellt = gtk.CellRendererText()
cellt.set_property("wrap-mode", pango.WRAP_CHAR)
colt = gtk.TreeViewColumn("status", cellt, markup = 1)
colp.add_attribute(cellp, "cell-background", 2)
colt.add_attribute(cellt, "cell-background", 2)
treeview.append_column(colp)
treeview.append_column(colt)
status = self.twitter.statuses.values()[0]
store.append((self.iconstore.get(status.user),
"<b>%s</b>\n%s" % (status.user.screen_name, status.text),
color))
def on_changed_cursor(view):
view.get_selection().unselect_all()
treeview.set_property("can-focus", False)
treeview.set_headers_visible(False)
treeview.connect("cursor-changed", on_changed_cursor)
treeview.show()
swin = gtk.ScrolledWindow()
swin.add(treeview)
swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_NEVER)
swin.show()
label = gtk.Label("Sample")
label.set_justify(gtk.JUSTIFY_LEFT)
label.set_padding(0, 10)
label.set_alignment(0, 0.5)
label.show()
def on_colorselection_color_changed(colorselection, liststore):
strcolor = colorselection.get_current_color().to_string()
liststore.set_value(liststore.get_iter_first(), 2, strcolor)
# Dialog setup
dialog = gtk.ColorSelectionDialog(title)
selection = dialog.get_color_selection()
selection.set_current_color(gtk.gdk.color_parse(color))
selection.connect("color-changed",
on_colorselection_color_changed, store)
selection.pack_start(label)
selection.pack_start(swin)
dialog.show_all()
if dialog.run() == -5:
color = selection.get_current_color().to_string()
entry.set_text(color)
else:
color = None
dialog.destroy()
return color
def status_update_thread(self, status):
t = threading.Thread(target = self._status_update, args = (status,))
t.start()
def _status_update(self, status):
args = dict()
gtk.gdk.threads_enter()
self.textview.set_sensitive(False)
self.btnupdate.set_sensitive(False)
gtk.gdk.threads_leave()
if self.twparams.get("reply_to", None):
args["in_reply_to_status_id"] = self.twparams.get("reply_to", None)
elif self.msgfooter != "":
status = u"%s %s" % (status, self.msgfooter)
if self.twparams.get("media", None):
resp = self.twitter.api_wrapper(
self.twitter.api.status_update_with_media,
status, self.twparams["media"], **args)
else:
resp = self.twitter.api_wrapper(
self.twitter.api.status_update, status, **args)
if resp:
gtk.gdk.threads_enter()
self.clear_textview()
gtk.gdk.threads_leave()
self.twparams.pop("reply_to", None)
self.twparams.pop("media", None)
self.imgtable.forall(self.imgtable.remove)
self.imgtable.set_visible(False)
gtk.gdk.threads_enter()
self.textview.set_sensitive(True)
self.btnupdate.set_sensitive(True)
self.textview.grab_focus()
gtk.gdk.threads_leave()
def get_default_interval(self, method):
if method == "home_timeline":
interval = self.interval[0]
elif method == "mentions":
interval = self.interval[1]
else:
interval = self.interval[2]
return interval
def get_filter_tab(self):
if not self._filter_tab:
return None
elif self.tlhash.get(self._filter_tab, -1) < 0:
# filter tab already closed
self.set_filter_tab(None)
return None
else:
return self._filter_tab
@classmethod
def set_filter_tab(cls, tab_id):
cls._filter_tab = tab_id
def save_settings(self):
conf = (("DEFAULT", "interval", self.interval),
("DEFAULT", "counts", self.scounts),
("DEFAULT", "iconmode", self.iconmode),
("DEFAULT", "iconcache", self.iconcache),
("DEFAULT", "userstream", self.userstream),
("DEFAULT", "color", self.status_color),
(self.twitter.my_name, "footer", self.msgfooter))
Config.save_section(conf)
# desktop notify
def notify(self, title, text, icon_user = None):
if USE_NOTIFY:
notify = pynotify.Notification(title, text)
if icon_user:
icon = self.iconstore.get(icon_user)
notify.set_icon_from_pixbuf(icon)
notify.show()
def refresh_tweet(self, i):
for tl in self.timelines:
if tl: tl.view.reset_status_text()
def message_dialog(self, message,
type = gtk.MESSAGE_ERROR,
buttons = gtk.BUTTONS_OK):
md = gtk.MessageDialog(type = type, buttons = buttons)
md.set_markup(message)
r = md.run()
md.destroy()
return r
########################################
# Original Events
# status added event
def on_status_added(self, i):
status = self.twitter.statuses[i]
myid = self.twitter.my_id
myname = self.twitter.my_name
if status.in_reply_to_user_id == myid or status.text.find("@%s" % myname) >= 0:
# add mentions tab
mentiontab = self.timelines[self.tlhash[self.timeline_mention]]
if status.id not in mentiontab.get_timeline_ids():
mentiontab.timeline.add_statuses(((status,)))
def on_mentions_added(self, i):
status = self.twitter.statuses[i]
self.notify("@%s mentioned you." % status.user.screen_name,
status.text, status.user)
# timeline refreshed event
def on_timeline_refresh(self):
if self.twitter.api.ratelimit_iplimit != -1:
msg = "%d/%d %d/%d" % (
self.twitter.api.ratelimit_remaining,
self.twitter.api.ratelimit_limit,
self.twitter.api.ratelimit_ipremaining,
self.twitter.api.ratelimit_iplimit)
else:
msg = "%d/%d" % (
self.twitter.api.ratelimit_remaining,
self.twitter.api.ratelimit_limit)
try:
self.label_apilimit.set_text("API: %s" % msg)
except:
pass
# status selection changed event
def on_status_selection_changed(self, status):
self.builder.get_object("menuitem_tweet").set_sensitive(True)
self.statusbar.pop(0)
self.statusbar.push(0, TwitterTools.get_footer(status))
# status activated event (to Reply
def on_status_activated(self, status):
self.reply_to_status(status)
# show error on statusbar
def on_twitterapi_error(self, timeline, e):
if e.code == 400:
message = "API rate limiting. Reset: %s" % (
self.twitter.api.ratelimit_reset.strftime("%H:%M:%S"))
elif e.code == 500 or e.code == 502:
message = "Twitter something is broken. Try again later."
elif e.code == 503:
message = "Twitter is over capacity. Try again later."
else:
message = "Oops! Couldn't reload timeline."
self.statusbar.pop(0)
self.statusbar.push(0, "[Error] %s %s (%s)" % (
timeline.getName(), message, e.code))
########################################
# Gtk Signal Events
# Status Update
def on_button1_clicked(self, widget):
txt = self.get_textview()
if txt != "":
# Status Update
self.status_update_thread(txt)
else:
# Reload timeline if nothing in textview
n = self.get_current_tab_n()
self.twparams.pop("reply_to", None)
if self.timelines[n] != None:
self.timelines[n].reload()
# key_press textview (for update status when press Ctrl + Enter)
def on_textview1_key_press_event(self, textview, event):
# Enter == 65293
if event.keyval == 65293 and event.state & gtk.gdk.CONTROL_MASK:
txt = self.get_textview()
# if update button enabled (== len(text) <= 140
if self.btnupdate.get_sensitive() and txt != "":
self.status_update_thread(txt)
return True
# Update menu popup
def on_button2_button_release_event(self, widget, event):
menu = self.builder.get_object("menu_update")
menu.popup(None, None, None, event.button, event.time)
# Add an image to tweet
def on_menuitem_add_image_activate(self, widget):
dialog = gtk.FileChooserDialog("Add an image...")
dialog.add_button(gtk.STOCK_OPEN, gtk.RESPONSE_OK)
dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
ret = dialog.run()
filename = dialog.get_filename()
dialog.destroy()
if ret == gtk.RESPONSE_OK:
media = self.twparams.setdefault("media", list())
# duplicate image?
if filename in media:
self.message_dialog("Duplicate image.")
return
# max_media_per_upload check
max_media = self.twitter.configuration.get("max_media_per_upload",
1)
if len(media) >= max_media:
self.message_dialog(
"You can upload max %d images per upload." % max_media)
return
# ext check
ext = os.path.splitext(filename)[1].upper()
if ext not in [".JPG", ".JPEG", ".PNG", ".GIF"]:
self.message_dialog(
"File is not Image. Only JPG, PNG and GIF.")
return
# filesize check
fsize = os.stat(filename).st_size
limit = self.twitter.configuration.get("photo_size_limit", 3145728)
if fsize > limit:
self.message_dialog(
"Image file size must be less than %d KB." % (
limit / 1024))
return
pix = gtk.gdk.pixbuf_new_from_file(filename)
ratio = float(pix.get_height()) / float(pix.get_width())
pix = pix.scale_simple(120, int(ratio * 120),
gtk.gdk.INTERP_BILINEAR)
img = gtk.Image()
img.set_from_pixbuf(pix)
box = gtk.EventBox()
box.add(img)
box.connect("button-release-event",
self.on_image_button_release, len(media))
# add new row
if len(media) % 4 == 0:
self.imgtable.resize(len(media) / 4 + 1, 4)
# attach image
self.imgtable.attach(
box, len(media) % 4, len(media) % 4 + 1,
len(media) / 4, len(media) / 4 + 1,
xoptions = gtk.SHRINK, yoptions = gtk.SHRINK,
xpadding = 0, ypadding = 10)
cursor = gtk.gdk.Cursor(gtk.gdk.HAND1)
box.window.set_cursor(cursor)
self.imgtable.set_visible(True)
self.imgtable.show_all()
# add params
media.append(filename)
def on_image_button_release(self, widget, event, media_num):
if event.button == 1:
# image clicked
if sys.platform == "win32":
os.startfile(self.twparams["media"][media_num])
else:
os.system("xdg-open %s" % self.twparams["media"][media_num])
elif event.button == 3:
# image delete
r = self.message_dialog(
"Are you sure you want to delete this image?",
gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO)
if r == gtk.RESPONSE_YES:
self.imgtable.remove(widget)
del self.twparams["media"][media_num]
if self.twparams["media"]:
self.imgtable.set_visible(False)
# Timeline Tab Close
def on_tabclose_clicked(self, widget, uid):
n = self.tlhash[uid]
del self.tlhash[uid]
if self.timeline_mention == uid:
self.timeline_mention = None
self.notebook.remove_page(n)
if self.timelines[n] != None:
self.timelines[n].destroy()
del self.timelines[n]
for i, m in self.tlhash.iteritems():
if m > n: self.tlhash[i] -= 1
p = self.notebook.get_current_page()
self.on_notebook1_switch_page(
self.notebook, self.notebook.get_nth_page(p), p)
# Tab right clicked
def on_notebook_tabbar_button_press(self, widget, event):
if event.button == 3:
self.menu_timeline.popup(
None, None, None, event.button, event.time)
# Character count
def on_textbuffer1_changed(self, buf):
text = self.get_textview().decode("utf-8")
# reply to user suggesstions
cursor = buf.get_property("cursor-position")
rspace = text.rfind(" ", 0, cursor)
rat = text.rfind("@", 0, cursor)
rhash = text.rfind("#", 0, cursor)
prefix = postfix = None
# is reply?
if rat == 0 or (rspace > 0 and rat > rspace):
prefix = text[rat + 1:cursor]
users = self.twitter.get_users_startswith(prefix)
if users:
users.sort(key = lambda u: u.screen_name)
postfix = users[0].screen_name[len(prefix):]
# is hash?
if rhash == 0 or (rspace > 0 and rhash > rspace):
prefix = text[rhash + 1:cursor]
hashtags = [h for h in self.twitter.hashtags if h.startswith(prefix)]
if hashtags:
hashtags.sort()
postfix = hashtags[0][len(prefix):]
# clear old suggesstions
if buf.get_has_selection():
buf.delete_selection(True, True)
self._text_delete_flag = False
# print screen_name suggesstions
if prefix and postfix and not self._text_delete_flag:
cursor_iter = buf.get_iter_at_mark(buf.get_insert())
buf.insert_at_cursor(postfix)
buf.select_range(buf.get_iter_at_offset(cursor),
buf.get_iter_at_mark(buf.get_insert()))
self._text_delete_flag = False
# add footer
if self.msgfooter != "" and self.twparams.get("reply_to", None):
text = u"%s %s" % (text, self.msgfooter)
# calculate tweet length
n = TwitterTools.get_tweet_length(
text, len(self.twparams.get("media", [])),
self.twitter.configuration.get("short_url_length", 20),
self.twitter.configuration.get("short_url_length_https", 20),
self.twitter.configuration.get("characters_reserved_per_media", 20)
)
if n <= 140:
self.charcount.set_text(str(n))
self.btnupdate.set_sensitive(True)
else:
self.charcount.set_markup(
"<b><span foreground='#FF0000'>%s</span></b>" % n)
self.btnupdate.set_sensitive(False)
def on_textbuffer1_delete_range(self, buf, start, end):
self._text_delete_flag = True
# Help - About menu
def on_menuitem_about_activate(self, menuitem):
self.builder.get_object("dialog_about").show_all()
return True
# About dialog closed
def on_dialog_about_response(self, dialog, response_id):
dialog.hide_all()
# disable menu when switched tab
def on_notebook1_switch_page(self, notebook, page, page_num):
self.builder.get_object("menuitem_tweet").set_sensitive(False)
menuitem_timeline = self.builder.get_object("menuitem_timeline")
menuitem_timeline.set_sensitive(False)
if page_num < 0: return False
tab = self.timelines[page_num]
if tab != None and tab.timeline != None:
self._toggle_change_flg = True
tl = tab.timeline
method = tl.method
default = self.get_default_interval(method)
if default == -1: default = None
menu_default = self.builder.get_object("menuitem_time_default")
menu_default.get_child().set_text("Default (%s)" % default)
interval = tl.interval
if interval == default:
menu_default.set_active(True)
elif interval == -1:
self.builder.get_object("menuitem_time_none").set_active(True)
elif interval == 600:
self.builder.get_object("menuitem_time_600").set_active(True)
elif interval == 300:
self.builder.get_object("menuitem_time_300").set_active(True)
elif interval == 120:
self.builder.get_object("menuitem_time_120").set_active(True)
elif interval == 60:
self.builder.get_object("menuitem_time_60").set_active(True)
elif interval == 30:
self.builder.get_object("menuitem_time_30").set_active(True)
self._toggle_change_flg = False
menuitem_timeline.set_sensitive(True)
# Streaming API tab
def on_menuitem_streaming_activate(self, menuitem):
dialog = gtk.MessageDialog(buttons = gtk.BUTTONS_OK)
dialog.set_markup("Please enter track keywords.")
dialog.format_secondary_markup(
"Examples: <i>hashtag, username, keyword</i>\n(Split comma. Unnecessary #, @)")
entry = gtk.Entry()
dialog.vbox.pack_start(entry)
dialog.show_all()
dialog.run()
text = entry.get_text().decode("utf-8")
dialog.destroy()
params = {"track" : text.split(",")}
self.new_timeline("Stream: %s" % text, "filter", **params)
def on_destroy(self, widget, *args, **kwargs):
widget.destroy()
########################################
# Tweet menu event
def on_menuitem_reply_activate(self, menuitem):
self.reply_to_selected_status()
# Retweet menu clicked
def on_menuitem_retweet_activate(self, memuitem):
self.get_current_tab().view.retweet_selected_status()
# Retweet with comment menu clicked
def on_menuitem_reteet_with_comment_activate(self, memuitem):
status = self.get_selected_status()
name = status.user.screen_name
text = status.text
self.twparams.pop("reply_to", None)
self.set_textview("RT @%s: %s" % (name, text), True)
# Added user timeline tab
def on_menuitem_usertl_activate(self, menuitem):
status = self.get_selected_status()
self.new_timeline("@%s" % status.user.screen_name,
"user_timeline", user = status.user.id)
# view conversation
def on_menuitem_detail_activate(self, menuitem):
status = self.get_selected_status()
detail = StatusDetail(status)
self.new_tab(detail, "%s: %s..." % (
status.user.screen_name, status.text[:10]))
# favorite
def on_menuitem_fav_activate(self, menuitem):
self.get_current_tab().view.favorite_selected_status()
# Destroy status
def on_menuitem_destroy_activate(self, menuitem):
status = self.get_selected_status()
self.twitter.destory_tweet(status)
# view on twitter.com
def on_menuitem_ontwitter_activate(self, menuitem):
status = self.get_selected_status()
url = "https://twitter.com/%s/status/%s" % (
status.user.screen_name, status.id)
webbrowser.open_new_tab(url)
########################################
# Timeline menu Event
def change_interval(self, interval):
if self._toggle_change_flg: return
tl = self.get_current_tab().timeline
if interval == 0:
method = tl.api_method.func_name
interval = self.get_default_interval(method)
old = tl.interval
tl.interval = interval
if old == -1: tl.lock.set()
def on_menuitem_time_600_toggled(self, menuitem):
if menuitem.get_active() == True:
self.change_interval(600)
def on_menuitem_time_300_toggled(self, menuitem):
if menuitem.get_active() == True:
self.change_interval(300)
def on_menuitem_time_120_toggled(self, menuitem):
if menuitem.get_active() == True:
self.change_interval(120)
def on_menuitem_time_60_toggled(self, menuitem):
if menuitem.get_active() == True:
self.change_interval(60)
def on_menuitem_time_30_toggled(self, menuitem):
if menuitem.get_active() == True:
self.change_interval(30)
def on_menuitem_time_default_toggled(self, menuitem):
if menuitem.get_active() == True:
self.change_interval(0)
def on_menuitem_time_none_toggled(self, menuitem):
if menuitem.get_active() == True:
self.change_interval(-1)
########################################
# Settings dialog event
# Settings
def on_imageitem_settings_activate(self, menuitem):
home, mentions, other = self.interval
# interval
if home == -1:
self.builder.get_object("checkbutton_home").set_active(False)
if mentions == -1:
self.builder.get_object("checkbutton_mentions").set_active(False)
if other == -1:
self.builder.get_object("checkbutton_other").set_active(False)
self.builder.get_object("spinbutton_home").set_value(home)
self.builder.get_object("spinbutton_mentions").set_value(mentions)
self.builder.get_object("spinbutton_other").set_value(other)
# status counts
self.builder.get_object("spinbutton_firstn").set_value(self.scounts[0])
self.builder.get_object("spinbutton_maxn").set_value(self.scounts[1])
# show icons
self.builder.get_object("checkbutton_showicon").set_active(self.iconmode)
# icon cache
self.builder.get_object("checkbutton_iconcache").set_active(self.iconcache)
# userstream
self.builder.get_object("checkbutton_userstream").set_active(self.userstream)
# footer
self.builder.get_object("entry_footer").set_text(self.msgfooter)
# OAuth information
self.builder.get_object("entry_myname").set_text(self.twitter.my_name)
self.builder.get_object("entry_ckey").set_text(self.twitter.api.oauth.ckey)
self.builder.get_object("entry_csecret").set_text(self.twitter.api.oauth.csecret)
self.builder.get_object("entry_atoken").set_text(self.twitter.api.oauth.atoken)
self.builder.get_object("entry_asecret").set_text(self.twitter.api.oauth.asecret)
# Color
color_entrys = (self.builder.get_object("entry_color_mytweet"),
self.builder.get_object("entry_color_mentions"),
self.builder.get_object("entry_color_replyto"),
self.builder.get_object("entry_color_replyto_user"),
self.builder.get_object("entry_color_selected_user"))
for i, entry in enumerate(color_entrys):
entry.set_text(self.status_color[i])
self.dsettings.show()
# Close or Cancel
def on_dialog_settings_close(self, widget):
self.dsettings.hide()
# OK
def on_dialog_settings_ok(self, widget):
# interval
if self.builder.get_object("checkbutton_home").get_active():
home = self.builder.get_object("spinbutton_home").get_value_as_int()
else:
self.charcount.set_markup("<b><span foreground='#FF0000'>%s</span></b>" % n)
self.btnupdate.set_sensitive(False)
home = -1
if self.builder.get_object("checkbutton_mentions").get_active():
mentions = self.builder.get_object("spinbutton_mentions").get_value_as_int()
else:
mentions = -1
if self.builder.get_object("checkbutton_other").get_active():
other = self.builder.get_object("spinbutton_other").get_value_as_int()
else:
other = -1
self.interval = (home, mentions, other)
# status counts
self.scounts = (
self.builder.get_object("spinbutton_firstn").get_value_as_int(),
self.builder.get_object("spinbutton_maxn").get_value_as_int())
# show icons
self.iconmode = self.builder.get_object("checkbutton_showicon").get_active()
# icon cache
self.iconcache = self.builder.get_object("checkbutton_iconcache").get_active()
# userstream
self.userstream = self.builder.get_object("checkbutton_userstream").get_active()
# footer
self.msgfooter = unicode(self.builder.get_object("entry_footer").get_text())
# Color
self.status_color = (self.builder.get_object("entry_color_mytweet").get_text(),
self.builder.get_object("entry_color_mentions").get_text(),
self.builder.get_object("entry_color_replyto").get_text(),
self.builder.get_object("entry_color_replyto_user").get_text(),
self.builder.get_object("entry_color_selected_user").get_text())
for t in self.timelines:
if t != None:
t.view.set_color(self.status_color)
self.save_settings()
self.dsettings.hide()
# toggle checkbox
def on_checkbutton_home_toggled(self, checkbutton):
sb = self.builder.get_object("spinbutton_home")
sb.set_sensitive(checkbutton.get_active())
def on_checkbutton_mentions_toggled(self, checkbutton):
sb = self.builder.get_object("spinbutton_mentions")
sb.set_sensitive(checkbutton.get_active())
def on_checkbutton_other_toggled(self, checkbutton):
sb = self.builder.get_object("spinbutton_other")
sb.set_sensitive(checkbutton.get_active())
def on_entry_color_changed(self, entry):
entry.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse(entry.get_text()))
# Color selection dialog open
def on_button_color1_clicked(self, widget):
entry = self.builder.get_object("entry_color_mytweet")
self.color_dialog_run("My status", entry.get_text(), entry)
def on_button_color2_clicked(self, widget):
entry = self.builder.get_object("entry_color_mentions")
self.color_dialog_run("Mentions to me", entry.get_text(), entry)
def on_button_color3_clicked(self, widget):
entry = self.builder.get_object("entry_color_replyto")
self.color_dialog_run("Reply to", entry.get_text(), entry)
def on_button_color4_clicked(self, widget):
entry = self.builder.get_object("entry_color_replyto_user")
self.color_dialog_run("Reply to user", entry.get_text(), entry)
def on_button_color5_clicked(self, widget):
entry = self.builder.get_object("entry_color_selected_user")
self.color_dialog_run("Selected user", entry.get_text(), entry)
from twitterapi import TwitterAPI
from markov import MarkovModel
POST_SIGNATURE = ' #JohnMaddenBot'
if __name__ == '__main__':
#get something to post
johnMadden = MarkovModel('docs/jmcorpus.txt')
postContent = johnMadden.makeSentence(140 -
len(POST_SIGNATURE)) + POST_SIGNATURE
#set up twitter connection
tweeter = TwitterAPI('tokens.txt')
tweeter.tweet(postContent)
import json
from tweepy.streaming import StreamListener
from tweepy import Stream
from twitterapi import TwitterAPI
twitter = TwitterAPI()
class TraeAlfajoreListener(StreamListener):
"""
A listener handles to handle tweets from Ezeiza
"""
def on_data(self, data):
tweet = json.loads(data)
twitter.tweet_text(
'@{user} Trae alfajores!'.format(
user=tweet.get('user').get('screen_name')
),
tweet.get('id')
)
return True
def on_error(self, status):
if status == 420:
return False
def on_timeout(self):
print 'Timeout...'
return True # Don't kill the stream
# -*- coding: utf-8 -*-
from twitterapi import TwitterAPI
twitter = TwitterAPI()
search = twitter.search("@abad")
for tweet in search:
print tweet.text
from selectsentence import chooseSentence
from twitterapi import TwitterAPI
import datetime
if __name__ == "__main__":
twitter = TwitterAPI()
textID, sentence = chooseSentence()
twitter.tweet(sentence)
print "Using tweet from", textID
print "Sentence:"
print sentence
print "Timestamp:"
print datetime.datetime.now()
print "-"*60