Merge branch 'next-gen' into mastodon

src/controller/buffers/base/base.py

@@ -125,6 +125,9 @@ class Buffer(object):
     def share_item(self):
         pass
 
+    def can_share(self):
+        pass
+
     def destroy_status(self):
         pass
 

src/controller/buffers/twitter/base.py

@@ -19,7 +19,7 @@ import languageHandler
 import logging
 from audio_services import youtube_utils
 from controller.buffers.base import base
-from sessions.twitter import compose, utils, reduce
+from sessions.twitter import compose, utils, reduce, templates
 from mysc.thread_utils import call_threaded
 from tweepy.errors import TweepyException
 from tweepy.cursor import Cursor
@@ -84,42 +84,15 @@ class BaseBuffer(base.Buffer):
         return _(u"Unknown buffer")
 
     def post_status(self, *args, **kwargs):
-        item = None
-        title = _(u"Tweet")
-        caption = _(u"Write the tweet here")
+        title = _("Tweet")
+        caption = _("Write the tweet here")
         tweet = messages.tweet(self.session, title, caption, "")
-        if tweet.message.get_response() == widgetUtils.OK:
-            if config.app["app-settings"]["remember_mention_and_longtweet"]:
-                config.app["app-settings"]["longtweet"] = tweet.message.long_tweet.GetValue()
-                config.app.write()
-            text = tweet.message.get_text()
-            if len(text) > 280 and tweet.message.get("long_tweet") == True:
-                if not hasattr(tweet, "attachments"):
-                    text = twishort.create_tweet(self.session.settings["twitter"]["user_key"], self.session.settings["twitter"]["user_secret"], text)
-                else:
-                    text = twishort.create_tweet(self.session.settings["twitter"]["user_key"], self.session.settings["twitter"]["user_secret"], text, 1)
-            if not hasattr(tweet, "attachments") or len(tweet.attachments) == 0:
-                item = self.session.api_call(call_name="update_status", status=text, _sound="tweet_send.ogg", tweet_mode="extended")
-            else:
-                call_threaded(self.post_with_media, text=text, attachments=tweet.attachments)
-            # We will no longer will reuse the sent item from here as Streaming API should give us the new and correct item.
-            # but in case we'd need it, just uncomment the following couple of lines and make sure we reduce the item correctly.
-#            if item != None:
-#                pub.sendMessage("sent-tweet", data=item, user=self.session.db["user_name"])
-        if hasattr(tweet.message, "destroy"): tweet.message.destroy()
-        self.session.settings.write()
-
-    def post_with_media(self, text, attachments):
-        media_ids = []
-        for i in attachments:
-            img = self.session.twitter.media_upload(i["file"])
-            self.session.twitter.create_media_metadata(media_id=img.media_id, alt_text=i["description"])
-            media_ids.append(img.media_id)
-        item = self.session.twitter.update_status(status=text, media_ids=media_ids)
-        # We will no longer will reuse the sent item from here as Streaming API should give us the new and correct item.
-        # but in case we'd need it, just uncomment the following couple of lines and make sure we reduce the item correctly.
-#        if item != None:
-#            pub.sendMessage("sent-tweet", data=item, user=self.session.db["user_name"])
+        response = tweet.message.ShowModal()
+        if response == wx.ID_OK:
+            tweet_data = tweet.get_tweet_data()
+            call_threaded(self.session.send_tweet, *tweet_data)
+        if hasattr(tweet.message, "destroy"):
+            tweet.message.destroy()
 
     def get_formatted_message(self):
         if self.type == "dm" or self.name == "direct_messages":
@@ -127,8 +100,10 @@ class BaseBuffer(base.Buffer):
         return self.get_message()
 
     def get_message(self):
+        template = self.session.settings["templates"]["tweet"]
         tweet = self.get_right_tweet()
-        return " ".join(self.compose_function(tweet, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"], self.session))
+        t = templates.render_tweet(tweet, template, self.session, relative_times=self.session.settings["general"]["relative_times"], offset_seconds=self.session.db["utc_offset"])
+        return t
 
     def get_full_tweet(self):
         tweet = self.get_right_tweet()
@@ -167,7 +142,7 @@ class BaseBuffer(base.Buffer):
             log.debug("Starting stream for buffer %s, account %s and type %s" % (self.name, self.account, self.type))
             log.debug("args: %s, kwargs: %s" % (self.args, self.kwargs))
             if self.name != "direct_messages":
-                val = self.session.call_paged(self.function, *self.args, **self.kwargs)
+                val = self.session.call_paged(self.function, self.name, *self.args, **self.kwargs)
             else:
                 # 50 results are allowed per API call, so let's assume max value can be 50.
                 # reference: https://developer.twitter.com/en/docs/twitter-api/v1/direct-messages/sending-and-receiving/api-reference/list-events
@@ -199,9 +174,9 @@ class BaseBuffer(base.Buffer):
             self.put_items_on_list(number_of_items)
             if hasattr(self, "finished_timeline") and self.finished_timeline == False:
                 if "-timeline" in self.name:
-                    self.username = val[0].user.screen_name
+                    self.username = self.session.get_user(self.kwargs.get("user_id")).screen_name
                 elif "-favorite" in self.name:
-                    self.username = self.session.api_call("get_user", **self.kwargs).screen_name
+                    self.username = self.session.get_user(self.kwargs.get("user_id")).screen_name
                 self.finished_timeline = True
             if number_of_items > 0 and self.name != "sent_tweets" and self.name != "sent_direct_messages" and self.sound != None and self.session.settings["sound"]["session_mute"] == False and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and play_sound == True:
                 self.session.sound.play(self.sound)
@@ -416,13 +391,18 @@ class BaseBuffer(base.Buffer):
         tweet = self.session.db[self.name][self.buffer.list.get_selected()]
         return tweet
 
+    def can_share(self):
+        tweet = self.get_right_tweet()
+        user = self.session.get_user(tweet.user)
+        is_protected = user.protected
+        return is_protected==False
+
     @_tweets_exist
     def reply(self, *args, **kwargs):
         tweet = self.get_right_tweet()
         user = self.session.get_user(tweet.user)
         screen_name = user.screen_name
         id = tweet.id
-        twishort_enabled = hasattr(tweet, "twishort")
         users = utils.get_all_mentioned(tweet, self.session.db, field="screen_name")
         ids = utils.get_all_mentioned(tweet, self.session.db, field="id")
         # Build the window title
@@ -430,38 +410,14 @@ class BaseBuffer(base.Buffer):
             title=_("Reply to {arg0}").format(arg0=screen_name)
         else:
             title=_("Reply")
-        message = messages.reply(self.session, title, _(u"Reply to %s") % (screen_name,), "", users=users, ids=ids)
-        if message.message.get_response() == widgetUtils.OK:
+        message = messages.reply(self.session, title, _("Reply to %s") % (screen_name,), "", users=users, ids=ids)
+        if message.message.ShowModal() == widgetUtils.OK:
             if config.app["app-settings"]["remember_mention_and_longtweet"]:
-                config.app["app-settings"]["longtweet"] = message.message.long_tweet.GetValue()
                 if len(users) > 0:
-                    config.app["app-settings"]["mention_all"] = message.message.mentionAll.GetValue()
+                    config.app["app-settings"]["mention_all"] = message.message.mention_all.GetValue()
                 config.app.write()
-            params = {"_sound": "reply_send.ogg", "in_reply_to_status_id": id, "tweet_mode": "extended"}
-            text = message.message.get_text()
-            if twishort_enabled == False:
-                excluded_ids = message.get_ids()
-                params["exclude_reply_user_ids"] =excluded_ids
-                params["auto_populate_reply_metadata"] =True
-            else:
-                mentioned_people = message.get_people()
-                text = "@"+screen_name+" "+mentioned_people+u" "+text
-            if len(text) > 280 and message.message.get("long_tweet") == True:
-                if message.image == None:
-                    text = twishort.create_tweet(self.session.settings["twitter"]["user_key"], self.session.settings["twitter"]["user_secret"], text)
-                else:
-                    text = twishort.create_tweet(self.session.settings["twitter"]["user_key"], self.session.settings["twitter"]["user_secret"], text, 1)
-            params["status"] = text
-            if message.image == None:
-                params["call_name"] = "update_status"
-            else:
-                params["call_name"] = "update_status_with_media"
-                params["media"] = message.file
-            item = self.session.api_call(**params)
-            # We will no longer will reuse the sent item from here as Streaming API should give us the new and correct item.
-            # but in case we'd need it, just uncomment the following couple of lines and make sure we reduce the item correctly.
-#            if item != None:
-#                pub.sendMessage("sent-tweet", data=item, user=self.session.db["user_name"])
+            tweet_data = dict(text=message.message.text.GetValue(), attachments=message.attachments, poll_options=message.poll_options, poll_period=message.poll_period)
+            call_threaded(self.session.reply, in_reply_to_status_id=id, text=message.message.text.GetValue(), attachments=message.attachments, exclude_reply_user_ids=message.get_ids())
         if hasattr(message.message, "destroy"): message.message.destroy()
         self.session.settings.write()
 
@@ -477,25 +433,23 @@ class BaseBuffer(base.Buffer):
         else:
             screen_name = self.session.get_user(tweet.user).screen_name
             users = utils.get_all_users(tweet, self.session)
-        dm = messages.dm(self.session, _(u"Direct message to %s") % (screen_name,), _(u"New direct message"), users)
-        if dm.message.get_response() == widgetUtils.OK:
-            screen_name = dm.message.get("cb")
+        dm = messages.dm(self.session, _("Direct message to %s") % (screen_name,), _("New direct message"), users)
+        if dm.message.ShowModal() == widgetUtils.OK:
+            screen_name = dm.message.cb.GetValue()
             user = self.session.get_user_by_screen_name(screen_name)
             recipient_id =  user
-            text = dm.message.get_text()
-            val = self.session.api_call(call_name="send_direct_message", recipient_id=recipient_id, text=text)
-            if val != None:
-                sent_dms = self.session.db["sent_direct_messages"]
-                if self.session.settings["general"]["reverse_timelines"] == False:
-                    sent_dms.append(val)
-                else:
-                    sent_dms.insert(0, val)
-                self.session.db["sent_direct_messages"] = sent_dms
-                pub.sendMessage("sent-dm", data=val, user=self.session.db["user_name"])
+            text = dm.message.text.GetValue()
+            if len(dm.attachments) > 0:
+                attachment = dm.attachments[0]
+            else:
+                attachment = None
+            call_threaded(self.session.direct_message, text=text, recipient=recipient_id, attachment=attachment)
         if hasattr(dm.message, "destroy"): dm.message.destroy()
 
     @_tweets_exist
     def share_item(self, *args, **kwargs):
+        if self.can_share() == False:
+            return output.speak(_("This action is not supported on protected accounts."))
         tweet = self.get_right_tweet()
         id = tweet.id
         if self.session.settings["general"]["retweet_mode"] == "ask":
@@ -509,40 +463,20 @@ class BaseBuffer(base.Buffer):
         else:
             self._retweet_with_comment(tweet, id)
 
-    def _retweet_with_comment(self, tweet, id, comment=''):
-        # If quoting a retweet, let's quote the original tweet instead the retweet.
+    def _retweet_with_comment(self, tweet, id):
         if hasattr(tweet, "retweeted_status"):
             tweet = tweet.retweeted_status
-        if hasattr(tweet, "full_text"):
-            comments = tweet.full_text
-        else:
-            comments = tweet.text
-        retweet = messages.tweet(self.session, _(u"Quote"), _(u"Add your comment to the tweet"), u"“@%s: %s ”" % (self.session.get_user(tweet.user).screen_name, comments), max=256, messageType="retweet")
-        if comment != '':
-            retweet.message.set_text(comment)
-        if retweet.message.get_response() == widgetUtils.OK:
-            text = retweet.message.get_text()
-            text = text+" https://twitter.com/{0}/status/{1}".format(self.session.get_user(tweet.user).screen_name, id)
-            if retweet.image == None:
-                # We will no longer will reuse the sent item from here as Streaming API should give us the new and correct item.
-                # but in case we'd need it, just uncomment the following couple of lines and make sure we reduce the item correctly.
-                item = self.session.api_call(call_name="update_status", _sound="retweet_send.ogg", status=text, in_reply_to_status_id=id, tweet_mode="extended")
-#                if item != None:
-#                    new_item = self.session.twitter.get_status(id=item.id, include_ext_alt_text=True, tweet_mode="extended")
-#                    pub.sendMessage("sent-tweet", data=new_item, user=self.session.db["user_name"])
-            else:
-                call_threaded(self.session.api_call, call_name="update_status", _sound="retweet_send.ogg", status=text, media=retweet.image)
-        if hasattr(retweet.message, "destroy"): retweet.message.destroy()
+        retweet = messages.tweet(session=self.session, title=_("Quote"), caption=_("Add your comment to the tweet"), max=256, thread_mode=False)
+        if retweet.message.ShowModal() == widgetUtils.OK:
+            text = retweet.message.text.GetValue()
+            tweet_data = dict(text=text, attachments=retweet.attachments, poll_period=retweet.poll_period, poll_options=retweet.poll_options)
+            tweet_data.update(quote_tweet_id=id)
+            call_threaded(self.session.send_tweet, *[tweet_data])
+        if hasattr(retweet.message, "destroy"):
+            retweet.message.Destroy()
 
     def _direct_retweet(self, id):
         item = self.session.api_call(call_name="retweet", _sound="retweet_send.ogg", id=id)
-        # We will no longer will reuse the sent item from here as Streaming API should give us the new and correct item.
-        # but in case we'd need it, just uncomment the following couple of lines and make sure we reduce the item correctly.
-#        if item != None:
-            # Retweets are returned as non-extended tweets, so let's get the object as extended
-            # just before sending the event message. See https://github.com/manuelcortez/TWBlue/issues/253
-#            item = self.session.twitter.get_status(id=item.id, include_ext_alt_text=True, tweet_mode="extended")
-#            pub.sendMessage("sent-tweet", data=item, user=self.session.db["user_name"])
 
     def onFocus(self, *args, **kwargs):
         tweet = self.get_tweet()
@@ -557,6 +491,9 @@ class BaseBuffer(base.Buffer):
             self.session.sound.play("geo.ogg")
         if self.session.settings['sound']['indicate_img'] and utils.is_media(tweet):
             self.session.sound.play("image.ogg")
+        can_share = self.can_share()
+        pub.sendMessage("toggleShare", shareable=can_share)
+        self.buffer.retweet.Enable(can_share)
 
     def audio(self, url='', *args, **kwargs):
         if sound.URLPlayer.player.is_playing():

src/controller/buffers/twitter/directMessages.py

@@ -8,7 +8,7 @@ import config
 import languageHandler
 import logging
 from controller import messages
-from sessions.twitter import compose, utils
+from sessions.twitter import compose, utils, templates
 from mysc.thread_utils import call_threaded
 from tweepy.errors import TweepyException
 from pubsub import pub
@@ -90,18 +90,12 @@ class DirectMessagesBuffer(base.BaseBuffer):
     def reply(self, *args, **kwargs):
         tweet = self.get_right_tweet()
         screen_name = self.session.get_user(tweet.message_create["sender_id"]).screen_name
-        message = messages.reply(self.session, _(u"Mention"), _(u"Mention to %s") % (screen_name,), "@%s " % (screen_name,), [screen_name,])
-        if message.message.get_response() == widgetUtils.OK:
-            if config.app["app-settings"]["remember_mention_and_longtweet"]:
-                config.app["app-settings"]["longtweet"] = message.message.long_tweet.GetValue()
-                config.app.write()
-            if message.image == None:
-                item = self.session.api_call(call_name="update_status", _sound="reply_send.ogg", status=message.message.get_text(), tweet_mode="extended")
-                if item != None:
-                    pub.sendMessage("sent-tweet", data=item, user=self.session.db["user_name"])
-            else:
-                call_threaded(self.session.api_call, call_name="update_status_with_media", _sound="reply_send.ogg", status=message.message.get_text(), media=message.file)
-        if hasattr(message.message, "destroy"): message.message.destroy()
+        message = messages.reply(session=self.session, title=_("Mention"), caption=_("Mention to %s") % (screen_name,), text="@%s " % (screen_name,), thread_mode=False, users=[screen_name,])
+        if message.message.ShowModal() == widgetUtils.OK:
+            tweet_data = message.get_tweet_data()
+            call_threaded(self.session.send_tweet, tweet_data)
+        if hasattr(message.message, "destroy"):
+            message.message.destroy()
 
     def onFocus(self, *args, **kwargs):
         tweet = self.get_tweet()
@@ -135,6 +129,12 @@ class DirectMessagesBuffer(base.BaseBuffer):
     def open_in_browser(self, *args, **kwargs):
         output.speak(_(u"This action is not supported in the buffer yet."))
 
+    def get_message(self):
+        template = self.session.settings["templates"]["dm"]
+        dm = self.get_right_tweet()
+        t = templates.render_dm(dm, template, self.session, relative_times=self.session.settings["general"]["relative_times"], offset_seconds=self.session.db["utc_offset"])
+        return t
+
 class SentDirectMessagesBuffer(DirectMessagesBuffer):
 
     def __init__(self, *args, **kwargs):
@@ -156,4 +156,10 @@ class SentDirectMessagesBuffer(DirectMessagesBuffer):
         else:
             for i in items:
                 tweet = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"], self.session)
-                self.buffer.list.insert_item(False, *tweet)
+                self.buffer.list.insert_item(False, *tweet)
+
+    def get_message(self):
+        template = self.session.settings["templates"]["dm_sent"]
+        dm = self.get_right_tweet()
+        t = templates.render_dm(dm, template, self.session, relative_times=self.session.settings["general"]["relative_times"], offset_seconds=self.session.db["utc_offset"])
+        return t

src/controller/buffers/twitter/people.py

@@ -16,7 +16,7 @@ import logging
 from mysc.thread_utils import call_threaded
 from tweepy.errors import TweepyException
 from pubsub import pub
-from sessions.twitter import compose
+from sessions.twitter import compose, templates
 from . import base
 
 log = logging.getLogger("controller.buffers.twitter.peopleBuffer")
@@ -84,7 +84,10 @@ class PeopleBuffer(base.BaseBuffer):
         pass
 
     def get_message(self):
-        return " ".join(self.compose_function(self.get_tweet(), self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"], self.session))
+        template = self.session.settings["templates"]["person"]
+        user = self.get_right_tweet()
+        t = templates.render_person(user, template, self.session, relative_times=True, offset_seconds=self.session.db["utc_offset"])
+        return t
 
     def delete_item(self): pass
 
@@ -92,18 +95,12 @@ class PeopleBuffer(base.BaseBuffer):
     def reply(self, *args, **kwargs):
         tweet = self.get_right_tweet()
         screen_name = tweet.screen_name
-        message = messages.reply(self.session, _(u"Mention"), _(u"Mention to %s") % (screen_name,), "@%s " % (screen_name,), [screen_name,])
-        if message.message.get_response() == widgetUtils.OK:
-            if config.app["app-settings"]["remember_mention_and_longtweet"]:
-                config.app["app-settings"]["longtweet"] = message.message.long_tweet.GetValue()
-                config.app.write()
-            if message.image == None:
-                item = self.session.api_call(call_name="update_status", _sound="reply_send.ogg", status=message.message.get_text(), tweet_mode="extended")
-                if item != None:
-                    pub.sendMessage("sent-tweet", data=item, user=self.session.db["user_name"])
-            else:
-                call_threaded(self.session.api_call, call_name="update_status_with_media", _sound="reply_send.ogg", status=message.message.get_text(), media=message.file)
-        if hasattr(message.message, "destroy"): message.message.destroy()
+        message = messages.tweet(session=self.session, title=_("Mention"), caption=_("Mention to %s") % (screen_name,), text="@%s " % (screen_name,), thread_mode=False)
+        if message.message.ShowModal() == widgetUtils.OK:
+            tweet_data = message.get_tweet_data()
+            call_threaded(self.session.send_tweet, tweet_data)
+        if hasattr(message.message, "destroy"):
+            message.message.destroy()
 
     def start_stream(self, mandatory=False, play_sound=True, avoid_autoreading=False):
         # starts stream every 3 minutes.

src/controller/buffers/twitter/search.py

@@ -64,12 +64,16 @@ class SearchPeopleBuffer(people.PeopleBuffer):
             return False
 
 class ConversationBuffer(SearchBuffer):
+    last_thread_id = None
+    last_reply_id = None
 
     def start_stream(self, start=False, mandatory=False, play_sound=True, avoid_autoreading=False):
         current_time = time.time()
         if self.execution_time == 0 or current_time-self.execution_time >= 180 or mandatory == True:
             self.execution_time = current_time
+            log.debug("Retrieving conversation. Last thread ID is {}, last reply ID is {}".format(self.last_thread_id, self.last_reply_id))
             results = self.get_replies(self.tweet)
+            log.debug("Retrieved {} items before filters.".format(len(results)))
             number_of_items = self.session.order_buffer(self.name, results)
             log.debug("Number of items retrieved: %d" % (number_of_items,))
             self.put_items_on_list(number_of_items)
@@ -117,12 +121,12 @@ class ConversationBuffer(SearchBuffer):
         # find all tweets replying to the original thread only. Those tweets are sent by the same author who originally posted the first tweet.
         try:
             term = "conversation_id:{} from:{} to:{}".format(conversation_id, original_tweet.data.author_id, original_tweet.data.author_id)
-            thread_tweets = self.session.twitter_v2.search_recent_tweets(term, user_auth=True, max_results=98, tweet_fields=["in_reply_to_user_id", "author_id", "conversation_id"])
+            thread_tweets = self.session.twitter_v2.search_recent_tweets(term, user_auth=True, max_results=98, since_id=self.last_thread_id, tweet_fields=["in_reply_to_user_id", "author_id", "conversation_id"])
             if thread_tweets.data != None:
                 thread_results.extend(thread_tweets.data)
             # Search only replies to conversation_id.
             term = "conversation_id:{}".format(conversation_id, original_tweet.data.author_id)
-            reply_tweets = self.session.twitter_v2.search_recent_tweets(term, user_auth=True, max_results=50, tweet_fields=["in_reply_to_user_id", "author_id", "conversation_id"])
+            reply_tweets = self.session.twitter_v2.search_recent_tweets(term, user_auth=True, max_results=50, since_id=self.last_reply_id, tweet_fields=["in_reply_to_user_id", "author_id", "conversation_id"])
             if reply_tweets.data != None:
                 reply_results.extend(reply_tweets.data)
         except TweepyException as e:
@@ -135,6 +139,7 @@ class ConversationBuffer(SearchBuffer):
             try:
                 thread_results = self.session.twitter.lookup_statuses(ids, include_ext_alt_text=True, tweet_mode="extended")
                 thread_results.sort(key=lambda x: x.id)
+                self.last_thread_id = thread_results[-1].id
                 results.extend(thread_results)
             except TweepyException as e:
                 log.exception("There was an error attempting to retrieve tweets for Twitter API V1.1, in conversation buffer {}".format(self.name))
@@ -144,7 +149,39 @@ class ConversationBuffer(SearchBuffer):
             try:
                 reply_results = self.session.twitter.lookup_statuses(ids, include_ext_alt_text=True, tweet_mode="extended")
                 reply_results.sort(key=lambda x: x.id)
+                self.last_reply_id = reply_results[-1].id
                 results.extend(reply_results)
             except TweepyException as e:
                 log.exception("There was an error attempting to retrieve tweets for Twitter API V1.1, in conversation buffer {}".format(self.name))
+        return results
+
+    def get_replies_v1(self, tweet):
+        try:
+            tweet = self.session.twitter.get_status(id=tweet.id, tweet_mode="extended")
+        except:
+            log.exception("Error getting tweet for making a conversation buffer.")
+            return []
+        results = []
+        results.append(tweet)
+        if hasattr(tweet, "in_reply_to_status_id") and tweet.in_reply_to_status_id != None:
+            while tweet.in_reply_to_status_id != None:
+                original_tweet = self.session.twitter.get_status(id=tweet.in_reply_to_status_id, tweet_mode="extended")
+                results.insert(0, original_tweet)
+                tweet = original_tweet
+        try:
+            term = "from:{} to:{}".format(tweet.user.screen_name, tweet.user.screen_name)
+            thread_tweets = self.session.twitter.search_tweets(term, count=100, since_id=tweet.id, tweet_mode="extended")
+            results.extend(thread_tweets)
+        except TweepyException as e:
+            log.exception("There was an error when attempting to retrieve the whole conversation for buffer {}".format(self.buffer.name))
+
+        try:
+            term = "to:{}".format(tweet.user.screen_name)
+            reply_tweets = self.session.twitter.search_tweets(term, count=100, since_id=tweet.id, tweet_mode="extended")
+            ids = [t.id for t in results]
+            reply_tweets = [t for t in reply_tweets if hasattr(t, "in_reply_to_status_id") and t.in_reply_to_status_id in ids]
+            results.extend(reply_tweets)
+        except TweepyException as e:
+            log.exception("There was an error when attempting to retrieve the whole conversation for buffer {}".format(self.buffer.name))
+        results.sort(key=lambda x: x.id)
         return results

src/controller/buffers/twitter/trends.py

@@ -4,7 +4,7 @@ import platform
 if platform.system() == "Windows":
     import wx
     from wxUI import buffers, commonMessageDialogs, menus
-    from controller import user
+    from controller import user, messages
 elif platform.system() == "Linux":
     from gi.repository import Gtk
     from gtkUI import buffers, commonMessageDialogs
@@ -38,6 +38,18 @@ class TrendsBuffer(base.Buffer):
         self.get_formatted_message = self.get_message
         self.reply = self.search_topic
 
+
+    def post_status(self, *args, **kwargs):
+        title = _("Tweet")
+        caption = _("Write the tweet here")
+        tweet = messages.tweet(self.session, title, caption, "")
+        response = tweet.message.ShowModal()
+        if response == wx.ID_OK:
+            tweet_data = tweet.get_tweet_data()
+            call_threaded(self.session.send_tweet, *tweet_data)
+        if hasattr(tweet.message, "destroy"):
+            tweet.message.destroy()
+
     def start_stream(self, mandatory=False, play_sound=True, avoid_autoreading=False):
         # starts stream every 3 minutes.
         current_time = time.time()
@@ -119,21 +131,13 @@ class TrendsBuffer(base.Buffer):
 
     def tweet_about_this_trend(self, *args, **kwargs):
         if self.buffer.list.get_count() == 0: return
-        title = _(u"Tweet")
-        caption = _(u"Write the tweet here")
-        tweet = messages.tweet(self.session, title, caption, self.get_message()+ " ")
-        tweet.message.set_cursor_at_end()
-        if tweet.message.get_response() == widgetUtils.OK:
-            text = tweet.message.get_text()
-            if len(text) > 280 and tweet.message.get("long_tweet") == True:
-                if tweet.image == None:
-                    text = twishort.create_tweet(self.session.settings["twitter"]["user_key"], self.session.settings["twitter"]["user_secret"], text)
-                else:
-                    text = twishort.create_tweet(self.session.settings["twitter"]["user_key"], self.session.settings["twitter"]["user_secret"], text, 1)
-            if tweet.image == None:
-                call_threaded(self.session.api_call, call_name="update_status", status=text)
-            else:
-                call_threaded(self.session.api_call, call_name="update_status_with_media", status=text, media=tweet.image)
+        title = _("Tweet")
+        caption = _("Write the tweet here")
+        tweet = messages.tweet(session=self.session, title=title, caption=caption, text=self.get_message()+ " ")
+        tweet.message.SetInsertionPoint(len(tweet.message.GetValue()))
+        if tweet.message.ShowModal() == widgetUtils.OK:
+            tweet_data = tweet.get_tweet_data()
+            call_threaded(self.session.send_tweet, *tweet_data)
         if hasattr(tweet.message, "destroy"): tweet.message.destroy()
 
     def show_menu_by_key(self, ev):