Example #1
0
 def reconnect(self):
     ratelimit = self.api.rate_limit_status()
     if ratelimit is not None:
         minutes = math.ceil((ratelimit['reset_time_in_seconds'] \
                              - gmtime()) / 60.0) + 2
     
     else:
         minutes = 5
     
     self.refresh_timeout = int(minutes * 60)
     
     # Schedule a reconnect if the actual login failed
     if not self.status(ST_LOGIN_SUCCESSFUL):
         self.reconnect_time = gmtime()
         self.set_status(ST_RECONNECT)
         self.reconnect_timeout = gobject.timeout_add(
                                  int(self.refresh_timeout * 1000),
                                  self.login,
                                  self.last_username)
         
         return ERR_RATE_RECONNECT, lang.error_ratelimit_reconnect \
                                      % math.ceil(minutes)
     
     # Just display an error if we exiced the ratelimit while being logged in
     else:
         return ERR_RATE_LIMIT, lang.error_ratelimit % math.ceil(minutes)
Example #2
0
 def relative_time(self, date):
     delta = gmtime() - gmtime(date)
     
     if delta <= 1:
         return lang.html_about_second
     
     elif delta <= 45:
         return lang.html_second % delta
     
     elif delta <= 90:
         return lang.html_about_minute
     
     elif delta <= 60 * 45:
         return lang.html_minute % math.ceil(delta / 60.0)
     
     elif delta <= 60 * 60 * 1.5:
         return lang.html_about_hour
     
     elif delta <= 60 * 60 * 20:
         return lang.html_hour % math.ceil(delta / (60.0 * 60.0))
     
     elif delta <= 60 * 60 * 24 * 1.5:
         return lang.html_about_day
     
     elif delta <= 60 * 60 * 48:
         return lang.html_yesterday
     
     elif delta <= 60 * 60 * 72:
         return lang.html_day % math.ceil(delta / (60.0 * 60.0 * 24.0))
     
     else:
         return time.strftime(lang.html_exact, localtime(date))
Example #3
0
 def absolute_time(self, date, message=False):
     delta = gmtime() - gmtime(date)
     date = localtime(date)
     if delta <= 60 * 60 * 24:
         return time.strftime(lang.html_time_message if message \
                              else lang.html_time, date)
     
     else:
         return time.strftime(lang.html_time_day_message if message \
                              else lang.html_time_day, date)
Example #4
0
 def userlist_uptodate(self, name):
     if name == UNSET_USERNAME:
         return True
     
     userfile = os.path.join(ATARASHII_DIR, 'usernames_%s.list' % name)
     if not os.path.exists(userfile):
         self['userlist_time_' + name] = gmtime()
         return False
     
     if gmtime() - (self['userlist_time_' + name] or 0) > USERLIST_TIMEOUT:
         self['userlist_time_' + name] = gmtime()
         return False
     
     return True
Example #5
0
 def update_limit(self):
     ratelimit = self.api.rate_limit_status()
     if ratelimit is None:
         self.main.refresh_timeout = 60
         return False
     
     minutes = (ratelimit['reset_time_in_seconds'] - gmtime()) / 60
     
     limit = ratelimit['remaining_hits']
     if limit > 0:
         limit = limit / (2.0 + 2.0 / 2)
         self.main.refresh_timeout = int(minutes / limit * 60 * 1.10)
         if self.main.refresh_timeout < 45:
             self.main.refresh_timeout = 45
     
     # Check for ratelimit
     count = ratelimit['hourly_limit']
     if count < 350:
         if not self.main.status(ST_WARNING_RATE):
             self.main.set_status(ST_WARNING_RATE)
             gobject.idle_add(self.gui.warning_button.show,
                              lang.warning_button_rate_limit,
                              lang.warning_rate_limit % count)
     
     else:
         self.main.unset_status(ST_WARNING_RATE)
Example #6
0
 def run(self):
     while self.running:
         if self.do_init:
             self.init()
         
         elif self.refresh_images:
             self.refresh_images = False
             self.reload_images()
         
         elif self.started:
             if self.finish_update:
                 self.finish_update = False
                 gobject.idle_add(self.main.save_settings, True)
                 self.main.unset_status(ST_UPDATE)
                 self.main.refresh_time = gmtime()
                 gobject.idle_add(self.gui.set_multi_button, True)
                 gobject.idle_add(self.gui.update_app)
             
             elif self.tweet.load_history_id != HTML_UNSET_ID:
                 self.load_history()
             
             elif self.message.load_history_id != HTML_UNSET_ID:
                 self.load_history_message()
             
             elif self.profile.load_history_id != HTML_UNSET_ID:
                 self.load_history_profile()
             
             elif self.main.refresh_timeout != UNSET_TIMEOUT \
                  and (gmtime() > self.main.refresh_time + \
                  self.main.refresh_timeout or self.refresh_now \
                  or self.refresh_messages):
                 
                 self.update_id += 1
                 self.main.set_status(ST_UPDATE)
                 gobject.idle_add(self.gui.set_multi_button, False, None,
                                  True, True)
                 
                 self.update(self.update_id)
                 self.refresh_messages = False
                 self.refresh_now = False
         
         self.wait.clear()
         gobject.timeout_add(1000, self.unwait)
         self.wait.wait()
Example #7
0
 def on_login_complete(self):
     self.set_status(ST_LOGIN_COMPLETE)
     self.gui.tray.activate_menu(True)
     self.gui.update_app()
     if self.gui.settings_dialog is not None:
         self.gui.settings_dialog.activate(True)
     
     self.save_settings(True)
     self.gui.set_multi_button(True)
     self.refresh_time = gmtime()
Example #8
0
 def get_image(self, item, message=False, user=None):
     if user is None:
         user = item.sender if message else item.retweeted_status.user \
                if hasattr(item, 'retweeted_status') else item.user
     
     url = user.profile_image_url \
           if not self.main.settings.is_true('unicorns', False) \
           else 'http://unicornify.appspot.com/avatar/%s?s=128' \
           % hashlib.md5(str(user.id)).hexdigest()
     
     img = os.path.join(CACHE_DIR, str(user.id) + '_' \
                        + url[url.rfind('/') + 1:].split('?')[0])
     
     if not os.path.exists(img):
         urllib.urlretrieve(url, img)
     
     # Check for user picture
     if user.screen_name.lower() == self.main.username.lower():
         date = gmtime(item.created_at) if item is not None else gmtime()
         self.main.set_user_picture(img, date)
     
     return img
Example #9
0
 def update_status(self, once=False):
     if self.text.has_typed and not self.mode == MODE_PROFILE:
         pass
     
     elif self.main.status(ST_RECONNECT):
         wait = self.main.refresh_timeout - \
                 (gmtime() - self.main.reconnect_time)
         if wait < 60:
             self.set_status(lang.status_reconnect_seconds % wait)
         
         elif wait < 105:
             self.set_status(lang.status_reconnect_minute)
         
         else:
             self.set_status(
                 lang.status_reconnect_minutes % math.ceil(wait / 60.0))
     
     elif self.main.status(ST_HISTORY):
         if self.tweet.load_history_id != HTML_UNSET_ID:
             state = lang.status_load_history
         
         elif self.message.load_history_id != HTML_UNSET_ID:
             state = lang.status_load_message_history
         
         else:
             state = lang.status_load_history
         
         self.set_status(state)
     
     elif self.main.status(ST_CONNECT):
         self.set_status(lang.status_connecting % self.main.username)
     
     elif self.main.status(ST_LOGIN_ERROR):
         self.set_status(lang.status_error)
     
     elif not self.main.status(ST_LOGIN_SUCCESSFUL):
         self.set_status(lang.status_logout)
     
     elif self.main.any_status(ST_SEND, ST_DELETE):
         pass
     
     elif self.mode == MODE_PROFILE \
          and self.profile.load_state == HTML_LOADING:
         
         self.set_status(lang.status_profile \
                         % lang.name(self.main.profile_current_user))
     
     elif self.main.status(ST_UPDATE):
         self.set_multi_button(False, None, False, True)
         self.set_status(lang.status_update)
     
     elif self.main.refresh_time == UNSET_TIMEOUT \
          or  (self.mode == MODE_MESSAGES \
          and self.message.load_state == HTML_LOADING) \
          or (self.mode == MODE_TWEETS \
          and self.tweet.load_state == HTML_LOADING):
         
         self.set_status(lang.status_connected)
     
     elif (not self.text.is_typing or not self.text.has_focus \
           or self.mode == MODE_PROFILE) and not self.main.status(ST_SEND):
         
         wait = self.main.refresh_timeout - \
                (gmtime() - self.main.refresh_time)
         
         if wait < 0:
             wait = 0
         
         if wait == 0:
             self.set_multi_button(False, None, False, True)
             self.set_status(lang.status_update)
         
         elif wait == 1:
             self.set_status(lang.status_one_second)
         
         else:
             if wait < 60:
                 self.set_status(lang.status_seconds % wait)
             
             elif wait < 105:
                 self.set_status(lang.status_minute)
             
             else:
                 self.set_status(
                      lang.status_minutes % math.ceil(wait / 60.0))
     
     if once:
         return False
     
     else:
         return True