Write secrets from CI environment

Improve conversation Support

.gitlab-ci.yml

@@ -0,0 +1,123 @@
+variables:
+  GIT_SUBMODULE_STRATEGY: recursive
+  PYTHON: "C:\\python37\\python.exe"
+  NSIS: "C:\\program files (x86)\\nsis\\makensis.exe"
+
+stages:
+  - build
+  - make_installer
+  - upload
+
+twblue32:
+  tags:
+    - shared-windows
+    - windows
+    - windows-1809
+  before_script:
+    - Set-Variable -Name "time" -Value (date -Format "%H:%m")
+    - echo ${time}
+    - echo "started by ${GITLAB_USER_NAME}"
+    - choco install python --version 3.7.9 -y -ForceX86
+    - '&$env:PYTHON -V'
+    - '&$env:PYTHON -m pip install --upgrade pip'
+    - '&$env:PYTHON -m pip install --upgrade -r requirements.txt'
+  stage: build
+  interruptible: true
+  script:
+    # Create html documentation firstly.
+    - cd doc
+    - '&$env:PYTHON documentation_importer.py'
+    - cd ..\src
+    - '&$env:PYTHON ..\doc\generator.py'
+    - '&$env:PYTHON write_version_data.py'
+    - '&$env:PYTHON setup.py build'
+    - cd ..
+    - mkdir artifacts
+    - cd scripts
+    - '&$env:PYTHON make_archive.py'
+    - cd ..
+    - mv src/dist artifacts/TWBlue
+    - move src/twblue.zip artifacts/twblue_x86.zip
+    # Move the generated script nsis file to artifacts, so we won't need python when generating the installer.
+    - move scripts/twblue.nsi artifacts/twblue.nsi
+  only:
+    - tags
+  artifacts:
+    paths:
+      - artifacts
+    expire_in: 1 day
+
+twblue64:
+  tags:
+    - shared-windows
+    - windows
+    - windows-1809
+  before_script:
+    - Set-Variable -Name "time" -Value (date -Format "%H:%m")
+    - echo ${time}
+    - echo "started by ${GITLAB_USER_NAME}"
+    - choco install python --version 3.7.9 -y
+    - '&$env:PYTHON -V'
+    - '&$env:PYTHON -m pip install --upgrade pip'
+    - '&$env:PYTHON -m pip install --upgrade -r requirements.txt'
+  stage: build
+  interruptible: true
+  script:
+    # Create html documentation firstly.
+    - cd doc
+    - '&$env:PYTHON documentation_importer.py'
+    - cd ..\src
+    - '&$env:PYTHON ..\doc\generator.py'
+    - '&$env:PYTHON write_version_data.py'
+    - '&$env:PYTHON setup.py build'
+    - cd ..
+    - mkdir artifacts
+    - cd scripts
+    - '&$env:PYTHON make_archive.py'
+    - cd ..
+    - mv src/dist artifacts/TWBlue64
+    - move src/twblue.zip artifacts/twblue_x64.zip
+  only:
+    - tags
+  artifacts:
+    paths:
+      - artifacts
+    expire_in: 1 day
+
+generate_versions:
+  stage: make_installer
+  tags:
+    - shared-windows
+    - windows
+    - windows-1809
+  before_script:
+    - Set-Variable -Name "time" -Value (date -Format "%H:%m")
+    - echo ${time}
+    - echo "started by ${GITLAB_USER_NAME}"
+    - choco install nsis -y -ForceX86
+  script:
+    - move artifacts/TWBlue scripts/
+    - move artifacts/TWBlue64 scripts/
+    - move artifacts/twblue.nsi scripts/installer.nsi
+    - cd scripts
+    - '&$env:NSIS installer.nsi'
+    - move twblue_setup.exe ../artifacts
+  only:
+    - tags
+  artifacts:
+    paths:
+      - artifacts
+    expire_in: 1 day
+
+upload:
+  stage: upload
+  tags:
+    - linux
+  image: python
+  interruptible: true
+  script:
+    - cd artifacts
+    - python ../scripts/upload.py
+  only:
+    - tags
+    - schedules

appveyor.yml

@@ -1,84 +0,0 @@
-pull_requests:
-  # Avoid building after pull requests. Shall we disable this option?
-  do_not_increment_build_number: true
-
-# Only build whenever we add tags to the repo.
-skip_non_tags: true
-
-environment:
-
-  matrix:
-
-  # List of python versions we want to work with.
-    - PYTHON: "C:\\Python38"
-      PYTHON_VERSION: "3.8.x" # currently 2.7.9
-      PYTHON_ARCH: "32"
-
-  # perhaps we may enable this one in future?
-#    - PYTHON: "C:\\Python37-x64"
-#      PYTHON_VERSION: "3.7.x" # currently 2.7.9
-#      PYTHON_ARCH: "64"
-
-# This is important so we will retrieve everything in submodules as opposed to default method.
-clone_script:
-  - cmd: >-
-      git clone -q --branch=%APPVEYOR_REPO_BRANCH% https://github.com/%APPVEYOR_REPO_NAME%.git %APPVEYOR_BUILD_FOLDER%
-      && cd %APPVEYOR_BUILD_FOLDER%
-      && git checkout -qf %APPVEYOR_REPO_COMMIT%
-      && git submodule update --init --recursive
-
-install:
-  # If there is a newer build queued for the same PR, cancel this one.
-  # The AppVeyor 'rollout builds' option is supposed to serve the same
-  # purpose but it is problematic because it tends to cancel builds pushed
-  # directly to master instead of just PR builds (or the converse).
-  # credits: JuliaLang developers.
-  - ps: if ($env:APPVEYOR_PULL_REQUEST_NUMBER -and $env:APPVEYOR_BUILD_NUMBER -ne ((Invoke-RestMethod `
-        https://ci.appveyor.com/api/projects/$env:APPVEYOR_ACCOUNT_NAME/$env:APPVEYOR_PROJECT_SLUG/history?recordsNumber=50).builds | `
-        Where-Object pullRequestId -eq $env:APPVEYOR_PULL_REQUEST_NUMBER)[0].buildNumber) { `
-          throw "There are newer queued builds for this pull request, failing early." }
-#  - ECHO "Filesystem root:"
-#  - ps: "ls \"C:/\""
-
-  # Check that we have the expected version and architecture for Python
-  - "SET PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%"
-  - "python --version"
-  - "python -c \"import struct; print(struct.calcsize('P') * 8)\""
-
-  # Upgrade to the latest version of pip to avoid it displaying warnings
-  # about it being out of date.
-  - "python -m pip install --upgrade pip setuptools"
-
-  # Install the build dependencies of the project. If some dependencies contain
-  # compiled extensions and are not provided as pre-built wheel packages,
-  # pip will build them from source using the MSVC compiler matching the
-  # target Python version and architecture
-  - "%CMD_IN_ENV% pip install -r requirements.txt"
-  - "%CMD_IN_ENV% pip install pyenchant"
-
-build_script:
-  # Build documentation at first, so setup.py won't fail when copying everything.
-  - "cd doc"
-  # Import documentation before building, so strings.py will be created.
-  - "%CMD_IN_ENV% python documentation_importer.py"
-  # build doc from src folder so it will generate result files right there.
-  - "cd ..\\src"
-  - "%CMD_IN_ENV% python ..\\doc\\generator.py"
-  # Build distributable files.
-  - "%CMD_IN_ENV% python setup.py build"
-  - "cd dist"
-  # Zip it all.
-  - cmd: 7z a ..\..\snapshot.zip *
-
-artifacts:
-  - path: snapshot.zip
-
-deploy:
-- provider: FTP
-  host: twblue.es
-  protocol: ftp
-  beta: true
-  username: twblue.es
-  password:
-    secure: lQZqpYRnHf4LLVOg0C42NQ==
-  folder: 'web/pubs'

contributors.txt

@@ -39,5 +39,5 @@ florian Ionașcu
 Christian Leo Mameli
 Natalia Hedlund (Наталья Хедлунд)
 Valeria (Валерия)
-Corentin Bacqué-Cazenave
+Oreonan
 Artem Plaksin (maniyax)

doc/changelog.md

@@ -2,6 +2,27 @@
 
 ## changes in this version
 
+* Added an user alias manager, located in the application menu in the menu bar. From this dialog, it is possible to review, add, edit or remove user aliases for the current account. ([#401](https://github.com/manuelcortez/TWBlue/issues/401))
+* TWBlue now closes the VLC player window automatically when a video reaches its end. ([#399](https://github.com/manuelcortez/TWBlue/issues/399))
+* After a lot of time, TWBlue now uses a new default Soundpack, called FreakyBlue. This soundpack will be set by default in all new sessions created in the application. Thanks to [Andre Louis](https://twitter.com/FreakyFwoof) for the pack. ([#247](https://github.com/manuelcortez/TWBlue/issues/247))
+* When reading a tweet, if the tweet contains more than 2 consecutive mentions, TWBlue will announce how many more users the tweet includes, as opposed to read every user in the conversation. You still can display the tweet to read all users.
+* In the tweet displayer, It is possible to copy a link to the current tweet or person by pressing a button called "copy link to clipboard".
+* Added a keymap capable to work under Windows 11. ([#391](https://github.com/manuelcortez/TWBlue/pull/391))
+* Added user aliases to TWBlue. This feature allows you to rename user's display names on Twitter, so the next time you'll read an user it will be announced as you configured. For adding an alias to an user, select the "add alias" option in the user menu, located in the menu bar. This feature works only if you have set display screen names unchecked. Users are displayed with their display name in people buffers only. This action is supported in all keymaps, although it is undefined by default. ([#389](https://github.com/manuelcortez/TWBlue/pull/389))
+* There are some changes to the autocomplete users feature:
+    * Now users can search for twitter screen names or display names in the database.
+* It is possible to undefine keystrokes in the current keymap in TWBlue. This allows you, for example, to redefine keystrokes completely.
+* We have changed our Geocoding service to the Nominatim API from OpenStreetMap. Addresses present in tweets are going to be determined by this service, as the Google Maps API now requires an API key. ([#390](https://github.com/manuelcortez/TWBlue/issues/390))
+* Added a limited version of the Twitter's Streaming API: The Streaming API will work only for tweets, and will receive tweets only by people you follow. Protected users are not possible to be streamed. It is possible that during high tweet traffic, the Stream might get disconnected at times, but TWBlue should be capable of detecting this problem and reconnecting the stream again. ([#385](https://github.com/manuelcortez/TWBlue/pull/385))
+* Fixed an issue that made TWBlue to not show a dialog when attempting to show a profile for a suspended user. ([#387](https://github.com/manuelcortez/TWBlue/issues/387))
+* Added support for Twitter audio and videos: Tweets which contains audio or videos will be detected as audio items, and you can playback those with the regular command to play audios. ([#384,](https://github.com/manuelcortez/TWBlue/pull/384))
+* We just implemented some changes in the way TWBlue handles tweets in order to reduce its RAM memory usage [#380](https://github.com/manuelcortez/TWBlue/pull/380):
+    * We reduced the tweets size by storing only the tweet fields we currently use. This should reduce tweet's size in memory for every object up to 75%.
+    * When using the cache database to store your tweets, there is a new setting present in the account settings dialog, in the general tab. This setting allows you to control whether TWBlue will load the whole database into memory (which is the current behaviour) or not.
+        * Loading the whole database into memory has the advantage of being extremely fast to access any element (for example when moving through tweets in a buffer), but it requires more memory as the tweet buffers grow up. This should, however, use less memory than before thanks to the optimizations performed in tweet objects. If you have a machine with enough memory, this should be a good option for your case.
+        * If you uncheck this setting, TWBlue will read the whole database from disk. This is significantly slower, but the advantage of this setting is that it will consume almost no extra memory, no matter how big is the tweets dataset. Be ware, though, that TWBlue might start to feel slower when accessing elements (for example when reading tweets) as the buffers grow up. This setting is suggested for computers with low memory or for those people not wanting to keep a really big amount of tweets stored.
+* Changed the label in the direct message's text control so it will indicate that the user needs to write the text there, without referring to any username in particular. ([#366,](https://github.com/manuelcortez/TWBlue/issues/366))
+* TWBlue will take Shift+F10 again as the contextual menu key in the list of items in a buffer. This stopped working after we have migrated to WX 4.1. ([#353,](https://github.com/manuelcortez/TWBlue/issues/353))
 * TWBlue should render correctly retweets of quoted tweets. ([#365,](https://github.com/manuelcortez/TWBlue/issues/365))
 * Fixed an error that was causing TWBlue to be unable to output to screen readers at times. ([#369,](https://github.com/manuelcortez/TWBlue/issues/369))
 * Fixed autocomplete users feature. ([#367,](https://github.com/manuelcortez/TWBlue/issues/367))

doc/documentation_importer.py

@@ -16,9 +16,9 @@ def prepare_documentation_in_file(fileSource, fileDest):
 		if "\n" == i:
 			newvar = "\"\","
 		elif "\n" == i[-1]:
-			newvar = "_(u\"\"\"%s\"\"\"),\n" % (i[:-1])
+			newvar = "\"\"\"%s\"\"\",\n" % (i[:-1])
 		else:
-			newvar = "_(u\"\"\"%s\"\"\"),\n" % (i)
+			newvar = "\"\"\"%s\"\"\",\n" % (i)
 		f2.write(newvar)
 	f1.close()
 	f2.write("]")

doc/generator.py

@@ -8,28 +8,27 @@ import shutil
 from codecs import open as _open
 from importlib import reload
 
-def change_language(name, language):
- global _
- os.environ["lang"] = language
- _ = gettext.install(name, os.path.join(paths.app_path(), "locales"))
+def get_translation_function(name, language):
+ if language == "en":
+  return gettext.NullTranslations()
+ translation_function = gettext.translation(name, os.path.join(paths.app_path(), "locales"), languages=[language])
+ return translation_function
 
 # the list of supported language codes of TW Blue
-languages = ["en", "es", "fr", "de", "it", "gl", "ja", "ru", "ro", "eu", "ca", "da"]
+languages = ["en", "es", "fr", "de", "it", "gl", "ja", "ru", "ro", "eu", "ca", "da", "sr"]
 
 def generate_document(language, document_type="documentation"):
  if document_type == "documentation":
   translation_file = "twblue-documentation"
-  change_language(translation_file, language)
-  reload(strings)
-  markdown_file = markdown.markdown("\n".join(strings.documentation[1:]), extensions=["markdown.extensions.toc"])
-  title = strings.documentation[0]
+  translation_function = get_translation_function(translation_file, language)
+  markdown_file = markdown.markdown("\n".join([translation_function.gettext(s[:-1]) if s != "\n" else s for s in strings.documentation[1:]]), extensions=["markdown.extensions.toc"])
+  title = translation_function.gettext(strings.documentation[0][:-1])
   filename = "manual.html"
  elif document_type == "changelog":
   translation_file = "twblue-changelog"
-  change_language(translation_file, language)
-  reload(changelog)
-  markdown_file = markdown.markdown("\n".join(changelog.documentation[1:]), extensions=["markdown.extensions.toc"])
-  title = changelog.documentation[0]
+  translation_function = get_translation_function(translation_file, language)
+  markdown_file = markdown.markdown("\n".join([translation_function.gettext(s[:-1]) if s != "\n" else s for s in changelog.documentation[1:]]), extensions=["markdown.extensions.toc"])
+  title = translation_function.gettext(changelog.documentation[0][:-1])
   filename = "changelog.html"
  first_html_block = """<!doctype html>
  <html lang="%s">
@@ -56,11 +55,13 @@ def create_documentation():
   shutil.copy(os.path.join("..", "license.txt"), os.path.join("documentation", "license.txt"))
  for i in languages:
   print("Creating documentation for: %s" % (i,))
+  try:
    generate_document(i)
    generate_document(i, "changelog")
+  except:
+   continue
  print("Done")
 
-change_language("twblue-documentation", "en")
 import strings
 import changelog
 create_documentation()

mysc/keys/api_keys.c

@@ -5,19 +5,6 @@ return "key\0";
 char *get_api_secret(){
 return "secret_key\0";
 }
-char *get_dropbox_api_key(){
-return "key\0";
-}
-char *get_dropbox_api_secret(){
-return "secret_key\0";
-}
 char *get_twishort_api_key(){
 return "key\0";
 }
-char *get_bts_user(){
-return "user\0";
-}
-char *get_bts_password(){
-return "pass\0";
-}
-

mysc/keys/api_keys.h

@@ -3,10 +3,6 @@
 
 char *get_api_key();
 char *get_api_secret();
-char *get_dropbox_api_key();
-char *get_dropbox_api_secret();
 char *get_twishort_api_key();
-char *get_bts_user();
-char *get_bts_password();
 
 #endif

requirements.txt

@@ -9,7 +9,7 @@ oauthlib
 requests-oauthlib
 requests-toolbelt
 pypubsub
-pygeocoder
+geopy
 arrow
 python-dateutil
 futures
@@ -25,12 +25,29 @@ urllib3
 youtube-dl
 python-vlc
 pypiwin32
+pywin32
 certifi
 backports.functools_lru_cache
 cx_freeze
 tweepy
 twitter-text-parser
 pyenchant
+sqlitedict
+cx-Logging
+h11
+h2
+hpack
+hstspreload
+httpcore
+httpx
+hyperframe
+rfc3986
+sniffio
+attrs
+importlib-metadata
+numpy
+pillow
+charset-normalizer
 git+https://github.com/accessibleapps/libloader
 git+https://github.com/accessibleapps/platform_utils
 git+https://github.com/accessibleapps/accessible_output2

scripts/make_archive.py

@@ -0,0 +1,12 @@
+import  shutil
+import os
+import sys
+
+def create_archive():
+	os.chdir("..\\src")
+	print("Creating zip archive...")
+	folder = "dist"
+	shutil.make_archive("twblue", "zip", folder)
+	os.chdir("..\\scripts")
+
+create_archive()

scripts/twblue.nsi

@@ -14,11 +14,11 @@ SetCompress auto
 SetCompressor /solid lzma
 SetDatablockOptimize on
 VIAddVersionKey ProductName "TWBlue"
-VIAddVersionKey LegalCopyright "Copyright 2018 Manuel Cortéz."
-VIAddVersionKey ProductVersion "0.95"
-VIAddVersionKey FileVersion "0.95"
-VIProductVersion "0.95.0.0"
-VIFileVersion "0.95.0.0"
+VIAddVersionKey LegalCopyright "Copyright 2014-2021 Manuel Cortéz."
+VIAddVersionKey ProductVersion "0.95.0"
+VIAddVersionKey FileVersion "0.95.0"
+VIProductVersion "0.95.0"
+VIFileVersion "0.95.0"
 !insertmacro MUI_PAGE_WELCOME
 !define MUI_LICENSEPAGE_RADIOBUTTONS
 !insertmacro MUI_PAGE_LICENSE "license.txt"
@@ -27,7 +27,7 @@ var StartMenuFolder
 !insertmacro MUI_PAGE_STARTMENU startmenu $StartMenuFolder
 !insertmacro MUI_PAGE_INSTFILES
 !define MUI_FINISHPAGE_LINK "Visit TWBlue website"
-!define MUI_FINISHPAGE_LINK_LOCATION "http://twblue.es"
+!define MUI_FINISHPAGE_LINK_LOCATION "https://twblue.es"
 !define MUI_FINISHPAGE_RUN "$INSTDIR\TWBlue.exe"
 !insertmacro MUI_PAGE_FINISH
 !insertmacro MUI_UNPAGE_CONFIRM
@@ -73,9 +73,9 @@ WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\twblue" "U
 WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall" "InstallLocation" $INSTDIR
 WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall" "Publisher" "Manuel Cortéz"
 WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\twblue" "DisplayVersion" "0.95"
-WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\twblue" "URLInfoAbout" "http://twblue.es"
+WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\twblue" "URLInfoAbout" "https://twblue.es"
 WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\twblue" "VersionMajor" 0
-WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\twblue" "VersionMinor" 95
+WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\twblue" "VersionMinor" 0
 WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\twblue" "NoModify" 1
 WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\twblue" "NoRepair" 1
 SectionEnd

scripts/upload.py

@@ -0,0 +1,48 @@
+#! /usr/bin/env python
+import sys
+import os
+import glob
+import ftplib
+
+transferred=0
+
+def convert_bytes(n):
+	K, M, G, T, P = 1 << 10, 1 << 20, 1 << 30, 1 << 40, 1 << 50
+	if   n >= P:
+		return '%.2fPb' % (float(n) / T)
+	elif   n >= T:
+		return '%.2fTb' % (float(n) / T)
+	elif n >= G:
+		return '%.2fGb' % (float(n) / G)
+	elif n >= M:
+		return '%.2fMb' % (float(n) / M)
+	elif n >= K:
+		return '%.2fKb' % (float(n) / K)
+	else:
+		return '%d' % n
+
+def callback(progress):
+	global transferred
+	transferred = transferred+len(progress)
+	print("Uploaded {}".format(convert_bytes(transferred),))
+
+ftp_server = os.environ.get("FTP_SERVER") or sys.argv[1]
+ftp_username = os.environ.get("FTP_USERNAME") or sys.argv[2]
+ftp_password = os.environ.get("FTP_PASSWORD") or sys.argv[3]
+
+print("Uploading files to the TWBlue server...")
+print("Connecting to %s" % (ftp_server,))
+connection = ftplib.FTP(ftp_server)
+print("Connected to FTP server {}".format(ftp_server,))
+connection.login(user=ftp_username, passwd=ftp_password)
+print("Logged in successfully")
+connection.cwd("web/pubs")
+files = glob.glob("*.zip")+glob.glob("*.exe")
+print("These files will be uploaded into the version folder: {}".format(files,))
+for file in files:
+	transferred = 0
+	print("Uploading {}".format(file,))
+	with open(file, "rb") as f:
+		connection.storbinary('STOR %s' % file, f, callback=callback, blocksize=1024*1024) 
+print("Upload completed. exiting...")
+connection.quit()

src/Conf.defaults

@@ -12,6 +12,7 @@ reverse_timelines = boolean(default=False)
 announce_stream_status = boolean(default=True)
 retweet_mode = string(default="ask")
 persist_size = integer(default=0)
+load_cache_in_memory=boolean(default=True)
 show_screen_names = boolean(default=False)
 buffer_order = list(default=list('home','mentions', 'dm', 'sent_dm', 'sent_tweets','favorites','followers','friends','blocks','muted','events'))
 
@@ -20,7 +21,7 @@ volume = float(default=1.0)
 input_device = string(default="Default")
 output_device = string(default="Default")
 session_mute = boolean(default=False)
-current_soundpack = string(default="default")
+current_soundpack = string(default="FreakyBlue")
 indicate_audio = boolean(default=True)
 indicate_geo = boolean(default=True)
 indicate_img = boolean(default=True)
@@ -48,3 +49,5 @@ braille_reporting = boolean(default=True)
 speech_reporting = boolean(default=True)
 
 [filters]
+
+[user-aliases]

src/application.py

@@ -3,20 +3,14 @@ import datetime
 
 name = 'TWBlue'
 short_name='twblue'
-snapshot = True
-if snapshot == False:
- version = "0.95"
- update_url = 'https://twblue.es/updates/stable.php'
- mirror_update_url = 'https://raw.githubusercontent.com/manuelcortez/TWBlue/next-gen/updates/stable.json'
-else:
- version = "5"
- update_url = 'https://twblue.es/updates/snapshot.php'
- mirror_update_url = 'https://raw.githubusercontent.com/manuelcortez/TWBlue/next-gen/updates/snapshots.json'
+update_url = 'https://twblue.es/updates/updates.php'
+mirror_update_url = 'https://raw.githubusercontent.com/manuelcortez/TWBlue/next-gen/updates/updates.json'
 authors = ["Manuel Cortéz", "José Manuel Delicado"]
 authorEmail = "manuel@manuelcortez.net"
 copyright = "Copyright (C) 2013-2021, Manuel cortéz."
 description = name+" is an app designed to use Twitter simply and efficiently while using minimal system resources. This app provides access to most Twitter  features."
-translators = ["Manuel Cortéz (English)", "Mohammed Al Shara, Hatoun Felemban (Arabic)", "Francisco Torres (Catalan)", "Manuel cortéz (Spanish)", "Sukil Etxenike Arizaleta (Basque)", "Jani Kinnunen (finnish)", "Rémy Ruiz (French)", "Juan Buño (Galician)", "Steffen Schultz (German)", "Zvonimir Stanečić (Croatian)", "Robert Osztolykan (Hungarian)", "Christian Leo Mameli (Italian)", "Riku (Japanese)", "Paweł Masarczyk (Polish)", "Odenilton Júnior Santos (Portuguese)", "Florian Ionașcu, Nicușor Untilă (Romanian)", "Natalia Hedlund, Valeria Kuznetsova (Russian)", "Aleksandar Đurić (Serbian)", "Burak Yüksek (Turkish)"]
+translators = ["Manuel Cortéz (English)", "Mohammed Al Shara, Hatoun Felemban (Arabic)", "Francisco Torres (Catalan)", "Manuel cortéz (Spanish)", "Sukil Etxenike Arizaleta (Basque)", "Jani Kinnunen (finnish)", "Oreonan (Français)", "Juan Buño (Galician)", "Steffen Schultz (German)", "Zvonimir Stanečić (Croatian)", "Robert Osztolykan (Hungarian)", "Christian Leo Mameli (Italian)", "Riku (Japanese)", "Paweł Masarczyk (Polish)", "Odenilton Júnior Santos (Portuguese)", "Florian Ionașcu, Nicușor Untilă (Romanian)", "Natalia Hedlund, Valeria Kuznetsova (Russian)", "Aleksandar Đurić (Serbian)", "Burak Yüksek (Turkish)"]
 url = u"https://twblue.es"
 report_bugs_url = "https://github.com/manuelcortez/twblue/issues"
 supported_languages = []
+version = "11"

src/controller/buffers/__init__.py

@@ -1,8 +1,3 @@
 # -*- coding: utf-8 -*-
-""" this package contains logic related to buffers. A buffer is a virtual representation of a group of items retrieved through the Social network API'S.
-  Ideally, new social networks added to TWBlue will have its own "buffers", and these buffers should be defined within this package, following the Twitter example.
-  Currently, the package contains the following modules:
-    * baseBuffers: Define a set of functions and structure to be expected in all buffers. New buffers should inherit its classes from one of the classes present here.
-    * twitterBuffers: All other code, specific to Twitter.
-"""
-from __future__ import unicode_literals
+from . import base as base
+from . import twitter as twitter

src/controller/buffers/base/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+from .account import AccountBuffer
+from .base import Buffer
+from .empty import EmptyBuffer

src/controller/buffers/base/account.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+""" Common logic to all buffers in TWBlue."""
+import logging
+import config
+import widgetUtils
+from pubsub import pub
+from wxUI import buffers
+from . import base
+
+log = logging.getLogger("controller.buffers.base.account")
+
+class AccountBuffer(base.Buffer):
+    def __init__(self, parent, name, account, account_id):
+        super(AccountBuffer, self).__init__(parent, None, name)
+        log.debug("Initializing buffer %s, account %s" % (name, account,))
+        self.buffer = buffers.accountPanel(parent, name)
+        self.type = self.buffer.type
+        self.compose_function = None
+        self.session = None
+        self.needs_init = False
+        self.account = account
+        self.buffer.account = account
+        self.name = name
+        self.account_id = account_id
+
+    def setup_account(self):
+        widgetUtils.connect_event(self.buffer, widgetUtils.CHECKBOX, self.autostart, menuitem=self.buffer.autostart_account)
+        if self.account_id in config.app["sessions"]["ignored_sessions"]:
+            self.buffer.change_autostart(False)
+        else:
+            self.buffer.change_autostart(True)
+        if not hasattr(self, "logged"):
+            self.buffer.change_login(login=False)
+            widgetUtils.connect_event(self.buffer.login, widgetUtils.BUTTON_PRESSED, self.logout)
+        else:
+            self.buffer.change_login(login=True)
+            widgetUtils.connect_event(self.buffer.login, widgetUtils.BUTTON_PRESSED, self.login)
+
+    def login(self, *args, **kwargs):
+        del self.logged
+        self.setup_account()
+        pub.sendMessage("login", session_id=self.account_id)
+
+    def logout(self, *args, **kwargs):
+        self.logged = False
+        self.setup_account()
+        pub.sendMessage("logout", session_id=self.account_id)
+
+    def autostart(self, *args, **kwargs):
+        if self.account_id in config.app["sessions"]["ignored_sessions"]:
+            self.buffer.change_autostart(True)
+            config.app["sessions"]["ignored_sessions"].remove(self.account_id)
+        else:
+            self.buffer.change_autostart(False)
+            config.app["sessions"]["ignored_sessions"].append(self.account_id)
+        config.app.write()

src/controller/buffers/base/base.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+""" Common logic to all buffers in TWBlue."""
+import logging
+import wx
+import output
+import sound
+import widgetUtils
+
+log = logging.getLogger("controller.buffers.base.base")
+
+class Buffer(object):
+    """ A basic buffer object. This should be the base class for all other derived buffers."""
+
+    def __init__(self, parent=None, function=None, session=None, *args, **kwargs):
+        """Inits the main controller for this buffer:
+          @ parent wx.Treebook object: Container where we will put this buffer.
+          @ function str or None: function to be called periodically and update items on this buffer.
+          @ session sessionmanager.session object or None: Session handler for settings, database and data access.
+        """
+        super(Buffer, self).__init__()
+        self.function = function
+        # Compose_function will be used to render an object on this buffer. Normally, signature is as follows:
+        # compose_function(item, db, relative_times, show_screen_names=False, session=None)
+        # Read more about compose functions in sessions/twitter/compose.py.
+        self.compose_function = None
+        self.args = args
+        self.kwargs = kwargs
+        # This will be used as a reference to the wx.Panel object wich stores the buffer GUI.
+        self.buffer = None
+        # This should countains the account associated to this buffer.
+        self.account = ""
+        # This controls whether the start_stream function should be called when starting the program.
+        self.needs_init = True
+        # if this is set to False, the buffer will be ignored on the invisible interface.
+        self.invisible = False
+        # Control variable, used to track time of execution for calls to start_stream.
+        self.execution_time = 0
+
+    def clear_list(self):
+        pass
+
+    def get_event(self, ev):
+        """ Catch key presses in the WX interface and generate the corresponding event names."""
+        if ev.GetKeyCode() == wx.WXK_RETURN and ev.ControlDown(): event = "audio"
+        elif ev.GetKeyCode() == wx.WXK_RETURN: event = "url"
+        elif ev.GetKeyCode() == wx.WXK_F5: event = "volume_down"
+        elif ev.GetKeyCode() == wx.WXK_F6: event = "volume_up"
+        elif ev.GetKeyCode() == wx.WXK_DELETE and ev.ShiftDown(): event = "clear_list"
+        elif ev.GetKeyCode() == wx.WXK_DELETE: event = "destroy_status"
+        # Raise a Special event when pressed Shift+F10 because Wx==4.1.x does not seems to trigger this by itself.
+        # See https://github.com/manuelcortez/TWBlue/issues/353
+        elif ev.GetKeyCode() == wx.WXK_F10 and ev.ShiftDown(): event = "show_menu"
+        else:
+            event = None
+            ev.Skip()
+        if event != None:
+            try:
+                ### ToDo: Remove after WX fixes issue #353 in the widgets.
+                if event == "show_menu":
+                    return self.show_menu(widgetUtils.MENU, pos=self.buffer.list.list.GetPosition())
+                getattr(self, event)()
+            except AttributeError:
+                pass
+
+    def volume_down(self):
+        """ Decreases volume by 5%"""
+        if self.session.settings["sound"]["volume"] > 0.0:
+            if self.session.settings["sound"]["volume"] <= 0.05:
+                self.session.settings["sound"]["volume"] = 0.0
+            else:
+                self.session.settings["sound"]["volume"] -=0.05
+        sound.URLPlayer.player.audio_set_volume(int(self.session.settings["sound"]["volume"]*100.0))
+        self.session.sound.play("volume_changed.ogg")
+        self.session.settings.write()
+
+    def volume_up(self):
+        """ Increases volume by 5%."""
+        if self.session.settings["sound"]["volume"] < 1.0:
+            if self.session.settings["sound"]["volume"] >= 0.95:
+                self.session.settings["sound"]["volume"] = 1.0
+            else:
+                self.session.settings["sound"]["volume"] +=0.05
+        sound.URLPlayer.player.audio_set_volume(int(self.session.settings["sound"]["volume"]*100))
+        self.session.sound.play("volume_changed.ogg")
+        self.session.settings.write()
+
+    def start_stream(self, mandatory=False, play_sound=True):
+        pass
+
+    def get_more_items(self):
+        output.speak(_(u"This action is not supported for this buffer"), True)
+
+    def put_items_on_list(self, items):
+        pass
+
+    def remove_buffer(self):
+        return False
+
+    def remove_item(self, item):
+        f = self.buffer.list.get_selected()
+        self.buffer.list.remove_item(item)
+        self.buffer.list.select_item(f)
+
+    def bind_events(self):
+        pass
+
+    def get_object(self):
+        return self.buffer
+
+    def get_message(self):
+        pass
+
+    def set_list_position(self, reversed=False):
+        if reversed == False:
+            self.buffer.list.select_item(-1)
+        else:
+            self.buffer.list.select_item(0)
+
+    def reply(self):
+        pass
+
+    def send_message(self):
+        pass
+
+    def share_item(self):
+        pass
+
+    def destroy_status(self):
+        pass
+
+    def post_status(self, *args, **kwargs):
+        pass
+
+    def save_positions(self):
+        try:
+            self.session.db[self.name+"_pos"]=self.buffer.list.get_selected()
+        except AttributeError:
+            pass

src/controller/buffers/base/empty.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+import logging
+from wxUI import buffers
+from . import base
+
+log = logging.getLogger("controller.buffers.base.empty")
+
+class EmptyBuffer(base.Buffer):
+    def __init__(self, parent, name, account):
+        super(EmptyBuffer, self).__init__(parent=parent)
+        log.debug("Initializing buffer %s, account %s" % (name, account,))
+        self.buffer = buffers.emptyPanel(parent, name)
+        self.type = self.buffer.type
+        self.compose_function = None
+        self.account = account
+        self.buffer.account = account
+        self.name = name
+        self.session = None
+        self.needs_init = True

src/controller/buffers/baseBuffers.py

@@ -1,203 +0,0 @@
-# -*- coding: utf-8 -*-
-""" Common logic to all buffers in TWBlue."""
-from __future__ import unicode_literals
-from builtins import object
-import logging
-import wx
-import output
-import config
-import sound
-import widgetUtils
-from pubsub import pub
-from wxUI import buffers
-
-log = logging.getLogger("controller.buffers.baseBuffers")
-
-def _items_exist(function):
- """ A decorator to execute a function only if the selected buffer contains at least one item."""
- def function_(self, *args, **kwargs):
-  if self.buffer.list.get_count() > 0:
-   function(self, *args, **kwargs)
- return function_
-
-class buffer(object):
- """ A basic buffer object. This should be the base class for all other derived buffers."""
-
- def __init__(self, parent=None, function=None, session=None, *args, **kwargs):
-  """Inits the main controller for this buffer:
-    @ parent wx.Treebook object: Container where we will put this buffer.
-    @ function str or None: function to be called periodically and update items on this buffer.
-    @ session sessionmanager.session object or None: Session handler for settings, database and data access.
-  """
-  super(buffer, self).__init__()
-  self.function = function
-  # Compose_function will be used to render an object on this buffer. Normally, signature is as follows:
-  # compose_function(item, db, relative_times, show_screen_names=False, session=None)
-  # Read more about compose functions in twitter/compose.py.
-  self.compose_function = None
-  self.args = args
-  self.kwargs = kwargs
-  # This will be used as a reference to the wx.Panel object wich stores the buffer GUI.
-  self.buffer = None
-  # This should countains the account associated to this buffer.
-  self.account = ""
-  # This controls whether the start_stream function should be called when starting the program.
-  self.needs_init = True
-  # if this is set to False, the buffer will be ignored on the invisible interface.
-  self.invisible = False
-  # Control variable, used to track time of execution for calls to start_stream.
-  self.execution_time = 0
-
- def clear_list(self):
-  pass
-
- def get_event(self, ev):
-  """ Catch key presses in the WX interface and generate the corresponding event names."""
-  if ev.GetKeyCode() == wx.WXK_RETURN and ev.ControlDown(): event = "audio"
-  elif ev.GetKeyCode() == wx.WXK_RETURN: event = "url"
-  elif ev.GetKeyCode() == wx.WXK_F5: event = "volume_down"
-  elif ev.GetKeyCode() == wx.WXK_F6: event = "volume_up"
-  elif ev.GetKeyCode() == wx.WXK_DELETE and ev.ShiftDown(): event = "clear_list"
-  elif ev.GetKeyCode() == wx.WXK_DELETE: event = "destroy_status"
-  else:
-   event = None
-   ev.Skip()
-  if event != None:
-   try:
-    getattr(self, event)()
-   except AttributeError:
-    pass
- 
- def volume_down(self):
-  """ Decreases volume by 5%"""
-  if self.session.settings["sound"]["volume"] > 0.0:
-   if self.session.settings["sound"]["volume"] <= 0.05:
-    self.session.settings["sound"]["volume"] = 0.0
-   else:
-    self.session.settings["sound"]["volume"] -=0.05
-  sound.URLPlayer.player.audio_set_volume(int(self.session.settings["sound"]["volume"]*100.0))
-  self.session.sound.play("volume_changed.ogg")
-  self.session.settings.write()
-
- def volume_up(self):
-  """ Increases volume by 5%."""
-  if self.session.settings["sound"]["volume"] < 1.0:
-   if self.session.settings["sound"]["volume"] >= 0.95:
-    self.session.settings["sound"]["volume"] = 1.0
-   else:
-    self.session.settings["sound"]["volume"] +=0.05
-  sound.URLPlayer.player.audio_set_volume(int(self.session.settings["sound"]["volume"]*100))
-  self.session.sound.play("volume_changed.ogg")
-  self.session.settings.write()
-
- def start_stream(self, mandatory=False, play_sound=True):
-  pass
-
- def get_more_items(self):
-  output.speak(_(u"This action is not supported for this buffer"), True)
-
- def put_items_on_list(self, items):
-  pass
-
- def remove_buffer(self):
-  return False
-
- def remove_item(self, item):
-  f = self.buffer.list.get_selected()
-  self.buffer.list.remove_item(item)
-  self.buffer.list.select_item(f)
-
- def bind_events(self):
-  pass
-
- def get_object(self):
-  return self.buffer
-
- def get_message(self):
-  pass
-
- def set_list_position(self, reversed=False):
-  if reversed == False:
-   self.buffer.list.select_item(-1)
-  else:
-   self.buffer.list.select_item(0)
-
- def reply(self):
-  pass
-
- def send_message(self):
-  pass
-
- def share_item(self):
-  pass
-
- def destroy_status(self):
-  pass
-
- def post_status(self, *args, **kwargs):
-  pass
-
- def save_positions(self):
-  try:
-   self.session.db[self.name+"_pos"]=self.buffer.list.get_selected()
-  except AttributeError:
-   pass
-
-class accountPanel(buffer):
- def __init__(self, parent, name, account, account_id):
-  super(accountPanel, self).__init__(parent, None, name)
-  log.debug("Initializing buffer %s, account %s" % (name, account,))
-  self.buffer = buffers.accountPanel(parent, name)
-  self.type = self.buffer.type
-  self.compose_function = None
-  self.session = None
-  self.needs_init = False
-  self.account = account
-  self.buffer.account = account
-  self.name = name
-  self.account_id = account_id
-
- def setup_account(self):
-  widgetUtils.connect_event(self.buffer, widgetUtils.CHECKBOX, self.autostart, menuitem=self.buffer.autostart_account)
-  if self.account_id in config.app["sessions"]["ignored_sessions"]:
-   self.buffer.change_autostart(False)
-  else:
-   self.buffer.change_autostart(True)
-  if not hasattr(self, "logged"):
-   self.buffer.change_login(login=False)
-   widgetUtils.connect_event(self.buffer.login, widgetUtils.BUTTON_PRESSED, self.logout)
-  else:
-   self.buffer.change_login(login=True)
-   widgetUtils.connect_event(self.buffer.login, widgetUtils.BUTTON_PRESSED, self.login)
-
- def login(self, *args, **kwargs):
-  del self.logged
-  self.setup_account()
-  pub.sendMessage("login", session_id=self.account_id)
-
- def logout(self, *args, **kwargs):
-  self.logged = False
-  self.setup_account()
-  pub.sendMessage("logout", session_id=self.account_id)
-
- def autostart(self, *args, **kwargs):
-  if self.account_id in config.app["sessions"]["ignored_sessions"]:
-   self.buffer.change_autostart(True)
-   config.app["sessions"]["ignored_sessions"].remove(self.account_id)
-  else:
-   self.buffer.change_autostart(False)
-   config.app["sessions"]["ignored_sessions"].append(self.account_id)
-  config.app.write()
-
-class emptyPanel(buffer):
- def __init__(self, parent, name, account):
-  super(emptyPanel, self).__init__(parent=parent)
-  log.debug("Initializing buffer %s, account %s" % (name, account,))
-  self.buffer = buffers.emptyPanel(parent, name)
-  self.type = self.buffer.type
-  self.compose_function = None
-  self.account = account
-  self.buffer.account = account
-  self.name = name
-  self.session = None
-  self.needs_init = True

src/controller/buffers/twitter/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+from .base import BaseBuffer
+from .directMessages import DirectMessagesBuffer, SentDirectMessagesBuffer
+from .list import ListBuffer
+from .people import PeopleBuffer
+from .trends import TrendsBuffer
+from .search import SearchBuffer, SearchPeopleBuffer,  ConversationBuffer

src/controller/buffers/twitter/base.py

@@ -0,0 +1,655 @@
+# -*- coding: utf-8 -*-
+import time
+import platform
+if platform.system() == "Windows":
+    import wx
+    from wxUI import buffers, dialogs, commonMessageDialogs, menus
+    from controller import user
+elif platform.system() == "Linux":
+    from gi.repository import Gtk
+    from gtkUI import buffers, dialogs, commonMessageDialogs
+from controller import messages
+import widgetUtils
+import arrow
+import webbrowser
+import output
+import config
+import sound
+import languageHandler
+import logging
+from audio_services import youtube_utils
+from controller.buffers.base import base
+from sessions.twitter import compose, utils, reduce
+from mysc.thread_utils import call_threaded
+from tweepy.errors import TweepyException
+from tweepy.cursor import Cursor
+from pubsub import pub
+from sessions.twitter.long_tweets import twishort, tweets
+
+log = logging.getLogger("controller.buffers")
+
+def _tweets_exist(function):
+    """ A decorator to execute a function only if the selected buffer contains at least one item."""
+    def function_(self, *args, **kwargs):
+        if self.buffer.list.get_count() > 0:
+            function(self, *args, **kwargs)
+    return function_
+
+class BaseBuffer(base.Buffer):
+    def __init__(self, parent, function, name, sessionObject, account, sound=None, bufferType=None, compose_func="compose_tweet", *args, **kwargs):
+        super(BaseBuffer, self).__init__(parent, function, *args, **kwargs)
+        log.debug("Initializing buffer %s, account %s" % (name, account,))
+        if bufferType != None:
+            self.buffer = getattr(buffers, bufferType)(parent, name)
+        else:
+            self.buffer = buffers.basePanel(parent, name)
+        self.invisible = True
+        self.name = name
+        self.type = self.buffer.type
+        self.session = sessionObject
+        self.compose_function = getattr(compose, compose_func)
+        log.debug("Compose_function: %s" % (self.compose_function,))
+        self.account = account
+        self.buffer.account = account
+        self.bind_events()
+        self.sound = sound
+        if "-timeline" in self.name or "-favorite" in self.name:
+            self.finished_timeline = False
+            # Add a compatibility layer for username based timelines from config.
+            # ToDo: Remove this in some new versions of the client, when user ID timelines become mandatory.
+            try:
+                int(self.kwargs["user_id"])
+            except ValueError:
+                self.is_screen_name = True
+                self.kwargs["screen_name"] = self.kwargs["user_id"]
+                self.kwargs.pop("user_id")
+
+    def get_buffer_name(self):
+        """ Get buffer name from a set of different techniques."""
+        # firstly let's take the easier buffers.
+        basic_buffers = dict(home_timeline=_(u"Home"), mentions=_(u"Mentions"), direct_messages=_(u"Direct messages"), sent_direct_messages=_(u"Sent direct messages"), sent_tweets=_(u"Sent tweets"), favourites=_(u"Likes"), followers=_(u"Followers"), friends=_(u"Friends"), blocked=_(u"Blocked users"), muted=_(u"Muted users"))
+        if self.name in list(basic_buffers.keys()):
+            return basic_buffers[self.name]
+        # Check user timelines
+        elif hasattr(self, "username"):
+            if "-timeline" in self.name:
+                return _(u"{username}'s timeline").format(username=self.username,)
+            elif "-favorite" in self.name:
+                return _(u"{username}'s likes").format(username=self.username,)
+            elif "-followers" in self.name:
+                return _(u"{username}'s followers").format(username=self.username,)
+            elif "-friends" in self.name:
+                return _(u"{username}'s friends").format(username=self.username,)
+        log.error("Error getting name for buffer %s" % (self.name,))
+        return _(u"Unknown buffer")
+
+    def post_status(self, *args, **kwargs):
+        item = None
+        title = _(u"Tweet")
+        caption = _(u"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"])
+
+    def get_formatted_message(self):
+        if self.type == "dm" or self.name == "direct_messages":
+            return self.compose_function(self.get_right_tweet(), self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"], self.session)[1]
+        return self.get_message()
+
+    def get_message(self):
+        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))
+
+    def get_full_tweet(self):
+        tweet = self.get_right_tweet()
+        tweetsList = []
+        tweet_id = tweet.id
+        message = None
+        if hasattr(tweet, "message"):
+            message = tweet.message
+        try:
+            tweet = self.session.twitter.get_status(id=tweet_id, include_ext_alt_text=True, tweet_mode="extended")
+            tweet.full_text = utils.expand_urls(tweet.full_text, tweet.entities)
+        except TweepyException as e:
+            utils.twitter_error(e)
+            return
+        if message != None:
+            tweet.message = message
+        l = tweets.is_long(tweet)
+        while l != False:
+            tweetsList.append(tweet)
+            try:
+                tweet = self.session.twitter.get_status(id=l, include_ext_alt_text=True, tweet_mode="extended")
+                tweet.full_text = utils.expand_urls(tweet.full_text, tweet.entities)
+            except TweepyException as e:
+                utils.twitter_error(e)
+                return
+            l = tweets.is_long(tweet)
+            if l == False:
+                tweetsList.append(tweet)
+        return (tweet, tweetsList)
+
+    def start_stream(self, mandatory=False, play_sound=True, avoid_autoreading=False):
+        # starts stream every 3 minutes.
+        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("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)
+            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
+                if self.session.settings["general"]["max_tweets_per_call"] > 50:
+                    count = 50
+                else:
+                    count = self.session.settings["general"]["max_tweets_per_call"]
+                # try to retrieve the cursor for the current buffer.
+                try:
+                    val = getattr(self.session.twitter, self.function)(return_cursors=True, count=count, *self.args, **self.kwargs)
+                    if type(val) == tuple:
+                        val, cursor = val
+                        if type(cursor) == tuple:
+                            cursor = cursor[1]
+                        cursors = self.session.db["cursors"]
+                        cursors[self.name] = cursor
+                        self.session.db["cursors"] = cursors
+                    results = [i for i in val]
+                    val = results
+                    val.reverse()
+                    log.debug("Retrieved %d items from the cursored search on function %s." %(len(val), self.function))
+                    user_ids = [item.message_create["sender_id"] for item in val]
+                    self.session.save_users(user_ids)
+                except TweepyException as e:
+                    log.exception("Error %s" % (str(e)))
+                    return
+            number_of_items = self.session.order_buffer(self.name, val)
+            log.debug("Number of items retrieved: %d" % (number_of_items,))
+            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
+                elif "-favorite" in self.name:
+                    self.username = self.session.api_call("get_user", **self.kwargs).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)
+            # Autoread settings
+            if avoid_autoreading == False and mandatory == True and number_of_items > 0 and self.name in self.session.settings["other_buffers"]["autoread_buffers"]:
+                self.auto_read(number_of_items)
+            return number_of_items
+
+    def auto_read(self, number_of_items):
+        if number_of_items == 1 and self.name in self.session.settings["other_buffers"]["autoread_buffers"] and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and self.session.settings["sound"]["session_mute"] == False:
+            if self.session.settings["general"]["reverse_timelines"] == False:
+                tweet = self.session.db[self.name][-1]
+            else:
+                tweet = self.session.db[self.name][0]
+            output.speak(_(u"New tweet in {0}").format(self.get_buffer_name()))
+            output.speak(" ".join(self.compose_function(tweet, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"], self.session)))
+        elif number_of_items > 1 and self.name in self.session.settings["other_buffers"]["autoread_buffers"] and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and self.session.settings["sound"]["session_mute"] == False:
+            output.speak(_(u"{0} new tweets in {1}.").format(number_of_items, self.get_buffer_name()))
+
+    def get_more_items(self):
+        elements = []
+        if self.session.settings["general"]["reverse_timelines"] == False:
+            last_id = self.session.db[self.name][0].id
+        else:
+            last_id = self.session.db[self.name][-1].id
+        try:
+            items = getattr(self.session.twitter, self.function)(max_id=last_id, count=self.session.settings["general"]["max_tweets_per_call"], *self.args, **self.kwargs)
+        except TweepyException as e:
+            log.exception("Error %s" % (str(e)))
+            return
+        if items == None:
+            return
+        items_db = self.session.db[self.name]
+        self.session.add_users_from_results(items)
+        for i in items:
+            if utils.is_allowed(i, self.session.settings, self.name) == True and utils.find_item(i, self.session.db[self.name]) == None:
+                i = reduce.reduce_tweet(i)
+                i = self.session.check_quoted_status(i)
+                i = self.session.check_long_tweet(i)
+                elements.append(i)
+                if self.session.settings["general"]["reverse_timelines"] == False:
+                    items_db.insert(0, i)
+                else:
+                    items_db.append(i)
+        self.session.db[self.name] = items_db
+        selection = self.buffer.list.get_selected()
+        log.debug("Retrieved %d items from cursored search in function %s." % (len(elements), self.function))
+        if self.session.settings["general"]["reverse_timelines"] == False:
+            for i in elements:
+                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(True, *tweet)
+        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.select_item(selection)
+        output.speak(_(u"%s items retrieved") % (str(len(elements))), True)
+
+    def remove_buffer(self, force=False):
+        if "-timeline" in self.name:
+            if force == False:
+                dlg = commonMessageDialogs.remove_buffer()
+            else:
+                dlg = widgetUtils.YES
+            if dlg == widgetUtils.YES:
+                if self.name[:-9] in self.session.settings["other_buffers"]["timelines"]:
+                    self.session.settings["other_buffers"]["timelines"].remove(self.name[:-9])
+                    self.session.settings.write()
+                    if self.name in self.session.db:
+                        self.session.db.pop(self.name)
+                    return True
+            elif dlg == widgetUtils.NO:
+                return False
+        elif "favorite" in self.name:
+            if force == False:
+                dlg = commonMessageDialogs.remove_buffer()
+            else:
+                dlg = widgetUtils.YES
+            if dlg == widgetUtils.YES:
+                if self.name[:-9] in self.session.settings["other_buffers"]["favourites_timelines"]:
+                    self.session.settings["other_buffers"]["favourites_timelines"].remove(self.name[:-9])
+                    if self.name in self.session.db:
+                        self.session.db.pop(self.name)
+                    self.session.settings.write()
+                    return True
+            elif dlg == widgetUtils.NO:
+                return False
+        else:
+            output.speak(_(u"This buffer is not a timeline; it can't be deleted."), True)
+            return False
+
+    def remove_tweet(self, id):
+        if type(self.session.db[self.name]) == dict: return
+        items = self.session.db[self.name]
+        for i in range(0, len(items)):
+            if items[i].id == id:
+                items.pop(i)
+                self.remove_item(i)
+        self.session.db[self.name] = items
+
+    def put_items_on_list(self, number_of_items):
+        list_to_use = self.session.db[self.name]
+        if number_of_items == 0 and self.session.settings["general"]["persist_size"] == 0: return
+        log.debug("The list contains %d items " % (self.buffer.list.get_count(),))
+        log.debug("Putting %d items on the list" % (number_of_items,))
+        if self.buffer.list.get_count() == 0:
+            for i in list_to_use:
+                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.set_position(self.session.settings["general"]["reverse_timelines"])
+        elif self.buffer.list.get_count() > 0 and number_of_items > 0:
+            if self.session.settings["general"]["reverse_timelines"] == False:
+                items = list_to_use[len(list_to_use)-number_of_items:]
+                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)
+            else:
+                items = list_to_use[0:number_of_items]
+                items.reverse()
+                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(True, *tweet)
+        log.debug("Now the list contains %d items " % (self.buffer.list.get_count(),))
+
+    def add_new_item(self, item):
+        tweet = self.compose_function(item, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"], self.session)
+        if self.session.settings["general"]["reverse_timelines"] == False:
+            self.buffer.list.insert_item(False, *tweet)
+        else:
+            self.buffer.list.insert_item(True, *tweet)
+        if self.name in self.session.settings["other_buffers"]["autoread_buffers"] and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and self.session.settings["sound"]["session_mute"] == False:
+            output.speak(" ".join(tweet[:2]), speech=self.session.settings["reporting"]["speech_reporting"], braille=self.session.settings["reporting"]["braille_reporting"])
+        #Improve performance on Windows
+#  if platform.system() == "Windows":
+#   call_threaded(utils.is_audio,item)
+
+    def bind_events(self):
+        log.debug("Binding events...")
+        self.buffer.set_focus_function(self.onFocus)
+        widgetUtils.connect_event(self.buffer.list.list, widgetUtils.KEYPRESS, self.get_event)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.post_status, self.buffer.tweet)
+#  if self.type == "baseBuffer":
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.share_item, self.buffer.retweet)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.send_message, self.buffer.dm)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.reply, self.buffer.reply)
+        # Replace for the correct way in other platforms.
+        widgetUtils.connect_event(self.buffer.list.list, wx.EVT_LIST_ITEM_RIGHT_CLICK, self.show_menu)
+        widgetUtils.connect_event(self.buffer.list.list, wx.EVT_LIST_KEY_DOWN, self.show_menu_by_key)
+
+    def show_menu(self, ev, pos=0, *args, **kwargs):
+        if self.buffer.list.get_count() == 0: return
+        if self.name == "sent_tweets" or self.name == "direct_messages":
+            menu = menus.sentPanelMenu()
+        elif self.name == "direct_messages":
+            menu = menus.dmPanelMenu()
+            widgetUtils.connect_event(menu, widgetUtils.MENU, self.send_message, menuitem=menu.reply)
+            widgetUtils.connect_event(menu, widgetUtils.MENU, self.user_actions, menuitem=menu.userActions)
+        else:
+            menu = menus.basePanelMenu()
+            widgetUtils.connect_event(menu, widgetUtils.MENU, self.reply, menuitem=menu.reply)
+            widgetUtils.connect_event(menu, widgetUtils.MENU, self.user_actions, menuitem=menu.userActions)
+            widgetUtils.connect_event(menu, widgetUtils.MENU, self.share_item, menuitem=menu.retweet)
+            widgetUtils.connect_event(menu, widgetUtils.MENU, self.fav, menuitem=menu.fav)
+            widgetUtils.connect_event(menu, widgetUtils.MENU, self.unfav, menuitem=menu.unfav)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.url_, menuitem=menu.openUrl)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.audio, menuitem=menu.play)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.view, menuitem=menu.view)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.copy, menuitem=menu.copy)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.destroy_status, menuitem=menu.remove)
+        if hasattr(menu, "openInBrowser"):
+            widgetUtils.connect_event(menu, widgetUtils.MENU, self.open_in_browser, menuitem=menu.openInBrowser)
+        if pos != 0:
+            self.buffer.PopupMenu(menu, pos)
+        else:
+            self.buffer.PopupMenu(menu, ev.GetPosition())
+
+    def view(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="view_item")
+
+    def copy(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="copy_to_clipboard")
+
+    def user_actions(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="follow")
+
+    def fav(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="add_to_favourites")
+
+    def unfav(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="remove_from_favourites")
+
+    def delete_item_(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="delete_item")
+
+    def url_(self, *args, **kwargs):
+        self.url()
+
+    def show_menu_by_key(self, ev):
+        if self.buffer.list.get_count() == 0:
+            return
+        if ev.GetKeyCode() == wx.WXK_WINDOWS_MENU:
+            self.show_menu(widgetUtils.MENU, pos=self.buffer.list.list.GetPosition())
+
+    def get_tweet(self):
+        if hasattr(self.session.db[self.name][self.buffer.list.get_selected()], "retweeted_status"):
+            tweet = self.session.db[self.name][self.buffer.list.get_selected()].retweeted_status
+        else:
+            tweet = self.session.db[self.name][self.buffer.list.get_selected()]
+        return tweet
+
+    def get_right_tweet(self):
+        tweet = self.session.db[self.name][self.buffer.list.get_selected()]
+        return tweet
+
+    @_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
+        if len(users) < 1:
+            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:
+            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.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"])
+        if hasattr(message.message, "destroy"): message.message.destroy()
+        self.session.settings.write()
+
+    @_tweets_exist
+    def send_message(self, *args, **kwargs):
+        tweet = self.get_right_tweet()
+        if self.type == "dm":
+            screen_name = self.session.get_user(tweet.message_create["sender_id"]).screen_name
+            users = [screen_name]
+        elif self.type == "people":
+            screen_name = tweet.screen_name
+            users = [screen_name]
+        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")
+            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"])
+        if hasattr(dm.message, "destroy"): dm.message.destroy()
+
+    @_tweets_exist
+    def share_item(self, *args, **kwargs):
+        tweet = self.get_right_tweet()
+        id = tweet.id
+        if self.session.settings["general"]["retweet_mode"] == "ask":
+            answer = commonMessageDialogs.retweet_question(self.buffer)
+            if answer == widgetUtils.YES:
+                self._retweet_with_comment(tweet, id)
+            elif answer == widgetUtils.NO:
+                self._direct_retweet(id)
+        elif self.session.settings["general"]["retweet_mode"] == "direct":
+            self._direct_retweet(id)
+        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.
+        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()
+
+    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()
+        if platform.system() == "Windows" and self.session.settings["general"]["relative_times"] == True:
+            # fix this:
+            original_date = arrow.get(self.session.db[self.name][self.buffer.list.get_selected()].created_at, locale="en")
+            ts = original_date.humanize(locale=languageHandler.getLanguage())
+            self.buffer.list.list.SetItem(self.buffer.list.get_selected(), 2, ts)
+        if self.session.settings['sound']['indicate_audio'] and utils.is_audio(tweet):
+            self.session.sound.play("audio.ogg")
+        if self.session.settings['sound']['indicate_geo'] and utils.is_geocoded(tweet):
+            self.session.sound.play("geo.ogg")
+        if self.session.settings['sound']['indicate_img'] and utils.is_media(tweet):
+            self.session.sound.play("image.ogg")
+
+    def audio(self, url='', *args, **kwargs):
+        if sound.URLPlayer.player.is_playing():
+            return sound.URLPlayer.stop_audio()
+        tweet = self.get_tweet()
+        if tweet == None: return
+        urls = utils.find_urls(tweet, twitter_media=True)
+        if len(urls) == 1:
+            url=urls[0]
+        elif len(urls) > 1:
+            urls_list = dialogs.urlList.urlList()
+            urls_list.populate_list(urls)
+            if urls_list.get_response() == widgetUtils.OK:
+                url=urls_list.get_string()
+            if hasattr(urls_list, "destroy"): urls_list.destroy()
+        if url != '':
+            #   try:
+            sound.URLPlayer.play(url, self.session.settings["sound"]["volume"])
+#   except:
+#    log.error("Exception while executing audio method.")
+
+# @_tweets_exist
+    def url(self, url='', announce=True, *args, **kwargs):
+        if url == '':
+            tweet = self.get_tweet()
+            urls = utils.find_urls(tweet)
+            if len(urls) == 1:
+                url=urls[0]
+            elif len(urls) > 1:
+                urls_list = dialogs.urlList.urlList()
+                urls_list.populate_list(urls)
+                if urls_list.get_response() == widgetUtils.OK:
+                    url=urls_list.get_string()
+                if hasattr(urls_list, "destroy"): urls_list.destroy()
+            if url != '':
+                if announce:
+                    output.speak(_(u"Opening URL..."), True)
+                webbrowser.open_new_tab(url)
+
+    def clear_list(self):
+        dlg = commonMessageDialogs.clear_list()
+        if dlg == widgetUtils.YES:
+            self.session.db[self.name] = []
+            self.buffer.list.clear()
+
+    @_tweets_exist
+    def destroy_status(self, *args, **kwargs):
+        index = self.buffer.list.get_selected()
+        if self.type == "events" or self.type == "people" or self.type == "empty" or self.type == "account": return
+        answer = commonMessageDialogs.delete_tweet_dialog(None)
+        if answer == widgetUtils.YES:
+            items = self.session.db[self.name]
+            try:
+                if self.name == "direct_messages" or self.name == "sent_direct_messages":
+                    self.session.twitter.delete_direct_message(id=self.get_right_tweet().id)
+                    items.pop(index)
+                else:
+                    self.session.twitter.destroy_status(id=self.get_right_tweet().id)
+                    items.pop(index)
+                self.buffer.list.remove_item(index)
+            except TweepyException:
+                self.session.sound.play("error.ogg")
+            self.session.db[self.name] = items
+
+    @_tweets_exist
+    def user_details(self):
+        tweet = self.get_right_tweet()
+        if self.type == "dm":
+            users = [self.session.get_user(tweet.message_create["sender_id"]).screen_name]
+        elif self.type == "people":
+            users = [tweet.screen_name]
+        else:
+            users = utils.get_all_users(tweet, self.session)
+        dlg = dialogs.utils.selectUserDialog(title=_(u"User details"), users=users)
+        if dlg.get_response() == widgetUtils.OK:
+            user.profileController(session=self.session, user=dlg.get_user())
+        if hasattr(dlg, "destroy"): dlg.destroy()
+
+    def get_quoted_tweet(self, tweet):
+        quoted_tweet = self.session.twitter.get_status(id=tweet.id)
+        quoted_tweet.text = utils.find_urls_in_text(quoted_tweet.text, quoted_tweet.entities)
+        l = tweets.is_long(quoted_tweet)
+        id = tweets.get_id(l)
+        original_tweet = self.session.twitter.get_status(id=id)
+        original_tweet.text = utils.find_urls_in_text(original_tweet.text, original_tweet.entities)
+        return compose.compose_quoted_tweet(quoted_tweet, original_tweet, self.session.db, self.session.settings["general"]["relative_times"])
+
+    def get_item_url(self):
+        tweet = self.get_tweet()
+        url = "https://twitter.com/{screen_name}/status/{tweet_id}".format(screen_name=self.session.get_user(tweet.user).screen_name, tweet_id=tweet.id)
+        return url
+
+    def open_in_browser(self, *args, **kwargs):
+        url = self.get_item_url()
+        output.speak(_(u"Opening item in web browser..."))
+        webbrowser.open(url)

src/controller/buffers/twitter/directMessages.py

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+import platform
+import widgetUtils
+import arrow
+import webbrowser
+import output
+import config
+import languageHandler
+import logging
+from controller import messages
+from sessions.twitter import compose, utils
+from mysc.thread_utils import call_threaded
+from tweepy.errors import TweepyException
+from pubsub import pub
+from . import base
+
+log = logging.getLogger("controller.buffers.twitter.dmBuffer")
+
+class DirectMessagesBuffer(base.BaseBuffer):
+
+    def get_more_items(self):
+        # 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
+        if self.session.settings["general"]["max_tweets_per_call"] > 50:
+            count = 50
+        else:
+            count = self.session.settings["general"]["max_tweets_per_call"]
+        total = 0
+        # try to retrieve the cursor for the current buffer.
+        cursor = self.session.db["cursors"].get(self.name)
+        try:
+            items = getattr(self.session.twitter, self.function)(return_cursors=True, cursor=cursor, count=count, *self.args, **self.kwargs)
+            if type(items) == tuple:
+                items, cursor = items
+                if type(cursor) == tuple:
+                    cursor = cursor[1]
+                cursors = self.session.db["cursors"]
+                cursors[self.name] = cursor
+                self.session.db["cursors"] = cursors
+            results = [i for i in items]
+            items = results
+            log.debug("Retrieved %d items for cursored search in function %s" % (len(items), self.function))
+        except TweepyException as e:
+            log.exception("Error %s" % (str(e)))
+            return
+        if items == None:
+            return
+        sent = []
+        received = []
+        sent_dms = self.session.db["sent_direct_messages"]
+        received_dms = self.session.db["direct_messages"]
+        for i in items:
+            if int(i.message_create["sender_id"]) == self.session.db["user_id"]:
+                if self.session.settings["general"]["reverse_timelines"] == False:
+                    sent_dms.insert(0, i)
+                    sent.append(i)
+                else:
+                    sent_dms.append(i)
+                    sent.insert(0, i)
+            else:
+                if self.session.settings["general"]["reverse_timelines"] == False:
+                    received_dms.insert(0, i)
+                    received.append(i)
+                else:
+                    received_dms.append(i)
+                    received.insert(0, i)
+            total = total+1
+        self.session.db["direct_messages"] = received_dms
+        self.session.db["sent_direct_messages"] = sent_dms
+        user_ids = [item.message_create["sender_id"] for item in items]
+        self.session.save_users(user_ids)
+        pub.sendMessage("more-sent-dms", data=sent, account=self.session.db["user_name"])
+        selected = self.buffer.list.get_selected()
+        if self.session.settings["general"]["reverse_timelines"] == True:
+            for i in received:
+                if int(i.message_create["sender_id"]) == self.session.db["user_id"]:
+                    continue
+                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(True, *tweet)
+            self.buffer.list.select_item(selected)
+        else:
+            for i in received:
+                if int(i.message_create["sender_id"]) == self.session.db["user_id"]:
+                    continue
+                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(True, *tweet)
+        output.speak(_(u"%s items retrieved") % (total), True)
+
+    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()
+
+    def onFocus(self, *args, **kwargs):
+        tweet = self.get_tweet()
+        if platform.system() == "Windows" and self.session.settings["general"]["relative_times"] == True:
+            # fix this:
+            original_date = arrow.get(int(tweet.created_timestamp))
+            ts = original_date.humanize(locale=languageHandler.getLanguage())
+            self.buffer.list.list.SetItem(self.buffer.list.get_selected(), 2, ts)
+        if self.session.settings['sound']['indicate_audio'] and utils.is_audio(tweet):
+            self.session.sound.play("audio.ogg")
+        if self.session.settings['sound']['indicate_img'] and utils.is_media(tweet):
+            self.session.sound.play("image.ogg")
+
+    def clear_list(self):
+        dlg = commonMessageDialogs.clear_list()
+        if dlg == widgetUtils.YES:
+            self.session.db[self.name] = []
+            self.buffer.list.clear()
+
+    def auto_read(self, number_of_items):
+        if number_of_items == 1 and self.name in self.session.settings["other_buffers"]["autoread_buffers"] and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and self.session.settings["sound"]["session_mute"] == False:
+            if self.session.settings["general"]["reverse_timelines"] == False:
+                tweet = self.session.db[self.name][-1]
+            else:
+                tweet = self.session.db[self.name][0]
+            output.speak(_(u"New direct message"))
+            output.speak(" ".join(self.compose_function(tweet, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"], self.session)))
+        elif number_of_items > 1 and self.name in self.session.settings["other_buffers"]["autoread_buffers"] and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and self.session.settings["sound"]["session_mute"] == False:
+            output.speak(_(u"{0} new direct messages.").format(number_of_items,))
+
+    def open_in_browser(self, *args, **kwargs):
+        output.speak(_(u"This action is not supported in the buffer yet."))
+
+class SentDirectMessagesBuffer(DirectMessagesBuffer):
+
+    def __init__(self, *args, **kwargs):
+        super(SentDirectMessagesBuffer, self).__init__(*args, **kwargs)
+        if ("sent_direct_messages" in self.session.db) == False:
+            self.session.db["sent_direct_messages"] = []
+
+    def get_more_items(self):
+        output.speak(_(u"Getting more items cannot be done in this buffer. Use the direct messages buffer instead."))
+
+    def start_stream(self, *args, **kwargs):
+        pass
+
+    def put_more_items(self, items):
+        if self.session.settings["general"]["reverse_timelines"] == True:
+            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)
+        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)

src/controller/buffers/twitter/list.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+import platform
+if platform.system() == "Windows":
+    from wxUI import dialogs, commonMessageDialogs
+elif platform.system() == "Linux":
+    from gi.repository import Gtk
+    from gtkUI import dialogs, commonMessageDialogs
+import widgetUtils
+import logging
+from tweepy.cursor import Cursor
+from . import base
+
+log = logging.getLogger("controller.buffers.twitter.listBuffer")
+
+class ListBuffer(base.BaseBuffer):
+    def __init__(self, parent, function, name, sessionObject, account, sound=None, bufferType=None, list_id=None, *args, **kwargs):
+        super(ListBuffer, self).__init__(parent, function, name, sessionObject, account, sound=None, bufferType=None, *args, **kwargs)
+        self.users = []
+        self.list_id = list_id
+        self.kwargs["list_id"] = list_id
+
+    def start_stream(self, mandatory=False, play_sound=True, avoid_autoreading=False):
+        self.get_user_ids()
+        super(ListBuffer, self).start_stream(mandatory, play_sound, avoid_autoreading)
+
+    def get_user_ids(self):
+        for i in Cursor(self.session.twitter.get_list_members, list_id=self.list_id, include_entities=False, skip_status=True, count=5000).items():
+            if i.id not in self.users:
+                self.users.append(i.id)
+
+    def remove_buffer(self, force=False):
+        if force == False:
+            dlg = commonMessageDialogs.remove_buffer()
+        else:
+            dlg = widgetUtils.YES
+        if dlg == widgetUtils.YES:
+            if self.name[:-5] in self.session.settings["other_buffers"]["lists"]:
+                self.session.settings["other_buffers"]["lists"].remove(self.name[:-5])
+                if self.name in self.session.db:
+                    self.session.db.pop(self.name)
+                self.session.settings.write()
+                return True
+        elif dlg == widgetUtils.NO:
+            return False

src/controller/buffers/twitter/people.py

@@ -0,0 +1,258 @@
+# -*- coding: utf-8 -*-
+import time
+import platform
+if platform.system() == "Windows":
+    from wxUI import commonMessageDialogs, menus
+    from controller import user
+elif platform.system() == "Linux":
+    from gi.repository import Gtk
+    from gtkUI import dialogs, commonMessageDialogs
+from controller import messages
+import widgetUtils
+import webbrowser
+import output
+import config
+import logging
+from mysc.thread_utils import call_threaded
+from tweepy.errors import TweepyException
+from pubsub import pub
+from sessions.twitter import compose
+from . import base
+
+log = logging.getLogger("controller.buffers.twitter.peopleBuffer")
+
+def _tweets_exist(function):
+    """ A decorator to execute a function only if the selected buffer contains at least one item."""
+    def function_(self, *args, **kwargs):
+        if self.buffer.list.get_count() > 0:
+            function(self, *args, **kwargs)
+    return function_
+
+class PeopleBuffer(base.BaseBuffer):
+    def __init__(self, parent, function, name, sessionObject, account, bufferType=None, *args, **kwargs):
+        super(PeopleBuffer, self).__init__(parent, function, name, sessionObject, account, bufferType="peoplePanel", *args, **kwargs)
+        log.debug("Initializing buffer %s, account %s" % (name, account,))
+        self.compose_function = compose.compose_followers_list
+        log.debug("Compose_function: %s" % (self.compose_function,))
+        self.get_tweet = self.get_right_tweet
+        self.url = self.interact
+        if "-followers" in self.name or "-friends" in self.name:
+            self.finished_timeline = False
+            # Add a compatibility layer for username based timelines from config.
+            # ToDo: Remove this in some new versions of the client, when user ID timelines become mandatory.
+            try:
+                int(self.kwargs["user_id"])
+            except ValueError:
+                self.is_screen_name = True
+                self.kwargs["screen_name"] = self.kwargs["user_id"]
+                self.kwargs.pop("user_id")
+
+    def remove_buffer(self, force=True):
+        if "-followers" in self.name:
+            if force == False:
+                dlg = commonMessageDialogs.remove_buffer()
+            else:
+                dlg = widgetUtils.YES
+            if dlg == widgetUtils.YES:
+                if self.name[:-10] in self.session.settings["other_buffers"]["followers_timelines"]:
+                    self.session.settings["other_buffers"]["followers_timelines"].remove(self.name[:-10])
+                    if self.name in self.session.db:
+                        self.session.db.pop(self.name)
+                    self.session.settings.write()
+                    return True
+            elif dlg == widgetUtils.NO:
+                return False
+        elif "-friends" in self.name:
+            if force == False:
+                dlg = commonMessageDialogs.remove_buffer()
+            else:
+                dlg = widgetUtils.YES
+            if dlg == widgetUtils.YES:
+                if self.name[:-8] in self.session.settings["other_buffers"]["friends_timelines"]:
+                    self.session.settings["other_buffers"]["friends_timelines"].remove(self.name[:-8])
+                    if self.name in self.session.db:
+                        self.session.db.pop(self.name)
+                    self.session.settings.write()
+                    return True
+            elif dlg == widgetUtils.NO:
+                return False
+        else:
+            output.speak(_(u"This buffer is not a timeline; it can't be deleted."), True)
+            return False
+
+    def onFocus(self, ev):
+        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))
+
+    def delete_item(self): pass
+
+    @_tweets_exist
+    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()
+
+    def start_stream(self, mandatory=False, play_sound=True, avoid_autoreading=False):
+        # starts stream every 3 minutes.
+        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("Starting stream for %s buffer, %s account" % (self.name, self.account,))
+            log.debug("args: %s, kwargs: %s" % (self.args, self.kwargs))
+            try:
+                val = getattr(self.session.twitter, self.function)(return_cursors=True, count=self.session.settings["general"]["max_tweets_per_call"], *self.args, **self.kwargs)
+                if type(val) == tuple:
+                    val, cursor = val
+                    if type(cursor) == tuple:
+                        cursor = cursor[1]
+                    cursors = self.session.db["cursors"]
+                    cursors[self.name] = cursor
+                    self.session.db["cursors"] = cursors
+                results = [i for i in val]
+                val = results
+                val.reverse()
+                log.debug("Retrieved %d items from cursored search in function %s" % (len(val), self.function))
+            except TweepyException as e:
+                log.exception("Error %s" % (str(e)))
+                return
+            number_of_items = self.session.order_people(self.name, val)
+            log.debug("Number of items retrieved: %d" % (number_of_items,))
+            self.put_items_on_list(number_of_items)
+            if hasattr(self, "finished_timeline") and self.finished_timeline == False:
+                self.username = self.session.api_call("get_user", **self.kwargs).screen_name
+                self.finished_timeline = True
+            if number_of_items > 0 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)
+            # Autoread settings
+            if avoid_autoreading == False and mandatory == True and number_of_items > 0 and self.name in self.session.settings["other_buffers"]["autoread_buffers"]:
+                self.auto_read(number_of_items)
+            return number_of_items
+
+    def get_more_items(self):
+        try:
+            cursor = self.session.db["cursors"].get(self.name)
+            items = getattr(self.session.twitter, self.function)(return_cursors=True, users=True, cursor=cursor, count=self.session.settings["general"]["max_tweets_per_call"], *self.args, **self.kwargs)
+            if type(items) == tuple:
+                items, cursor = items
+                if type(cursor) == tuple:
+                    cursor = cursor[1]
+                cursors = self.session.db["cursors"]
+                cursors[self.name] = cursor
+                self.session.db["cursors"] = cursors
+            results = [i for i in items]
+            items = results
+            log.debug("Retrieved %d items from cursored search in function %s" % (len(items), self.function))
+        except TweepyException as e:
+            log.exception("Error %s" % (str(e)))
+            return
+        if items == None:
+            return
+        items_db = self.session.db[self.name]
+        for i in items:
+            if self.session.settings["general"]["reverse_timelines"] == False:
+                items_db.insert(0, i)
+            else:
+                items_db.append(i)
+        self.session.db[self.name] = items_db
+        selected = self.buffer.list.get_selected()
+        if self.session.settings["general"]["reverse_timelines"] == True:
+            for i in items:
+                tweet = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session)
+                self.buffer.list.insert_item(True, *tweet)
+            self.buffer.list.select_item(selected)
+        else:
+            for i in items:
+                tweet = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session)
+                self.buffer.list.insert_item(True, *tweet)
+        output.speak(_(u"%s items retrieved") % (len(items)), True)
+
+    def put_items_on_list(self, number_of_items):
+        log.debug("The list contains %d items" % (self.buffer.list.get_count(),))
+#  log.debug("Putting %d items on the list..." % (number_of_items,))
+        if self.buffer.list.get_count() == 0:
+            for i in self.session.db[self.name]:
+                tweet = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session)
+                self.buffer.list.insert_item(False, *tweet)
+            self.buffer.set_position(self.session.settings["general"]["reverse_timelines"])
+#   self.buffer.set_list_position()
+        elif self.buffer.list.get_count() > 0:
+            if self.session.settings["general"]["reverse_timelines"] == False:
+                for i in self.session.db[self.name][len(self.session.db[self.name])-number_of_items:]:
+                    tweet = self.compose_function(i, self.session.db)
+                    self.buffer.list.insert_item(False, *tweet)
+            else:
+                items = self.session.db[self.name][0:number_of_items]
+                items.reverse()
+                for i in items:
+                    tweet = self.compose_function(i, self.session.db)
+                    self.buffer.list.insert_item(True, *tweet)
+        log.debug("now the list contains %d items" % (self.buffer.list.get_count(),))
+
+    def get_right_tweet(self):
+        tweet = self.session.db[self.name][self.buffer.list.get_selected()]
+        return tweet
+
+    def add_new_item(self, item):
+        tweet = self.compose_function(item, self.session.db, self.session.settings["general"]["relative_times"], self.session)
+        if self.session.settings["general"]["reverse_timelines"] == False:
+            self.buffer.list.insert_item(False, *tweet)
+        else:
+            self.buffer.list.insert_item(True, *tweet)
+        if self.name in self.session.settings["other_buffers"]["autoread_buffers"] and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and self.session.settings["sound"]["session_mute"] == False:
+            output.speak(" ".join(tweet))
+
+    def clear_list(self):
+        dlg = commonMessageDialogs.clear_list()
+        if dlg == widgetUtils.YES:
+            self.session.db[self.name] = []
+            self.session.db["cursors"][self.name] = -1
+            self.buffer.list.clear()
+
+    def interact(self):
+        user.profileController(self.session, user=self.get_right_tweet().screen_name)
+
+    def show_menu(self, ev, pos=0, *args, **kwargs):
+        menu = menus.peoplePanelMenu()
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.send_message, menuitem=menu.reply)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.user_actions, menuitem=menu.userActions)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.details, menuitem=menu.details)
+#  widgetUtils.connect_event(menu, widgetUtils.MENU, self.lists, menuitem=menu.lists)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.view, menuitem=menu.view)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.copy, menuitem=menu.copy)
+        if hasattr(menu, "openInBrowser"):
+            widgetUtils.connect_event(menu, widgetUtils.MENU, self.open_in_browser, menuitem=menu.openInBrowser)
+        if pos != 0:
+            self.buffer.PopupMenu(menu, pos)
+        else:
+            self.buffer.PopupMenu(menu, ev.GetPosition())
+
+    def details(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="user_details")
+
+    def auto_read(self, number_of_items):
+        if number_of_items == 1 and self.name in self.session.settings["other_buffers"]["autoread_buffers"] and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and self.session.settings["sound"]["session_mute"] == False:
+            if self.session.settings["general"]["reverse_timelines"] == False:
+                tweet = self.session.db[self.name][-1]
+            else:
+                tweet = self.session.db[self.name][0]
+            output.speak(" ".join(self.compose_function(tweet, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"], self.session)))
+        elif number_of_items > 1 and self.name in self.session.settings["other_buffers"]["autoread_buffers"] and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and self.session.settings["sound"]["session_mute"] == False:
+            output.speak(_(u"{0} new followers.").format(number_of_items))
+
+    def get_item_url(self, *args, **kwargs):
+        tweet = self.get_tweet()
+        url = "https://twitter.com/{screen_name}".format(screen_name=tweet.screen_name)
+        return url

src/controller/buffers/twitter/search.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+import time
+import platform
+import locale
+if platform.system() == "Windows":
+    from wxUI import  commonMessageDialogs
+elif platform.system() == "Linux":
+    from gi.repository import Gtk
+    from gtkUI import commonMessageDialogs
+import widgetUtils
+import logging
+from tweepy.errors import TweepyException
+from . import base, people
+
+log = logging.getLogger("controller.buffers.twitter.searchBuffer")
+
+class SearchBuffer(base.BaseBuffer):
+
+    def remove_buffer(self, force=False):
+        if force == False:
+            dlg = commonMessageDialogs.remove_buffer()
+        else:
+            dlg = widgetUtils.YES
+        if dlg == widgetUtils.YES:
+            if self.name[:-11] in self.session.settings["other_buffers"]["tweet_searches"]:
+                self.session.settings["other_buffers"]["tweet_searches"].remove(self.name[:-11])
+                self.session.settings.write()
+                if self.name in self.session.db:
+                    self.session.db.pop(self.name)
+                return True
+        elif dlg == widgetUtils.NO:
+            return False
+
+class SearchPeopleBuffer(people.PeopleBuffer):
+    """ This is identical to a normal peopleBufferController, except that uses the page parameter instead of a cursor."""
+    def __init__(self, parent, function, name, sessionObject, account, bufferType="peoplePanel", *args, **kwargs):
+        super(SearchPeopleBuffer, self).__init__(parent, function, name, sessionObject, account, bufferType="peoplePanel", *args, **kwargs)
+        if ("page" in self.kwargs) == False:
+            self.page = 1
+        else:
+            self.page = self.kwargs.pop("page")
+
+    def get_more_items(self, *args, **kwargs):
+        # Add 1 to the page parameter, put it in kwargs and calls to get_more_items in the parent buffer.
+        self.page = self.page +1
+        self.kwargs["page"] = self.page
+        super(SearchPeopleBuffer, self).get_more_items(*args, **kwargs)
+        # remove the parameter again to make sure start_stream won't fetch items for this page indefinitely.
+        self.kwargs.pop("page")
+
+    def remove_buffer(self, force=False):
+        if force == False:
+            dlg = commonMessageDialogs.remove_buffer()
+        else:
+            dlg = widgetUtils.YES
+        if dlg == widgetUtils.YES:
+            if self.name[:-11] in self.session.settings["other_buffers"]["tweet_searches"]:
+                self.session.settings["other_buffers"]["tweet_searches"].remove(self.name[:-11])
+                self.session.settings.write()
+                if self.name in self.session.db:
+                    self.session.db.pop(self.name)
+                return True
+        elif dlg == widgetUtils.NO:
+            return False
+
+class ConversationBuffer(SearchBuffer):
+
+    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
+            results = self.get_replies(self.tweet)
+            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)
+            if number_of_items > 0 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)
+            # Autoread settings
+            if avoid_autoreading == False and mandatory == True and number_of_items > 0 and self.name in self.session.settings["other_buffers"]["autoread_buffers"]:
+                self.auto_read(number_of_items)
+            return number_of_items
+
+    def remove_buffer(self, force=False):
+        if force == False:
+            dlg = commonMessageDialogs.remove_buffer()
+        else:
+            dlg = widgetUtils.YES
+        if dlg == widgetUtils.YES:
+            if self.name in self.session.db:
+                self.session.db.pop(self.name)
+            return True
+        elif dlg == widgetUtils.NO:
+            return False
+
+    def get_replies(self, tweet):
+        """ Try to retrieve the whole conversation for the passed object by using a mix between calls to API V1.1 and V2 """
+        results = []
+        # If the tweet that starts the conversation is a reply to something else, let's try to get the parent tweet first.
+        if hasattr(self, "in_reply_to_status_id") and self.tweet.in_reply_to_status_id != None:
+            try:
+                tweet2 = self.session.twitter_v2.get_tweet(id=self.tweet.in_reply_to_status_id, user_auth=True, tweet_fields=["conversation_id"])
+                results.append(tweet2)
+            except TweepyException as e:
+                log.exception("There was an error attempting to retrieve a parent tweet for the conversation for {}".format(self.name))
+        # Now, try to fetch the tweet initiating the conversation in V2 so we can get conversation_id
+        try:
+            tweet = self.session.twitter_v2.get_tweet(id=self.tweet.id, user_auth=True, tweet_fields=["conversation_id"])
+            results.append(tweet.data)
+            term = "conversation_id:{}".format(tweet.data.conversation_id)
+            tweets = self.session.twitter_v2.search_recent_tweets(term, user_auth=True, max_results=98)
+            if tweets.data != None:
+                results.extend(tweets.data)
+        except TweepyException as e:
+            log.exception("There was an error when attempting to retrieve the whole conversation for buffer {}".format(self.buffer.name))
+        new_results = []
+        ids = [tweet.id for tweet in results]
+        try:
+            results = self.session.twitter.lookup_statuses(ids, include_ext_alt_text=True, tweet_mode="extended")
+            results.sort(key=lambda x: x.id)
+        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 []
+        return results

src/controller/buffers/twitter/trends.py

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+import time
+import platform
+if platform.system() == "Windows":
+    import wx
+    from wxUI import buffers, commonMessageDialogs, menus
+    from controller import user
+elif platform.system() == "Linux":
+    from gi.repository import Gtk
+    from gtkUI import buffers, commonMessageDialogs
+from controller import messages
+import widgetUtils
+import output
+import logging
+from mysc.thread_utils import call_threaded
+from tweepy.errors import TweepyException
+from pubsub import pub
+from controller.buffers import base
+
+log = logging.getLogger("controller.buffers.twitter.trends")
+
+class TrendsBuffer(base.Buffer):
+    def __init__(self, parent, name, sessionObject, account, trendsFor, *args, **kwargs):
+        super(TrendsBuffer, self).__init__(parent=parent, sessionObject=sessionObject)
+        self.trendsFor = trendsFor
+        self.session = sessionObject
+        self.account = account
+        self.invisible = True
+        self.buffer = buffers.trendsPanel(parent, name)
+        self.buffer.account = account
+        self.type = self.buffer.type
+        self.bind_events()
+        self.sound = "trends_updated.ogg"
+        self.trends = []
+        self.name = name
+        self.buffer.name = name
+        self.compose_function = self.compose_function_
+        self.get_formatted_message = self.get_message
+        self.reply = self.search_topic
+
+    def start_stream(self, mandatory=False, play_sound=True, avoid_autoreading=False):
+        # starts stream every 3 minutes.
+        current_time = time.time()
+        if self.execution_time == 0 or current_time-self.execution_time >= 180 or mandatory == True:
+            self.execution_time = current_time
+            try:
+                data = self.session.twitter.get_place_trends(id=self.trendsFor)
+            except TweepyException as err:
+                log.exception("Error %s" % (str(err)))
+            if not hasattr(self, "name_"):
+                self.name_ = data[0]["locations"][0]["name"]
+            self.trends = data[0]["trends"]
+            self.put_items_on_the_list()
+            if 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)
+
+    def put_items_on_the_list(self):
+        selected_item = self.buffer.list.get_selected()
+        self.buffer.list.clear()
+        for i in self.trends:
+            tweet = self.compose_function(i)
+            self.buffer.list.insert_item(False, *tweet)
+            self.buffer.set_position(self.session.settings["general"]["reverse_timelines"])
+
+    def compose_function_(self, trend):
+        return [trend["name"]]
+
+    def bind_events(self):
+        log.debug("Binding events...")
+        self.buffer.list.list.Bind(wx.EVT_CHAR_HOOK, self.get_event)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.tweet_about_this_trend, self.buffer.tweetTrendBtn)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.post_status, self.buffer.tweet)
+        widgetUtils.connect_event(self.buffer.list.list, wx.EVT_LIST_ITEM_RIGHT_CLICK, self.show_menu)
+        widgetUtils.connect_event(self.buffer.list.list, wx.EVT_LIST_KEY_DOWN, self.show_menu_by_key)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.search_topic, self.buffer.search_topic)
+
+    def get_message(self):
+        return self.compose_function(self.trends[self.buffer.list.get_selected()])[0]
+
+    def remove_buffer(self, force=False):
+        if force == False:
+            dlg = commonMessageDialogs.remove_buffer()
+        else:
+            dlg = widgetUtils.YES
+        if dlg == widgetUtils.YES:
+            if self.name[:-3] in self.session.settings["other_buffers"]["trending_topic_buffers"]:
+                self.session.settings["other_buffers"]["trending_topic_buffers"].remove(self.name[:-3])
+                self.session.settings.write()
+                if self.name in self.session.db:
+                    self.session.db.pop(self.name)
+                return True
+        elif dlg == widgetUtils.NO:
+            return False
+
+    def url(self, *args, **kwargs):
+        self.tweet_about_this_trend()
+
+    def search_topic(self, *args, **kwargs):
+        topic = self.trends[self.buffer.list.get_selected()]["name"]
+        pub.sendMessage("search", term=topic)
+
+    def show_menu(self, ev, pos=0, *args, **kwargs):
+        menu = menus.trendsPanelMenu()
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.search_topic, menuitem=menu.search_topic)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.tweet_about_this_trend, menuitem=menu.tweetThisTrend)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.view, menuitem=menu.view)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.copy, menuitem=menu.copy)
+        if pos != 0:
+            self.buffer.PopupMenu(menu, pos)
+        else:
+            self.buffer.PopupMenu(menu, ev.GetPosition())
+
+    def view(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="view_item")
+
+    def copy(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="copy_to_clipboard")
+
+    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)
+        if hasattr(tweet.message, "destroy"): tweet.message.destroy()
+
+    def show_menu_by_key(self, ev):
+        if self.buffer.list.get_count() == 0:
+            return
+        if ev.GetKeyCode() == wx.WXK_WINDOWS_MENU:
+            self.show_menu(widgetUtils.MENU, pos=self.buffer.list.list.GetPosition())
+
+    def open_in_browser(self, *args, **kwargs):
+        output.speak(_(u"This action is not supported in the buffer, yet."))

src/controller/listsController.py

@@ -3,7 +3,7 @@ import widgetUtils
 import output
 import logging
 from wxUI.dialogs import lists
-from tweepy.error import TweepError
+from tweepy.errors import TweepyException
 from sessions.twitter import compose, utils
 from pubsub import pub
 
@@ -49,9 +49,9 @@ class listsController(object):
                 new_list = self.session.twitter.create_list(name=name, description=description, mode=mode)
                 self.session.db["lists"].append(new_list)
                 self.dialog.lista.insert_item(False, *compose.compose_list(new_list))
-   except TweepError as e:
-    output.speak("error %s: %s" % (e.api_code, e.reason))
-    log.exception("error %s: %s" % (e.api_code, e.reason))
+            except TweepyException as e:
+                output.speak("error %s" % (str(e)))
+                log.exception("error %s" % (str(e)))
         dialog.destroy()
 
     def edit_list(self, *args, **kwargs):
@@ -70,8 +70,9 @@ class listsController(object):
                 self.session.twitter.update_list(list_id=list.id, name=name, description=description, mode=mode)
                 self.session.get_lists()
                 self.dialog.populate_list(self.get_all_lists(), True)
-   except TweepError as e:
-    output.speak("error %s: %s" % (e.api_code, e.reason))
+            except TweepyException as e:
+                output.speak("error %s" % (str(e)))
+                log.exception("error %s" % (str(e)))
         dialog.destroy()
 
     def remove_list(self, *args, **kwargs):
@@ -82,8 +83,9 @@ class listsController(object):
                 self.session.twitter.destroy_list(list_id=list)
                 self.session.db["lists"].pop(self.dialog.get_item())
                 self.dialog.lista.remove_item(self.dialog.get_item())
-   except TweepError as e:
-    output.speak("error %s: %s" % (e.api_code, e.reason))
+            except TweepyException as e:
+                output.speak("error %s" % (str(e)))
+                log.exception("error %s" % (str(e)))
 
     def open_list_as_buffer(self, *args, **kwargs):
         if self.dialog.lista.get_count() == 0: return
@@ -97,8 +99,9 @@ class listsController(object):
             list = self.session.twitter.subscribe_list(list_id=list_id)
             item = utils.find_item(list.id, self.session.db["lists"])
             self.session.db["lists"].append(list)
-  except TweepError as e:
-   output.speak("error %s: %s" % (e.api_code, e.reason))
+        except TweepyException as e:
+            output.speak("error %s" % (str(e)))
+            log.exception("error %s" % (str(e)))
 
     def unsubscribe(self, *args, **kwargs):
         if self.dialog.lista.get_count() == 0: return
@@ -106,5 +109,6 @@ class listsController(object):
         try:
             list = self.session.twitter.unsubscribe_list(list_id=list_id)
             self.session.db["lists"].remove(list)
-  except TweepError as e:
-   output.speak("error %s: %s" % (e.api_code, e.reason))
+        except TweepyException as e:
+            output.speak("error %s" % (str(e)))
+            log.exception("error %s" % (str(e)))

src/controller/mainController.py

@@ -2,6 +2,7 @@
 import platform
 system = platform.system()
 import application
+import wx
 import requests
 from audio_services import youtube_utils
 import arrow
@@ -22,31 +23,30 @@ elif system == "Linux":
     from gtkUI import (view, commonMessageDialogs)
 from sessions.twitter import utils, compose
 from sessionmanager import manager, sessionManager
-
-from controller.buffers import baseBuffers, twitterBuffers
+from controller import buffers
 from . import messages
+from . import userAliasController
 import sessions
 from sessions.twitter  import session as session_
 from pubsub import pub
 import sound
 import output
-from tweepy.error import TweepError
+from tweepy.errors import TweepyException, Forbidden
 from mysc.thread_utils import call_threaded
 from mysc.repeating_timer import RepeatingTimer
 from mysc import restart
 import config
 import widgetUtils
-import pygeocoder
-from pygeolib import GeocoderError
 import logging
 import webbrowser
+from geopy.geocoders import Nominatim
 from mysc import localization
 import os
 import languageHandler
 
 log = logging.getLogger("mainController")
 
-geocoder = pygeocoder.Geocoder()
+geocoder = Nominatim(user_agent="TWBlue")
 
 class Controller(object):
 
@@ -126,12 +126,14 @@ class Controller(object):
         pub.subscribe(self.update_sent_dms, "sent-dms-updated")
         pub.subscribe(self.more_dms, "more-sent-dms")
         pub.subscribe(self.manage_sent_tweets, "sent-tweet")
+        pub.subscribe(self.manage_new_tweet, "newTweet")
         pub.subscribe(self.manage_friend, "friend")
         pub.subscribe(self.manage_unfollowing, "unfollowing")
         pub.subscribe(self.manage_favourite, "favourite")
         pub.subscribe(self.manage_unfavourite, "unfavourite")
         pub.subscribe(self.manage_blocked_user, "blocked-user")
         pub.subscribe(self.manage_unblocked_user, "unblocked-user")
+        pub.subscribe(self.create_buffer, "createBuffer")
         if system == "Windows":
             pub.subscribe(self.invisible_shorcuts_changed, "invisible-shorcuts-changed")
             widgetUtils.connect_event(self.view, widgetUtils.MENU, self.show_hide, menuitem=self.view.show_hide)
@@ -185,9 +187,11 @@ class Controller(object):
         widgetUtils.connect_event(self.view, widgetUtils.MENU, self.report_error, self.view.reportError)
         widgetUtils.connect_event(self.view, widgetUtils.MENU, self.view_documentation, self.view.doc)
         widgetUtils.connect_event(self.view, widgetUtils.MENU, self.view_changelog, self.view.changelog)
+        widgetUtils.connect_event(self.view, widgetUtils.MENU, self.add_alias, self.view.addAlias)
         widgetUtils.connect_event(self.view, widgetUtils.MENU, self.add_to_list, self.view.addToList)
         widgetUtils.connect_event(self.view, widgetUtils.MENU, self.remove_from_list, self.view.removeFromList)
         widgetUtils.connect_event(self.view, widgetUtils.MENU, self.update_buffer, self.view.update_buffer)
+        widgetUtils.connect_event(self.view, widgetUtils.MENU, self.manage_aliases, self.view.manageAliases)
 
     def set_systray_icon(self):
         self.systrayIcon = sysTrayIcon.SysTrayIcon()
@@ -254,8 +258,8 @@ class Controller(object):
         # Connection checker executed each minute.
         self.checker_function = RepeatingTimer(60, self.check_connection)
 #  self.checker_function.start()
-  self.save_db = RepeatingTimer(300, self.save_data_in_db)
-  self.save_db.start()
+#        self.save_db = RepeatingTimer(300, self.save_data_in_db)
+#        self.save_db.start()
         log.debug("Setting updates to buffers every %d seconds..." % (60*config.app["app-settings"]["update_period"],))
         self.update_buffers_function = RepeatingTimer(60*config.app["app-settings"]["update_period"], self.update_buffers)
         self.update_buffers_function.start()
@@ -266,15 +270,19 @@ class Controller(object):
             if sessions.sessions[i].is_logged == False: continue
             self.start_buffers(sessions.sessions[i])
             self.set_buffer_positions(sessions.sessions[i])
+            sessions.sessions[i].start_streaming()
         if config.app["app-settings"]["play_ready_sound"] == True:
             sessions.sessions[list(sessions.sessions.keys())[0]].sound.play("ready.ogg")
         if config.app["app-settings"]["speak_ready_msg"] == True:
             output.speak(_(u"Ready"))
         self.started = True
+        self.streams_checker_function = RepeatingTimer(60, self.check_streams)
+        self.streams_checker_function.start()
+
 
     def create_ignored_session_buffer(self, session):
         self.accounts.append(session.settings["twitter"]["user_name"])
-  account = baseBuffers.accountPanel(self.view.nb, session.settings["twitter"]["user_name"], session.settings["twitter"]["user_name"], session.session_id)
+        account = buffers.base.AccountBuffer(self.view.nb, session.settings["twitter"]["user_name"], session.settings["twitter"]["user_name"], session.session_id)
         account.logged = False
         account.setup_account()
         self.buffers.append(account)
@@ -288,106 +296,89 @@ class Controller(object):
         self.create_buffers(session, False)
         self.start_buffers(session)
 
+    def create_buffer(self, buffer_type="baseBuffer", session_type="twitter", buffer_title="", parent_tab=None, start=False, kwargs={}):
+        log.debug("Creating buffer of type {0} with parent_tab of {2} arguments {1}".format(buffer_type, kwargs, parent_tab))
+        if not hasattr(buffers, session_type):
+            raise AttributeError("Session type %s does not exist yet." % (session_type))
+        available_buffers = getattr(buffers, session_type)
+        if not hasattr(available_buffers, buffer_type):
+            raise AttributeError("Specified buffer type does not exist: %s" % (buffer_type,))
+        buffer = getattr(available_buffers, buffer_type)(**kwargs)
+        if start:
+            if kwargs.get("function") == "user_timeline":
+                try:
+                    buffer.start_stream(play_sound=False)
+                except ValueError:
+                    commonMessageDialogs.unauthorized()
+                    return
+            else:
+                call_threaded(buffer.start_stream)
+        self.buffers.append(buffer)
+        if parent_tab == None:
+            log.debug("Appending buffer {}...".format(buffer,))
+            self.view.add_buffer(buffer.buffer, buffer_title)
+        else:
+            self.view.insert_buffer(buffer.buffer, buffer_title, parent_tab)
+            log.debug("Inserting buffer {0} into control {1}".format(buffer, parent_tab))
+
     def create_buffers(self, session, createAccounts=True):
         """ Generates buffer objects for an user account.
         session SessionObject: a sessionmanager.session.Session Object"""
         session.get_user_info()
         if createAccounts == True:
             self.accounts.append(session.db["user_name"])
-   account = baseBuffers.accountPanel(self.view.nb, session.db["user_name"], session.db["user_name"], session.session_id)
+            account = buffers.base.AccountBuffer(self.view.nb, session.db["user_name"], session.db["user_name"], session.session_id)
             account.setup_account()
             self.buffers.append(account)
             self.view.add_buffer(account.buffer , name=session.db["user_name"])
+        root_position =self.view.search(session.db["user_name"], session.db["user_name"])
         for i in session.settings['general']['buffer_order']:
             if i == 'home':
-    home = twitterBuffers.baseBufferController(self.view.nb, "home_timeline", "home_timeline", session, session.db["user_name"], sound="tweet_received.ogg", tweet_mode="extended")
-    self.buffers.append(home)
-    self.view.insert_buffer(home.buffer, name=_(u"Home"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Home"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, function="home_timeline", name="home_timeline", sessionObject=session, account=session.db["user_name"], sound="tweet_received.ogg", tweet_mode="extended"))
             elif i == 'mentions':
-    mentions = twitterBuffers.baseBufferController(self.view.nb, "mentions_timeline", "mentions", session, session.db["user_name"], sound="mention_received.ogg", tweet_mode="extended")
-    self.buffers.append(mentions)
-    self.view.insert_buffer(mentions.buffer, name=_(u"Mentions"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Mentions"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, function="mentions_timeline", name="mentions", sessionObject=session, account=session.db["user_name"], sound="mention_received.ogg", tweet_mode="extended"))
             elif i == 'dm':
-    dm = twitterBuffers.directMessagesController(self.view.nb, "list_direct_messages", "direct_messages", session, session.db["user_name"], bufferType="dmPanel", compose_func="compose_direct_message", sound="dm_received.ogg")
-    self.buffers.append(dm)
-    self.view.insert_buffer(dm.buffer, name=_(u"Direct messages"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+                pub.sendMessage("createBuffer", buffer_type="DirectMessagesBuffer", session_type=session.type, buffer_title=_("Direct messages"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, function="get_direct_messages", name="direct_messages", sessionObject=session, account=session.db["user_name"], bufferType="dmPanel", compose_func="compose_direct_message", sound="dm_received.ogg"))
             elif i == 'sent_dm':
-    sent_dm = twitterBuffers.sentDirectMessagesController(self.view.nb, "", "sent_direct_messages", session, session.db["user_name"], bufferType="dmPanel", compose_func="compose_direct_message")
-    self.buffers.append(sent_dm)
-    self.view.insert_buffer(sent_dm.buffer, name=_(u"Sent direct messages"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+                pub.sendMessage("createBuffer", buffer_type="SentDirectMessagesBuffer", session_type=session.type, buffer_title=_("Sent direct messages"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, function=None, name="sent_direct_messages", sessionObject=session, account=session.db["user_name"], bufferType="dmPanel", compose_func="compose_direct_message"))
             elif i == 'sent_tweets':
-    sent_tweets = twitterBuffers.baseBufferController(self.view.nb, "user_timeline", "sent_tweets", session, session.db["user_name"], screen_name=session.db["user_name"], tweet_mode="extended")
-    self.buffers.append(sent_tweets)
-    self.view.insert_buffer(sent_tweets.buffer, name=_(u"Sent tweets"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Sent tweets"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, function="user_timeline", name="sent_tweets", sessionObject=session, account=session.db["user_name"], screen_name=session.db["user_name"], tweet_mode="extended"))
             elif i == 'favorites':
-    favourites = twitterBuffers.baseBufferController(self.view.nb, "favorites", "favourites", session, session.db["user_name"], sound="favourite.ogg", tweet_mode="extended")
-    self.buffers.append(favourites)
-    self.view.insert_buffer(favourites.buffer, name=_(u"Likes"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Likes"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, function="get_favorites", name="favourites", sessionObject=session, account=session.db["user_name"], sound="favourite.ogg", tweet_mode="extended"))
             elif i == 'followers':
-    followers = twitterBuffers.peopleBufferController(self.view.nb, "followers", "followers", session, session.db["user_name"], sound="update_followers.ogg", screen_name=session.db["user_name"])
-    self.buffers.append(followers)
-    self.view.insert_buffer(followers.buffer, name=_(u"Followers"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+                pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=session.type, buffer_title=_("Followers"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, function="get_followers", name="followers", sessionObject=session, account=session.db["user_name"], sound="update_followers.ogg", screen_name=session.db["user_name"]))
             elif i == 'friends':
-    friends = twitterBuffers.peopleBufferController(self.view.nb, "friends", "friends", session, session.db["user_name"], screen_name=session.db["user_name"])
-    self.buffers.append(friends)
-    self.view.insert_buffer(friends.buffer, name=_(u"Friends"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+                pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=session.type, buffer_title=_("Following"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, function="get_friends", name="friends", sessionObject=session, account=session.db["user_name"], screen_name=session.db["user_name"]))
             elif i == 'blocks':
-    blocks = twitterBuffers.peopleBufferController(self.view.nb, "blocks", "blocked", session, session.db["user_name"])
-    self.buffers.append(blocks)
-    self.view.insert_buffer(blocks.buffer, name=_(u"Blocked users"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+                pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=session.type, buffer_title=_("Blocked users"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, function="get_blocks", name="blocked", sessionObject=session, account=session.db["user_name"]))
             elif i == 'muted':
-    muted = twitterBuffers.peopleBufferController(self.view.nb, "mutes", "muted", session, session.db["user_name"])
-    self.buffers.append(muted)
-    self.view.insert_buffer(muted.buffer, name=_(u"Muted users"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
-  timelines = baseBuffers.emptyPanel(self.view.nb, "timelines", session.db["user_name"])
-  self.buffers.append(timelines)
-  self.view.insert_buffer(timelines.buffer , name=_(u"Timelines"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+                pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=session.type, buffer_title=_("Muted users"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, function="get_mutes", name="muted", sessionObject=session, account=session.db["user_name"]))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Timelines"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, name="timelines", account=session.db["user_name"]))
+        timelines_position =self.view.search("timelines", session.db["user_name"])
         for i in session.settings["other_buffers"]["timelines"]:
-   tl = twitterBuffers.baseBufferController(self.view.nb, "user_timeline", "%s-timeline" % (i,), session, session.db["user_name"], sound="tweet_timeline.ogg", bufferType=None, user_id=i, tweet_mode="extended")
-   self.buffers.append(tl)
-   self.view.insert_buffer(tl.buffer, name=_(u"Timeline for {}").format(i,), pos=self.view.search("timelines", session.db["user_name"]))
-  favs_timelines = baseBuffers.emptyPanel(self.view.nb, "favs_timelines", session.db["user_name"])
-  self.buffers.append(favs_timelines)
-  self.view.insert_buffer(favs_timelines.buffer , name=_(u"Likes timelines"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+            pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_(u"Timeline for {}").format(i,), parent_tab=timelines_position, start=False, kwargs=dict(parent=self.view.nb, function="user_timeline", name="%s-timeline" % (i,), sessionObject=session, account=session.db["user_name"], sound="tweet_timeline.ogg", bufferType=None, user_id=i, tweet_mode="extended"))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Likes timelines"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, name="favs_timelines", account=session.db["user_name"]))
+        favs_timelines_position =self.view.search("favs_timelines", session.db["user_name"])
         for i in session.settings["other_buffers"]["favourites_timelines"]:
-   tl = twitterBuffers.baseBufferController(self.view.nb, "favorites", "%s-favorite" % (i,), session, session.db["user_name"], bufferType=None, sound="favourites_timeline_updated.ogg", user_id=i, tweet_mode="extended")
-   self.buffers.append(tl)
-   self.view.insert_buffer(tl.buffer, name=_(u"Likes for {}").format(i,), pos=self.view.search("favs_timelines", session.db["user_name"]))
-  followers_timelines = baseBuffers.emptyPanel(self.view.nb, "followers_timelines", session.db["user_name"])
-  self.buffers.append(followers_timelines)
-  self.view.insert_buffer(followers_timelines.buffer , name=_(u"Followers' Timelines"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+            pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Likes for {}").format(i,), parent_tab=favs_timelines_position, start=False, kwargs=dict(parent=self.view.nb, function="get_favorites", name="%s-favorite" % (i,), sessionObject=session, account=session.db["user_name"], bufferType=None, sound="favourites_timeline_updated.ogg", user_id=i, tweet_mode="extended"))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Followers timelines"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, name="followers_timelines", account=session.db["user_name"]))
+        followers_timelines_position =self.view.search("followers_timelines", session.db["user_name"])
         for i in session.settings["other_buffers"]["followers_timelines"]:
-   tl = twitterBuffers.peopleBufferController(self.view.nb, "followers", "%s-followers" % (i,), session, session.db["user_name"], sound="new_event.ogg", user_id=i)
-   self.buffers.append(tl)
-   self.view.insert_buffer(tl.buffer, name=_(u"Followers for {}").format(i,), pos=self.view.search("followers_timelines", session.db["user_name"]))
-  friends_timelines = baseBuffers.emptyPanel(self.view.nb, "friends_timelines", session.db["user_name"])
-  self.buffers.append(friends_timelines)
-  self.view.insert_buffer(friends_timelines.buffer , name=_(u"Friends' Timelines"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+            pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=session.type, buffer_title=_("Followers for {}").format(i,), parent_tab=followers_timelines_position, start=False, kwargs=dict(parent=self.view.nb, function="get_followers", name="%s-followers" % (i,), sessionObject=session, account=session.db["user_name"], sound="new_event.ogg", user_id=i))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Following timelines"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, name="friends_timelines", account=session.db["user_name"]))
+        friends_timelines_position =self.view.search("friends_timelines", session.db["user_name"])
         for i in session.settings["other_buffers"]["friends_timelines"]:
-   tl = twitterBuffers.peopleBufferController(self.view.nb, "friends", "%s-friends" % (i,), session, session.db["user_name"], sound="new_event.ogg", user_id=i)
-   self.buffers.append(tl)
-   self.view.insert_buffer(tl.buffer, name=_(u"Friends for {}").format(i,), pos=self.view.search("friends_timelines", session.db["user_name"]))
-  lists = baseBuffers.emptyPanel(self.view.nb, "lists", session.db["user_name"])
-  self.buffers.append(lists)
-  self.view.insert_buffer(lists.buffer , name=_(u"Lists"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+            pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=session.type, buffer_title=_(u"Friends for {}").format(i,), parent_tab=friends_timelines_position, start=False, kwargs=dict(parent=self.view.nb, function="get_friends", name="%s-friends" % (i,), sessionObject=session, account=session.db["user_name"], sound="new_event.ogg", user_id=i))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Lists"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, name="lists", account=session.db["user_name"]))
+        lists_position =self.view.search("lists", session.db["user_name"])
         for i in session.settings["other_buffers"]["lists"]:
-   tl = twitterBuffers.listBufferController(self.view.nb, "list_timeline", "%s-list" % (i,), session, session.db["user_name"], bufferType=None, sound="list_tweet.ogg", list_id=utils.find_list(i, session.db["lists"]), tweet_mode="extended")
-   session.lists.append(tl)
-   self.buffers.append(tl)
-   self.view.insert_buffer(tl.buffer, name=_(u"List for {}").format(i), pos=self.view.search("lists", session.db["user_name"]))
-  searches = baseBuffers.emptyPanel(self.view.nb, "searches", session.db["user_name"])
-  self.buffers.append(searches)
-  self.view.insert_buffer(searches.buffer , name=_(u"Searches"), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+            pub.sendMessage("createBuffer", buffer_type="ListBuffer", session_type=session.type, buffer_title=_(u"List for {}").format(i), parent_tab=lists_position, start=False, kwargs=dict(parent=self.view.nb, function="list_timeline", name="%s-list" % (i,), sessionObject=session, account=session.db["user_name"], bufferType=None, sound="list_tweet.ogg", list_id=utils.find_list(i, session.db["lists"]), tweet_mode="extended"))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Searches"), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, name="searches", account=session.db["user_name"]))
+        searches_position =self.view.search("searches", session.db["user_name"])
         for i in session.settings["other_buffers"]["tweet_searches"]:
-   tl = twitterBuffers.searchBufferController(self.view.nb, "search", "%s-searchterm" % (i,), session, session.db["user_name"], bufferType="searchPanel", sound="search_updated.ogg", q=i, tweet_mode="extended")
-   self.buffers.append(tl)
-   self.view.insert_buffer(tl.buffer, name=_(u"Search for {}").format(i), pos=self.view.search("searches", session.db["user_name"]))
+            pub.sendMessage("createBuffer", buffer_type="SearchBuffer", session_type=session.type, buffer_title=_(u"Search for {}").format(i), parent_tab=searches_position, start=False, kwargs=dict(parent=self.view.nb, function="search_tweets", name="%s-searchterm" % (i,), sessionObject=session, account=session.db["user_name"], bufferType="searchPanel", sound="search_updated.ogg", q=i, tweet_mode="extended"))
         for i in session.settings["other_buffers"]["trending_topic_buffers"]:
-   buffer = twitterBuffers.trendsBufferController(self.view.nb, "%s_tt" % (i,), session, session.db["user_name"], i, sound="trends_updated.ogg")
-   buffer.start_stream(play_sound=False)
-   buffer.searchfunction = self.search
-   self.buffers.append(buffer)
-   self.view.insert_buffer(buffer.buffer, name=_(u"Trending topics for %s") % (buffer.name_), pos=self.view.search(session.db["user_name"], session.db["user_name"]))
+            pub.sendMessage("createBuffer", buffer_type="TrendsBuffer", session_type=session.type, buffer_title=_("Trending topics for %s") % (i), parent_tab=root_position, start=False, kwargs=dict(parent=self.view.nb, name="%s_tt" % (i,), sessionObject=session, account=session.db["user_name"], trendsFor=i, sound="trends_updated.ogg"))
 
     def set_buffer_positions(self, session):
         "Sets positions for buffers if values exist in the database."
@@ -426,21 +417,18 @@ class Controller(object):
         if dlg.get_response() == widgetUtils.OK and dlg.get("term") != "":
             term = dlg.get("term")
             buffer = self.get_best_buffer()
+            searches_position =self.view.search("searches", buffer.session.db["user_name"])
             if dlg.get("tweets") == True:
                 if term not in buffer.session.settings["other_buffers"]["tweet_searches"]:
                     buffer.session.settings["other_buffers"]["tweet_searches"].append(term)
                     buffer.session.settings.write()
                     args = {"lang": dlg.get_language(), "result_type": dlg.get_result_type()}
-     search = twitterBuffers.searchBufferController(self.view.nb, "search", "%s-searchterm" % (term,), buffer.session, buffer.session.db["user_name"], bufferType="searchPanel", sound="search_updated.ogg", q=term, tweet_mode="extended", **args)
+                    pub.sendMessage("createBuffer", buffer_type="SearchBuffer", session_type=buffer.session.type, buffer_title=_("Search for {}").format(term), parent_tab=searches_position, start=True, kwargs=dict(parent=self.view.nb, function="search_tweets", name="%s-searchterm" % (term,), sessionObject=buffer.session, account=buffer.session.db["user_name"], bufferType="searchPanel", sound="search_updated.ogg", q=term, tweet_mode="extended", **args))
                 else:
                     log.error("A buffer for the %s search term is already created. You can't create a duplicate buffer." % (term,))
                     return
             elif dlg.get("users") == True:
-    search = twitterBuffers.searchPeopleBufferController(self.view.nb, "search_users", "%s-searchUser" % (term,), buffer.session, buffer.session.db["user_name"], bufferType=None, sound="search_updated.ogg", q=term)
-   search.start_stream(mandatory=True)
-   pos=self.view.search("searches", buffer.session.db["user_name"])
-   self.insert_buffer(search, pos)
-   self.view.insert_buffer(search.buffer, name=_(u"Search for {}").format(term), pos=pos)
+                pub.sendMessage("createBuffer", buffer_type="SearchPeopleBuffer", session_type=buffer.session.type, buffer_title=_("Search for {}").format(term), parent_tab=searches_position, start=True, kwargs=dict(parent=self.view.nb, function="search_users", name="%s-searchUser" % (term,), sessionObject=buffer.session, account=buffer.session.db["user_name"], bufferType=None, sound="search_updated.ogg", q=term))
         dlg.Destroy()
 
     def find(self, *args, **kwargs):
@@ -530,7 +518,7 @@ class Controller(object):
         elif buff.type == "dm":
             users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
         else:
-   users = utils.get_all_users(tweet, buff.session.db)
+            users = utils.get_all_users(tweet, buff.session)
         dlg = dialogs.utils.selectUserDialog(_(u"Select the user"), users)
         if dlg.get_response() == widgetUtils.OK:
             user = dlg.get_user()
@@ -547,7 +535,7 @@ class Controller(object):
         elif buff.type == "dm":
             users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
         else:
-   users = utils.get_all_users(tweet, buff.session.db)
+            users = utils.get_all_users(tweet, buff.session)
         dlg = dialogs.utils.selectUserDialog(_(u"Select the user"), users)
         if dlg.get_response() == widgetUtils.OK:
             user = dlg.get_user()
@@ -563,8 +551,9 @@ class Controller(object):
                 if listBuffer != None: listBuffer.get_user_ids()
                 buff.session.db["lists"].pop(older_list)
                 buff.session.db["lists"].append(list)
-   except TweepError as e:
-    output.speak("error %s: %s" % (e.api_code, e.reason))
+            except TweepyException as e:
+                log.exception("error %s" % (str(e)))
+                output.speak("error %s" % (str(e)))
 
     def remove_from_list(self, *args, **kwargs):
         buff = self.get_best_buffer()
@@ -575,7 +564,7 @@ class Controller(object):
         elif buff.type == "dm":
             users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
         else:
-   users = utils.get_all_users(tweet, buff.session.db)
+            users = utils.get_all_users(tweet, buff.session)
         dlg = dialogs.utils.selectUserDialog(_(u"Select the user"), users)
         if dlg.get_response() == widgetUtils.OK:
             user = dlg.get_user()
@@ -591,8 +580,9 @@ class Controller(object):
                 if listBuffer != None: listBuffer.get_user_ids()
                 buff.session.db["lists"].pop(older_list)
                 buff.session.db["lists"].append(list)
-   except TweepError as e:
-    output.speak("error %s: %s" % (e.api_code, e.reason))
+            except TweepyException as e:
+                output.speak("error %s" % (str(e)))
+                log.exception("error %s" % (str(e)))
 
     def list_manager(self, *args, **kwargs):
         s = self.get_best_buffer().session
@@ -617,6 +607,7 @@ class Controller(object):
             if d.needs_restart == True:
                 commonMessageDialogs.needs_restart()
                 buff.session.settings.write()
+                buff.session.save_persistent_data()
                 restart.restart_program()
 
     def report_error(self, *args, **kwargs):
@@ -649,15 +640,20 @@ class Controller(object):
         log.debug("Saving global configuration...")
         for item in sessions.sessions:
             if sessions.sessions[item].logged == False: continue
+            log.debug("Disconnecting streaming endpoint for session" +    sessions.sessions[item].session_id)
+            sessions.sessions[item].stop_streaming()
             log.debug("Disconnecting streams for %s session" % (sessions.sessions[item].session_id,))
             sessions.sessions[item].sound.cleaner.cancel()
-   log.debug("Shelving database for " +    sessions.sessions[item].session_id)
-   sessions.sessions[item].shelve()
+            log.debug("Saving database for " +    sessions.sessions[item].session_id)
+            sessions.sessions[item].save_persistent_data()
         if system == "Windows":
             self.systrayIcon.RemoveIcon()
             pidpath = os.path.join(os.getenv("temp"), "{}.pid".format(application.name))
             if os.path.exists(pidpath):
                 os.remove(pidpath)
+        if hasattr(self, "streams_checker_function"):
+            log.debug("Stopping stream checker...")
+            self.streams_checker_function.cancel()
         widgetUtils.exit_application()
 
     def follow(self, *args, **kwargs):
@@ -669,7 +665,7 @@ class Controller(object):
         elif buff.type == "dm":
             users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
         else:
-   users = utils.get_all_users(tweet, buff.session.db)
+            users = utils.get_all_users(tweet, buff.session)
         u = userActionsController.userActionsController(buff, users)
 
     def unfollow(self, *args, **kwargs):
@@ -681,7 +677,7 @@ class Controller(object):
         elif buff.type == "dm":
             users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
         else:
-   users = utils.get_all_users(tweet, buff.session.db)
+            users = utils.get_all_users(tweet, buff.session)
         u = userActionsController.userActionsController(buff, users, "unfollow")
 
     def mute(self, *args, **kwargs):
@@ -693,7 +689,7 @@ class Controller(object):
         elif buff.type == "dm":
             users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
         else:
-   users = utils.get_all_users(tweet, buff.session.db)
+            users = utils.get_all_users(tweet, buff.session)
         u = userActionsController.userActionsController(buff, users, "mute")
 
     def unmute(self, *args, **kwargs):
@@ -705,7 +701,7 @@ class Controller(object):
         elif buff.type == "dm":
             users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
         else:
-   users = utils.get_all_users(tweet, buff.session.db)
+            users = utils.get_all_users(tweet, buff.session)
         u = userActionsController.userActionsController(buff, users, "unmute")
 
     def block(self, *args, **kwargs):
@@ -717,7 +713,7 @@ class Controller(object):
         elif buff.type == "dm":
             users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
         else:
-   users = utils.get_all_users(tweet, buff.session.db)
+            users = utils.get_all_users(tweet, buff.session)
         u = userActionsController.userActionsController(buff, users, "block")
 
     def unblock(self, *args, **kwargs):
@@ -729,7 +725,7 @@ class Controller(object):
         elif buff.type == "dm":
             users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
         else:
-   users = utils.get_all_users(tweet, buff.session.db)
+            users = utils.get_all_users(tweet, buff.session)
         u = userActionsController.userActionsController(buff, users, "unblock")
 
     def report(self, *args, **kwargs):
@@ -741,9 +737,34 @@ class Controller(object):
         elif buff.type == "dm":
             users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
         else:
-   users = utils.get_all_users(tweet, buff.session.db)
+            users = utils.get_all_users(tweet, buff.session)
         u = userActionsController.userActionsController(buff, users, "report")
 
+    def add_alias(self, *args, **kwargs):
+        buff = self.get_best_buffer()
+        if not hasattr(buff, "get_right_tweet"): return
+        tweet = buff.get_right_tweet()
+        if buff.type == "people":
+            users = [tweet.screen_name]
+        elif buff.type == "dm":
+            users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
+        else:
+            users = utils.get_all_users(tweet, buff.session)
+        dlg = dialogs.userAliasDialogs.addAliasDialog(_("Add an user alias"), users)
+        if dlg.get_response() == widgetUtils.OK:
+            user, alias = dlg.get_user()
+            if user == "" or alias == "":
+                return
+            user_id = buff.session.get_user_by_screen_name(user)
+            buff.session.settings["user-aliases"][str(user_id)] = alias
+            buff.session.settings.write()
+            output.speak(_("Alias has been set correctly for {}.").format(user))
+            pub.sendMessage("alias-added")
+
+    def manage_aliases(self, *args, **kwargs):
+        buff = self.get_best_buffer()
+        alias_controller = userAliasController.userAliasController(buff.session.settings)
+
     def post_tweet(self, event=None):
         buffer = self.get_best_buffer()
         buffer.post_status()
@@ -800,7 +821,7 @@ class Controller(object):
             return
         elif buffer.type == "baseBuffer" or buffer.type == "favourites_timeline" or buffer.type == "list" or buffer.type == "search":
             tweet, tweetsList = buffer.get_full_tweet()
-   msg = messages.viewTweet(tweet, tweetsList, utc_offset=buffer.session.db["utc_offset"])
+            msg = messages.viewTweet(tweet, tweetsList, utc_offset=buffer.session.db["utc_offset"], item_url=buffer.get_item_url())
         elif buffer.type == "dm":
             non_tweet = buffer.get_formatted_message()
             item = buffer.get_right_tweet()
@@ -808,8 +829,11 @@ class Controller(object):
             date = original_date.shift(seconds=buffer.session.db["utc_offset"]).format(_(u"MMM D, YYYY. H:m"), locale=languageHandler.getLanguage())
             msg = messages.viewTweet(non_tweet, [], False, date=date)
         else:
+            item_url = ""
+            if hasattr(buffer, "get_item_url"):
+                item_url = buffer.get_item_url()
             non_tweet = buffer.get_formatted_message()
-   msg = messages.viewTweet(non_tweet, [], False)
+            msg = messages.viewTweet(non_tweet, [], False, item_url=item_url)
 
     def open_in_browser(self, *args, **kwargs):
         buffer = self.get_current_buffer()
@@ -828,7 +852,7 @@ class Controller(object):
         elif buff.type == "dm":
             users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
         else:
-   users = utils.get_all_users(tweet, buff.session.db)
+            users = utils.get_all_users(tweet, buff.session)
         dlg = dialogs.userSelection.selectUserDialog(users=users, default=default)
         if dlg.get_response() == widgetUtils.OK:
             usr = utils.if_user_exists(buff.session.twitter, dlg.get_user())
@@ -848,7 +872,7 @@ class Controller(object):
                     if usr.id_str in buff.session.settings["other_buffers"]["timelines"]:
                         commonMessageDialogs.timeline_exist()
                         return
-     tl = twitterBuffers.baseBufferController(self.view.nb, "user_timeline", "%s-timeline" % (usr.id_str,), buff.session, buff.session.db["user_name"], bufferType=None, sound="tweet_timeline.ogg", user_id=usr.id_str, tweet_mode="extended")
+                    tl = buffers.twitter.BaseBuffer(self.view.nb, "user_timeline", "%s-timeline" % (usr.id_str,), buff.session, buff.session.db["user_name"], bufferType=None, sound="tweet_timeline.ogg", user_id=usr.id_str, tweet_mode="extended")
                     try:
                         tl.start_stream(play_sound=False)
                     except ValueError:
@@ -867,7 +891,7 @@ class Controller(object):
                     if usr.id_str in buff.session.settings["other_buffers"]["favourites_timelines"]:
                         commonMessageDialogs.timeline_exist()
                         return
-     tl = twitterBuffers.baseBufferController(self.view.nb, "favorites", "%s-favorite" % (usr.id_str,), buff.session, buff.session.db["user_name"], bufferType=None, sound="favourites_timeline_updated.ogg", user_id=usr.id_str, tweet_mode="extended")
+                    tl = buffers.twitter.BaseBuffer(self.view.nb, "get_favorites", "%s-favorite" % (usr.id_str,), buff.session, buff.session.db["user_name"], bufferType=None, sound="favourites_timeline_updated.ogg", user_id=usr.id_str, tweet_mode="extended")
                     try:
                         tl.start_stream(play_sound=False)
                     except ValueError:
@@ -886,7 +910,7 @@ class Controller(object):
                     if usr.id_str in buff.session.settings["other_buffers"]["followers_timelines"]:
                         commonMessageDialogs.timeline_exist()
                         return
-     tl = twitterBuffers.peopleBufferController(self.view.nb, "followers", "%s-followers" % (usr.id_str,), buff.session, buff.session.db["user_name"], sound="new_event.ogg", user_id=usr.id_str)
+                    tl = buffers.twitter.PeopleBuffer(self.view.nb, "get_followers", "%s-followers" % (usr.id_str,), buff.session, buff.session.db["user_name"], sound="new_event.ogg", user_id=usr.id_str)
                     try:
                         tl.start_stream(play_sound=False)
                     except ValueError:
@@ -905,7 +929,7 @@ class Controller(object):
                     if usr.id_str in buff.session.settings["other_buffers"]["friends_timelines"]:
                         commonMessageDialogs.timeline_exist()
                         return
-     tl = twitterBuffers.peopleBufferController(self.view.nb, "friends", "%s-friends" % (usr.id_str,), buff.session, buff.session.db["user_name"], sound="new_event.ogg", user_id=usr.id_str)
+                    tl = buffers.twitter.PeopleBuffer(self.view.nb, "get_friends", "%s-friends" % (usr.id_str,), buff.session, buff.session.db["user_name"], sound="new_event.ogg", user_id=usr.id_str)
                     try:
                         tl.start_stream(play_sound=False)
                     except ValueError:
@@ -923,9 +947,9 @@ class Controller(object):
 
     def open_conversation(self, *args, **kwargs):
         buffer = self.get_current_buffer()
-  id = buffer.get_right_tweet().id_str
-  user = buffer.get_right_tweet().user.screen_name
-  search = twitterBuffers.conversationBufferController(self.view.nb, "search", "%s-searchterm" % (id,), buffer.session, buffer.session.db["user_name"], bufferType="searchPanel", sound="search_updated.ogg", since_id=id, q="@{0}".format(user,))
+        id = buffer.get_right_tweet().id
+        user = buffer.session.get_user(buffer.get_right_tweet().user).screen_name
+        search = buffers.twitter.ConversationBuffer(self.view.nb, "search_tweets", "%s-searchterm" % (id,), buffer.session, buffer.session.db["user_name"], bufferType="searchPanel", sound="search_updated.ogg", since_id=id, q="@{0}".format(user,))
         search.tweet = buffer.get_right_tweet()
         search.start_stream(start=True)
         pos=self.view.search("searches", buffer.session.db["user_name"])
@@ -952,7 +976,7 @@ class Controller(object):
         if trends.dialog.get_response() == widgetUtils.OK:
             woeid = trends.get_woeid()
             if woeid in buff.session.settings["other_buffers"]["trending_topic_buffers"]: return
-   buffer = twitterBuffers.trendsBufferController(self.view.nb, "%s_tt" % (woeid,), buff.session, buff.account, woeid, sound="trends_updated.ogg")
+            buffer = buffers.twitter.TrendsBuffer(self.view.nb, "%s_tt" % (woeid,), buff.session, buff.account, woeid, sound="trends_updated.ogg")
             buffer.searchfunction = self.search
             pos=self.view.search(buff.session.db["user_name"], buff.session.db["user_name"])
             self.view.insert_buffer(buffer.buffer, name=_(u"Trending topics for %s") % (trends.get_string()), pos=pos)
@@ -967,19 +991,17 @@ class Controller(object):
             if tweet.coordinates != None:
                 x = tweet.coordinates["coordinates"][0]
                 y = tweet.coordinates["coordinates"][1]
-    address = geocoder.reverse_geocode(y, x, language = languageHandler.curLang)
-    if event == None: output.speak(address[0].__str__())
-    else: self.view.show_address(address[0].__str__())
+                address = geocoder.reverse("{}, {}".format(y, x), language = languageHandler.curLang)
+                if event == None: output.speak(address.address)
+                else: self.view.show_address(address.address)
             else:
                 output.speak(_(u"There are no coordinates in this tweet"))
-  except GeocoderError:
-   output.speak(_(u"There are no results for the coordinates in this tweet"))
         except ValueError:
             output.speak(_(u"Error decoding coordinates. Try again later."))
-  except KeyError:
-   pass
+#        except KeyError:
+#            pass
         except AttributeError:
-   pass
+            output.speak(_("Unable to find address in OpenStreetMap."))
 
     def view_reverse_geocode(self, event=None):
         try:
@@ -1234,14 +1256,17 @@ class Controller(object):
         keymap = {}
         for i in config.keymap["keymap"]:
             if hasattr(self, i):
+                if config.keymap["keymap"][i] != "":
                     keymap[config.keymap["keymap"][i]] = getattr(self, i)
         return keymap
 
     def register_invisible_keyboard_shorcuts(self, keymap):
         if config.changed_keymap:
             commonMessageDialogs.changed_keymap()
+        # Make sure we pass a keymap without undefined keystrokes.
+        new_keymap = {key: keymap[key] for key in keymap.keys() if keymap[key] != ""}
         self.keyboard_handler = WXKeyboardHandler(self.view)
-  self.keyboard_handler.register_keys(keymap)
+        self.keyboard_handler.register_keys(new_keymap)
 
     def unregister_invisible_keyboard_shorcuts(self, keymap):
         try:
@@ -1268,16 +1293,16 @@ class Controller(object):
     def manage_sent_tweets(self, data, user):
         buffer = self.search_buffer("sent_tweets", user)
         if buffer == None: return
-#  if "sent_tweets" not in buffer.session.settings["other_buffers"]["muted_buffers"]:
-#   self.notify(buffer.session, play_sound=play_sound)
         data = buffer.session.check_quoted_status(data)
         data = buffer.session.check_long_tweet(data)
         if data == False: # Long tweet deleted from twishort.
             return 
+        items = buffer.session.db[buffer.name]
         if buffer.session.settings["general"]["reverse_timelines"] == False:
-   buffer.session.db[buffer.name].append(data)
+            items.append(data)
         else:
-   buffer.session.db[buffer.name].insert(0, data)
+            items.insert(0, data)
+        buffer.session.db[buffer.name] = items
         buffer.add_new_item(data)
 
     def manage_friend(self, data, user):
@@ -1326,11 +1351,10 @@ class Controller(object):
                         i.start_stream()
                     else:
                         i.start_stream(play_sound=False)
-    except TweepError as err:
-     log.exception("Error %s starting buffer %s on account %s, with args %r and kwargs %r due to the following reason: %s" % (err.api_code, i.name, i.account, i.args, i.kwargs, err.reason))
+                except TweepyException as err:
+                    log.exception("Error %s starting buffer %s on account %s, with args %r and kwargs %r." % (str(err), i.name, i.account, i.args, i.kwargs))
                     # Determine if this error was caused by a block applied to the current user (IE permission errors).
-     errors_allowed = [130]
-     if (err.api_code != None and err.api_code not in errors_allowed) or (err.api_code == None and 'Not authorized' in err.reason): # A twitter error, so safely try to remove the buffer.
+                    if type(err) == Forbidden:
                         buff = self.view.search(i.name, i.account)
                         i.remove_buffer(force=True)
                         commonMessageDialogs.blocked_timeline()
@@ -1354,48 +1378,44 @@ class Controller(object):
             try:
                 if sessions.sessions[i].is_logged == False: continue
                 sessions.sessions[i].check_connection()
-   except TweepError: # We shouldn't allow this function to die.
+            except TweepyException: # We shouldn't allow this function to die.
                 pass
 
     def create_new_buffer(self, buffer, account, create):
         buff = self.search_buffer("home_timeline", account)
         if create == True:
             if buffer == "favourites":
-    favourites = twitterBuffers.baseBufferController(self.view.nb, "favorites", "favourites", buff.session, buff.session.db["user_name"], tweet_mode="extended")
+                favourites = buffers.twitter.BaseBuffer(self.view.nb, "get_favorites", "favourites", buff.session, buff.session.db["user_name"], tweet_mode="extended")
                 self.buffers.append(favourites)
                 self.view.insert_buffer(favourites.buffer, name=_(u"Likes"), pos=self.view.search(buff.session.db["user_name"], buff.session.db["user_name"]))
                 favourites.start_stream(play_sound=False)
             if buffer == "followers":
-    followers = twitterBuffers.peopleBufferController(self.view.nb, "followers", "followers", buff.session, buff.session.db["user_name"], screen_name=buff.session.db["user_name"])
+                followers = buffers.twitter.PeopleBuffer(self.view.nb, "get_followers", "followers", buff.session, buff.session.db["user_name"], screen_name=buff.session.db["user_name"])
                 self.buffers.append(followers)
                 self.view.insert_buffer(followers.buffer, name=_(u"Followers"), pos=self.view.search(buff.session.db["user_name"], buff.session.db["user_name"]))
                 followers.start_stream(play_sound=False)
             elif buffer == "friends":
-    friends = twitterBuffers.peopleBufferController(self.view.nb, "friends", "friends", buff.session, buff.session.db["user_name"], screen_name=buff.session.db["user_name"])
+                friends = buffers.twitter.PeopleBuffer(self.view.nb, "get_friends", "friends", buff.session, buff.session.db["user_name"], screen_name=buff.session.db["user_name"])
                 self.buffers.append(friends)
                 self.view.insert_buffer(friends.buffer, name=_(u"Friends"), pos=self.view.search(buff.session.db["user_name"], buff.session.db["user_name"]))
                 friends.start_stream(play_sound=False)
             elif buffer == "blocked":
-    blocks = twitterBuffers.peopleBufferController(self.view.nb, "blocks", "blocked", buff.session, buff.session.db["user_name"])
+                blocks = buffers.twitter.PeopleBuffer(self.view.nb, "get_blocks", "blocked", buff.session, buff.session.db["user_name"])
                 self.buffers.append(blocks)
                 self.view.insert_buffer(blocks.buffer, name=_(u"Blocked users"), pos=self.view.search(buff.session.db["user_name"], buff.session.db["user_name"]))
                 blocks.start_stream(play_sound=False)
             elif buffer == "muted":
-    muted = twitterBuffers.peopleBufferController(self.view.nb, "mutes", "muted", buff.session, buff.session.db["user_name"])
+                muted = buffers.twitter.PeopleBuffer(self.view.nb, "get_mutes", "muted", buff.session, buff.session.db["user_name"])
                 self.buffers.append(muted)
                 self.view.insert_buffer(muted.buffer, name=_(u"Muted users"), pos=self.view.search(buff.session.db["user_name"], buff.session.db["user_name"]))
                 muted.start_stream(play_sound=False)
-   elif buffer == "events":
-    events = twitterBuffers.eventsBufferController(self.view.nb, "events", buff.session, buff.session.db["user_name"], bufferType="dmPanel", screen_name=buff.session.db["user_name"])
-    self.buffers.append(events)
-    self.view.insert_buffer(events.buffer, name=_(u"Events"), pos=self.view.search(buff.session.db["user_name"], buff.session.db["user_name"]))
         elif create == False:
             self.destroy_buffer(buffer, buff.session.db["user_name"])
         elif buffer == "list":
             if create in buff.session.settings["other_buffers"]["lists"]:
                 output.speak(_(u"This list is already opened"), True)
                 return
-   tl = twitterBuffers.listBufferController(self.view.nb, "list_timeline", create+"-list", buff.session, buff.session.db["user_name"], bufferType=None, list_id=utils.find_list(create, buff.session.db["lists"]), tweet_mode="extended")
+            tl = buffers.twitter.ListBuffer(self.view.nb, "list_timeline", create+"-list", buff.session, buff.session.db["user_name"], bufferType=None, list_id=utils.find_list(create, buff.session.db["lists"]), tweet_mode="extended")
             buff.session.lists.append(tl)
             pos=self.view.search("lists", buff.session.db["user_name"])
             self.insert_buffer(tl, pos)
@@ -1536,11 +1556,10 @@ class Controller(object):
             if i.session != None and i.session.is_logged == True:
                 try:
                     i.start_stream(mandatory=True)
-    except TweepError as err:
-     log.exception("Error %s starting buffer %s on account %s, with args %r and kwargs %r due to the following reason: %s" % (err.api_code, i.name, i.account, i.args, i.kwargs, err.reason))
+                except TweepyException as err:
+                    log.exception("Error %s starting buffer %s on account %s, with args %r and kwargs %r." % (str(err), i.name, i.account, i.args, i.kwargs))
                     # Determine if this error was caused by a block applied to the current user (IE permission errors).
-     errors_allowed = [130]
-     if (err.api_code != None and err.api_code not in errors_allowed) or (err.api_code == None and 'Not authorized' in err.reason): # A twitter error, so safely try to remove the buffer.
+                    if type(err) == Forbidden:
                         buff = self.view.search(i.name, i.account)
                         i.remove_buffer(force=True)
                         commonMessageDialogs.blocked_timeline()
@@ -1623,4 +1642,28 @@ class Controller(object):
 
     def save_data_in_db(self):
         for i in sessions.sessions:
-   sessions.sessions[i].shelve()
+            sessions.sessions[i].save_persistent_data()
+
+    def manage_new_tweet(self, data, user, _buffers):
+        sound_to_play = None
+        for buff in _buffers:
+            buffer = self.search_buffer(buff, user)
+            if buffer == None or buffer.session.db["user_name"] != user: return
+            buffer.add_new_item(data)
+            if buff == "home_timeline": sound_to_play = "tweet_received.ogg"
+            elif buff == "mentions": sound_to_play = "mention_received.ogg"
+            elif buff == "sent_tweets": sound_to_play = "tweet_send.ogg"
+            elif "timeline" in buff: sound_to_play = "tweet_timeline.ogg"
+            else: sound_to_play = None
+            if sound_to_play != None and buff not in buffer.session.settings["other_buffers"]["muted_buffers"]:
+                self.notify(buffer.session, sound_to_play)
+
+    def check_streams(self):
+        if self.started == False:
+            return
+        for i in sessions.sessions:
+            try:
+                if sessions.sessions[i].is_logged == False: continue
+                sessions.sessions[i].check_streams()
+            except TweepyException: # We shouldn't allow this function to die.
+                pass

src/controller/messages.py

@@ -102,14 +102,14 @@ class basicTweet(object):
         else:
             self.message.disable_button("shortenButton")
             self.message.disable_button("unshortenButton")
-  if self.message.get("long_tweet") == False:
+        if self.message.get("long_tweet") == False and hasattr(self, "max"):
             text = self.message.get_text()
             results = parse_tweet(text)
             self.message.set_title(_(u"%s - %s of %d characters") % (self.title, results.weightedLength, self.max))
             if results.weightedLength > self.max:
                 self.session.sound.play("max_length.ogg")
         else:
-   self.message.set_title(_(u"%s - %s characters") % (self.title, results.weightedLength))
+            self.message.set_title(_(u"%s - %s characters") % (self.title, len(self.message.get_text())))
 
     def spellcheck(self, event=None):
         text = self.message.get_text()
@@ -205,7 +205,7 @@ class dm(basicTweet):
         c.show_menu("dm")
 
 class viewTweet(basicTweet):
- def __init__(self, tweet, tweetList, is_tweet=True, utc_offset=0, date=""):
+    def __init__(self, tweet, tweetList, is_tweet=True, utc_offset=0, date="", item_url=""):
         """ This represents a tweet displayer. However it could be used for showing something wich is not a tweet, like a direct message or an event.
          param tweet: A dictionary that represents a full tweet or a string for non-tweets.
          param tweetList: If is_tweet is set to True, this could be a list of quoted tweets.
@@ -273,6 +273,10 @@ class viewTweet(basicTweet):
             text = tweet
             self.message = message.viewNonTweet(text, date)
         widgetUtils.connect_event(self.message.spellcheck, widgetUtils.BUTTON_PRESSED, self.spellcheck)
+        if item_url != "":
+            self.message.enable_button("share")
+            widgetUtils.connect_event(self.message.share, widgetUtils.BUTTON_PRESSED, self.share)
+            self.item_url = item_url
         widgetUtils.connect_event(self.message.translateButton, widgetUtils.BUTTON_PRESSED, self.translate)
         if self.contain_urls() == True:
             self.message.enable_button("unshortenButton")
@@ -290,3 +294,8 @@ class viewTweet(basicTweet):
             if "https://twitter.com/" in i:
                 text = text.replace(i, "\n")
         return text
+
+    def share(self, *args, **kwargs):
+        if hasattr(self, "item_url"):
+            output.copy(self.item_url)
+            output.speak(_("Link copied to clipboard."))

src/controller/settings.py

@@ -1,7 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import unicode_literals
-from builtins import str
-from builtins import object
 import os
 import webbrowser
 import sound_lib
@@ -151,6 +148,7 @@ class accountSettingsController(globalSettingsController):
         else:
             self.dialog.set_value("general", "retweet_mode", _(u"Retweet with comments"))
         self.dialog.set_value("general", "persist_size", str(self.config["general"]["persist_size"]))
+        self.dialog.set_value("general", "load_cache_in_memory", self.config["general"]["load_cache_in_memory"])
         self.dialog.create_reporting()
         self.dialog.set_value("reporting", "speech_reporting", self.config["reporting"]["speech_reporting"])
         self.dialog.set_value("reporting", "braille_reporting", self.config["reporting"]["braille_reporting"])
@@ -193,6 +191,9 @@ class accountSettingsController(globalSettingsController):
             self.config["general"]["relative_times"] = self.dialog.get_value("general", "relative_time")
         self.config["general"]["show_screen_names"] = self.dialog.get_value("general", "show_screen_names")
         self.config["general"]["max_tweets_per_call"] = self.dialog.get_value("general", "itemsPerApiCall")
+        if self.config["general"]["load_cache_in_memory"] != self.dialog.get_value("general", "load_cache_in_memory"):
+            self.config["general"]["load_cache_in_memory"] = self.dialog.get_value("general", "load_cache_in_memory")
+            self.needs_restart = True
         if self.config["general"]["persist_size"] != self.dialog.get_value("general", "persist_size"):
             if self.dialog.get_value("general", "persist_size") == '':
                 self.config["general"]["persist_size"] =-1

src/controller/trendingTopics.py

@@ -8,7 +8,7 @@ class trendingTopicsController(object):
         self.countries = {}
         self.cities = {}
         self.dialog = trends.trendingTopicsDialog()
-  self.information = session.twitter.trends_available()
+        self.information = session.twitter.available_trends()
         self.split_information()
         widgetUtils.connect_event(self.dialog.country, widgetUtils.RADIOBUTTON, self.get_places)
         widgetUtils.connect_event(self.dialog.city, widgetUtils.RADIOBUTTON, self.get_places)

src/controller/user.py

@@ -6,7 +6,7 @@ import output
 from wxUI.dialogs import update_profile, show_user
 import logging
 log = logging.getLogger("controller.user")
-from tweepy.error import TweepError
+from tweepy.errors import TweepyException, Forbidden, NotFound
 from sessions.twitter import utils
 
 class profileController(object):
@@ -24,12 +24,12 @@ class profileController(object):
         else:
             try:
                 self.get_data(screen_name=self.user)
-   except TweepError as err:
-    if err.api_code == 50:
+            except TweepyException as err:
+                if type(err) == NotFound:
                     wx.MessageDialog(None, _(u"That user does not exist"), _(u"Error"), wx.ICON_ERROR).ShowModal()
-    if err.api_code == 403:
+                if type(err) == Forbidden:
                     wx.MessageDialog(None, _(u"User has been suspended"), _(u"Error"), wx.ICON_ERROR).ShowModal()
-    log.error("error %d: %s" % (err.api_code, err.reason))
+                log.error("error %s" % (str(err)))
                 return
             self.dialog = show_user.showUserProfile()
             string = self.get_user_info()
@@ -44,7 +44,7 @@ class profileController(object):
     def get_data(self, screen_name):
         self.data = self.session.twitter.get_user(screen_name=screen_name)
         if screen_name != self.session.db["user_name"]:
-   self.friendship_status = self.session.twitter.show_friendship(source_screen_name=self.session.db["user_name"], target_screen_name=screen_name)
+            self.friendship_status = self.session.twitter.get_friendship(source_screen_name=self.session.db["user_name"], target_screen_name=screen_name)
 
     def fill_profile_fields(self):
         self.dialog.set_name(self.data.name)
@@ -83,12 +83,12 @@ class profileController(object):
         if self.file != None:
             try:
                 self.session.twitter.update_profile_image(image=self.file)
-   except TweepError as e:
-    output.speak(u"Error %s. %s" % (e.api_code, e.reason))
+            except TweepyException as e:
+                output.speak(u"Error %s" % (str(e)))
         try:
             self.session.twitter.update_profile(name=name, description=description, location=location, url=url)
-  except TweepError as e:
-   output.speak(u"Error %s. %s" % (e.api_code, e.reason))
+        except TweepyException as e:
+            output.speak(u"Error %s." % (str(e)))
 
     def get_user_info(self):
         string = u""

src/controller/userActionsController.py

@@ -3,7 +3,7 @@ import widgetUtils
 import output
 from wxUI.dialogs import userActions
 from pubsub import pub
-from tweepy.error  import TweepError
+from tweepy.errors  import TweepyException
 from extra import autocompletionUsers
 
 class userActionsController(object):
@@ -29,44 +29,44 @@ class userActionsController(object):
     def follow(self, user):
         try:
             self.session.twitter.create_friendship(screen_name=user )
-  except TweepError as err:
-   output.speak("Error %s: %s" % (err.api_code, err.reason), True)
+        except TweepyException  as err:
+            output.speak("Error %s" % (str(err)), True)
 
     def unfollow(self, user):
         try:
             id = self.session.twitter.destroy_friendship(screen_name=user )
-  except TweepError as err:
-   output.speak("Error %s: %s" % (err.api_code, err.reason), True)
+        except TweepyException as err:
+            output.speak("Error %s" % (str(err)), True)
 
     def mute(self, user):
         try:
             id = self.session.twitter.create_mute(screen_name=user )
-  except TweepError as err:
-   output.speak("Error %s: %s" % (err.api_code, err.reason), True)
+        except TweepyException as err:
+            output.speak("Error %s" % (str(err)), True)
 
     def unmute(self, user):
         try:
             id = self.session.twitter.destroy_mute(screen_name=user )
-  except TweepError as err:
-   output.speak("Error %s: %s" % (err.api_code, err.reason), True)
+        except TweepyException as err:
+            output.speak("Error %s" % (str(err)), True)
 
     def report(self, user):
         try:
             id = self.session.twitter.report_spam(screen_name=user )
-  except TweepError as err:
-   output.speak("Error %s: %s" % (err.api_code, err.reason), True)
+        except TweepyException as err:
+            output.speak("Error %s" % (str(err)), True)
 
     def block(self, user):
         try:
             id = self.session.twitter.create_block(screen_name=user )
-  except TweepError as err:
-   output.speak("Error %s: %s" % (err.api_code, err.reason), True)
+        except TweepyException as err:
+            output.speak("Error %s" % (str(err)), True)
 
     def unblock(self, user):
         try:
             id = self.session.twitter.destroy_block(screen_name=user )
-  except TweepError as err:
-   output.speak("Error %s: %s" % (err.api_code, err.reason), True)
+        except TweepyException as err:
+            output.speak("Error %s" % (str(err)), True)
 
     def ignore_client(self, user):
         tweet = self.buffer.get_right_tweet()

src/controller/userAliasController.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+import widgetUtils
+from pubsub import pub
+from wxUI.dialogs import userAliasDialogs
+from extra import autocompletionUsers
+
+class userAliasController(object):
+    def __init__(self, settings):
+        super(userAliasController, self).__init__()
+        self.settings = settings
+        self.dialog = userAliasDialogs.userAliasEditorDialog()
+        self.update_aliases_manager()
+        widgetUtils.connect_event(self.dialog.add, widgetUtils.BUTTON_PRESSED, self.on_add)
+        widgetUtils.connect_event(self.dialog.edit, widgetUtils.BUTTON_PRESSED, self.on_edit)
+        widgetUtils.connect_event(self.dialog.remove, widgetUtils.BUTTON_PRESSED, self.on_remove)
+        pub.subscribe(self.update_aliases_manager, "alias-added")
+        self.dialog.ShowModal()
+
+    def update_aliases_manager(self):
+        self.dialog.users.Clear()
+        aliases = [self.settings["user-aliases"].get(k) for k in self.settings["user-aliases"].keys()]
+        if len(aliases) > 0:
+            self.dialog.users.InsertItems(aliases, 0)
+        self.dialog.on_selection_changes()
+
+    def on_add(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="add_alias")
+
+    def on_edit(self, *args, **kwargs):
+        selection = self.dialog.get_selected_user()
+        if selection != "":
+            edited = self.dialog.edit_alias_dialog(_("Edit alias for {}").format(selection))
+            if edited == None or edited == "":
+                return
+            for user_key in self.settings["user-aliases"].keys():
+                if self.settings["user-aliases"][user_key] == selection:
+                    self.settings["user-aliases"][user_key] = edited
+                    self.settings.write()
+                    self.update_aliases_manager()
+                    break
+
+    def on_remove(self, *args, **kwargs):
+        selection = self.dialog.get_selected_user()
+        if selection == None or selection == "":
+            return
+        should_remove = self.dialog.remove_alias_dialog()
+        if should_remove:
+            for user_key in self.settings["user-aliases"].keys():
+                if self.settings["user-aliases"][user_key] == selection:
+                    self.settings["user-aliases"].pop(user_key)
+                    self.settings.write()
+                    self.update_aliases_manager()
+                    break

src/extra/autocompletionUsers/manage.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import widgetUtils
+from tweepy.errors import TweepyException
 from . import storage, wx_manage
 from wxUI import commonMessageDialogs
 
@@ -27,8 +28,9 @@ class autocompletionManage(object):
         if usr == False:
             return
         try:
-   data = self.session.twitter.twitter.get_user(screen_name=usr)
-  except:
+            data = self.session.twitter.get_user(screen_name=usr)
+        except TweepyException as e:
+            log.exception("Exception raised when attempting to add an user to the autocomplete database manually.")
             self.dialog.show_invalid_user_error()
             return
         self.database.set_user(data.screen_name, data.name, 0)

src/extra/autocompletionUsers/storage.py

@@ -21,7 +21,7 @@ class storage(object):
         return self.cursor.fetchall()
 
     def get_users(self, term):
-  self.cursor.execute("""SELECT * FROM users WHERE user LIKE ?""", ('{}%'.format(term),))
+        self.cursor.execute("""SELECT * FROM users WHERE UPPER(user) LIKE :term OR UPPER(name) LIKE :term""", {"term": "%{}%".format(term.upper())})
         return self.cursor.fetchall()
 
     def set_user(self, screen_name, user_name, from_a_buffer):

src/fixes/fix_arrow.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import unicode_literals
 from arrow import locales
 from arrow.locales import Locale
 
@@ -8,88 +7,43 @@ def fix():
     locales.get_locale = get_locale
 
 def get_locale(name):
-	locale_cls = locales._locales.get(name.lower())
+    locale_cls = locales._locale_map.get(name.lower())
     if locale_cls is None:
         name = name[:2]
-		locale_cls = locales._locales.get(name.lower())
+        locale_cls = locales._locale_map.get(name.lower())
         if locale_cls == None:
             return locales.EnglishLocale()
     return locale_cls()
 
-class CatalaLocale(Locale):
-	names = ['ca', 'ca_es', 'ca_ca']
-	past = 'Fa {0}'
-	future = '{0}' # I don't know what's the right phrase in catala for the future.
-
-	timeframes = {
-		'now': 'Ara mateix',
-		'seconds': 'segons',
-		'minute': '1 minut',
-		'minutes': '{0} minuts',
-		'hour': 'una hora',
-		'hours': '{0} hores',
-		'day': 'un dia',
-		'days': '{0} dies',
-		'month': 'un mes',
-		'months': '{0} messos',
-		'year': 'un any',
-		'years': '{0} anys',
-	}
-
-	month_names = ['', 'Jener', 'Febrer', 'Març', 'Abril', 'Maig', 'Juny', 'Juliol', 'Agost', 'Setembre', 'Octubre', 'Novembre', 'Decembre']
-	month_abbreviations = ['', 'Jener', 'Febrer', 'Març', 'Abril', 'Maig', 'Juny', 'Juliol', 'Agost', 'Setembre', 'Octubre', 'Novembre', 'Decembre']
-	day_names = ['', 'Dilluns', 'Dimars', 'Dimecres', 'Dijous', 'Divendres', 'Disabte', 'Diumenge']
-	day_abbreviations = ['', 'Dilluns', 'Dimars', 'Dimecres', 'Dijous', 'Divendres', 'Disabte', 'Diumenge']
-
-class GalicianLocale(Locale):
+class GalicianLocale(object):
     names = ['gl', 'gl_es', 'gl_gl']
-	past = 'Fai {0}'
+    past = 'Hai {0}'
     future = 'En {0}'
+    and_word = "e"
 
     timeframes = {
-		'now': 'Agora mesmo',
-		'seconds': 'segundos',
+        'now': 'Agora',
+        "second": "un segundo",
+        'seconds': '{0} segundos',
         'minute': 'un minuto',
         'minutes': '{0} minutos',
-		'hour': 'una hora',
+        'hour': 'unha hora',
         'hours': '{0} horas',
         'day': 'un día',
         'days': '{0} días',
+        "week": "unha semana",
+        "weeks": "{0} semanas",
         'month': 'un mes',
         'months': '{0} meses',
         'year': 'un ano',
         'years': '{0} anos',
     }
 
-	month_names = ['', 'Xaneiro', 'Febreiro', 'Marzo', 'Abril', 'Maio', 'Xuño', 'Xullo', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Decembro']
-	month_abbreviations = ['', 'Xan', 'Feb', 'Mar', 'Abr', 'Mai', 'Xun', 'Xul', 'Ago', 'Set', 'Out', 'Nov', 'Dec']
-	day_names = ['', 'Luns', 'Martes', 'Mércores', 'Xoves', 'Venres', 'Sábado', 'Domingo']
-	day_abbreviations = ['', 'Lun', 'Mar', 'Mer', 'xov', 'Ven' 'Sab', 'Dom']
+    meridians = {"am": "am", "pm": "pm", "AM": "AM", "PM": "PM"}
 
-class BasqueLocale(Locale):
-	names = ['eu', 'eu_es', 'eu_eu']
-	past = 'duela {0}'
-	future = '{0} igarota'
-
-	timeframes = {
-		'now': 'Orain',
-		# 'second': 'segundu bat',
-		'seconds': 'segundu batzuk', # without specifying a number.
-		#'seconds':  '{0} segundu', # specifying a number
-		'minute': 'minutu bat',
-		'minutes': '{0} minutu',
-		'hour': 'ordu bat',
-		'hours': '{0} ordu',
-		'day': 'egun bat',
-		'days': '{0} egun',
-		'month': 'hilabete bat',
-		'months': '{0} hilabete',
-		'year': 'urte bat',
-		'years': '{0} urte',
-	}
-
-	month_names = ['', 'Urtarrilak', 'Otsailak', 'Martxoak', 'Apirilak', 'Maiatzak', 'Ekainak', 'Uztailak', 'Abuztuak', 'Irailak', 'Urriak', 'Azaroak', 'Abenduak']
-	month_abbreviations = ['', 'urt', 'ots', 'mar', 'api', 'mai', 'eka', 'uzt', 'abu', 'ira', 'urr', 'aza', 'abe']
-	day_names = ['', 'Asteleehna', 'Asteartea', 'Asteazkena', 'Osteguna', 'Ostirala', 'Larunbata', 'Igandea']
-	day_abbreviations = ['', 'al', 'ar', 'az', 'og', 'ol', 'lr', 'ig']
+    month_names = ['', 'xaneiro', 'febreiro', 'marzo', 'abril', 'maio', 'xuño', 'xullo', 'agosto', 'setembro', 'outubro', 'novembro', 'decembro']
+    month_abbreviations = ['', 'xan', 'feb', 'mar', 'abr', 'mai', 'xun', 'xul', 'ago', 'set', 'out', 'nov', 'dec']
+    day_names = ['', 'luns', 'martes', 'mércores', 'xoves', 'venres', 'sábado', 'domingo']
+    day_abbreviations = ['', 'lun', 'mar', 'mer', 'xov', 'ven', 'sab', 'dom']
+    ordinal_day_re = r"((?P<value>[1-3]?[0-9](?=[ºª]))[ºª])"
 

src/keymaps/Chicken Nugget.keymap

@@ -35,3 +35,4 @@ accountConfiguration = string(default="control+win+shift+o")
 update_buffer = string(default="control+win+shift+u")
 ocr_image = string(default="win+alt+o")
 open_in_browser = string(default="alt+control+win+return")
+add_alias=string(default="")

src/keymaps/Qwitter.keymap

@@ -54,3 +54,4 @@ accountConfiguration = string(default="control+win+shift+o")
 update_buffer = string(default="control+win+shift+u")
 ocr_image = string(default="win+alt+o")
 open_in_browser = string(default="alt+control+win+return")
+add_alias=string(default="")

src/keymaps/Windows 10.keymap

@@ -55,3 +55,4 @@ accountConfiguration = string(default="control+win+shift+o")
 update_buffer = string(default="control+alt+shift+u")
 ocr_image = string(default="win+alt+o")
 open_in_browser = string(default="alt+control+win+return")
+add_alias=string(default="")

src/keymaps/Windows11.keymap

@@ -0,0 +1,58 @@
+[info]
+name = string(default="Windows 11")
+desc = string(default="A keymap with remapped modifiers for Windows 11 compatibility.")
+author = string(default="Bill Jesús <galorasd@gmail.com>")
+
+[keymap]
+up = string(default="control+alt+win+up")
+down = string(default="control+alt+win+down")
+left = string(default="control+alt+win+left")
+right = string(default="control+alt+win+right")
+next_account = string(default="control+alt+win+shift+right")
+previous_account = string(default="control+alt+win+shift+left")
+open_conversation = string(default="control+alt+win+c")
+show_hide = string(default="control+win+w")
+post_tweet = string(default="alt+win+n")
+post_reply = string(default="control+win+r")
+post_retweet = string(default="alt+win+shift+r")
+send_dm = string(default="alt+win+shift+d")
+toggle_like = string(default="control+alt+win+f")
+follow = string(default="alt+win+shift+s")
+user_details = string(default="alt+win+shift+n")
+view_item = string(default="alt+win+v")
+exit = string(default="alt+win+f4")
+open_timeline = string(default="alt+win+i")
+remove_buffer = string(default="alt+win+shift+i")
+url = string(default="alt+win+return")
+audio = string(default="alt+shift+win+return")
+volume_up = string(default="control+alt+win+shift+up")
+go_home = string(default="control+alt+win+home")
+volume_down = string(default="control+alt+win+shift+down")
+go_end = string(default="control+alt+win+end")
+go_page_up = string(default="control+win+pageup")
+go_page_down = string(default="control+win+pagedown")
+update_profile = string(default="alt+win+p")
+delete = string(default="alt+win+delete")
+clear_buffer = string(default="alt+win+shift+delete")
+repeat_item = string(default="control+alt+win+space")
+copy_to_clipboard = string(default="alt+win+shift+c")
+add_to_list = string(default="alt+win+a")
+remove_from_list = string(default="alt+win+shift+a")
+toggle_buffer_mute = string(default="alt+win+shift+m")
+toggle_session_mute = string(default="control+alt+win+m")
+toggle_autoread = string(default="alt+win+e")
+search = string(default="alt+win+-")
+edit_keystrokes = string(default="alt+win+k")
+view_user_lists = string(default="alt+win+l")
+get_more_items = string(default="alt+win+pageup")
+reverse_geocode = string(default="control+win+g")
+view_reverse_geocode = string(default="alt+win+shift+g")
+get_trending_topics = string(default="control+win+t")
+check_for_updates = string(default="alt+win+u")
+list_manager = string(default="alt+win+shift+l")
+configuration = string(default="control+win+alt+o")
+accountConfiguration = string(default="control+win+shift+o")
+update_buffer = string(default="control+alt+shift+u")
+ocr_image = string(default="win+alt+o")
+open_in_browser = string(default="alt+control+win+return")
+add_alias=string(default="")

src/keymaps/base.template

@@ -56,3 +56,4 @@ configuration = string(default="control+win+o")
 accountConfiguration = string(default="control+win+shift+o")
 update_buffer = string(default="control+win+shift+u")
 open_in_browser = string(default="alt+control+win+return")
+add_alias=string(default="")

src/keymaps/default.keymap

@@ -57,3 +57,4 @@ accountConfiguration = string(default="control+win+shift+o")
 update_buffer = string(default="control+win+shift+u")
 ocr_image = string(default="win+alt+o")
 open_in_browser = string(default="alt+control+win+return")
+add_alias=string(default="")

src/keystrokeEditor/constants.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import unicode_literals
 actions = {
     "up": _(u"Go up in the current buffer"),
     "down": _(u"Go down in the current buffer"),
@@ -57,4 +56,6 @@ actions = {
     "audio": _(u"Try to play an audio file"),
     "update_buffer": _(u"Updates the buffer and retrieves possible lost items there."),
     "ocr_image": _(u"Extracts the text from a picture and displays the result in a dialog."),
+    "add_alias": _("Adds an alias to an user"),
 }
+ 

src/keystrokeEditor/keystrokeEditor.py

@@ -1,7 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import absolute_import
-from __future__ import unicode_literals
-from builtins import object
 import widgetUtils
 import config
 from . import wx_ui
@@ -18,6 +15,7 @@ class KeystrokeEditor(object):
         self.hold_map = self.map.copy()
         self.dialog.put_keystrokes(constants.actions, self.map)
         widgetUtils.connect_event(self.dialog.edit, widgetUtils.BUTTON_PRESSED, self.edit_keystroke)
+        widgetUtils.connect_event(self.dialog.undefine, widgetUtils.BUTTON_PRESSED, self.undefine_keystroke)
         widgetUtils.connect_event(self.dialog.execute, widgetUtils.BUTTON_PRESSED, self.execute_action)
         self.dialog.get_response()
 
@@ -33,6 +31,17 @@ class KeystrokeEditor(object):
                 self.map[action] = new_keystroke
                 self.dialog.put_keystrokes(constants.actions, self.map)
 
+    def undefine_keystroke(self, *args, **kwargs):
+        action = self.dialog.actions[self.dialog.get_action()]
+        keystroke = self.map.get(action)
+        if keystroke == None:
+            return
+        answer = self.dialog.undefine_keystroke_confirmation()
+        if answer == widgetUtils.YES:
+            self.map[action] = ""
+            self.changed = True
+            self.dialog.put_keystrokes(constants.actions, self.map)
+
     def set_keystroke(self, keystroke, dialog):
         for i in keystroke.split("+"):
             if hasattr(dialog, i):

src/keystrokeEditor/wx_ui.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import unicode_literals
 import wx
 from multiplatform_widgets import widgets
 from wxUI.dialogs import baseDialog
@@ -18,6 +17,7 @@ class keystrokeEditorDialog(baseDialog.BaseWXDialog):
         firstSizer.Add(self.keys.list, 0, wx.ALL, 5)
         self.edit = wx.Button(panel, -1, _(u"Edit"))
         self.edit.SetDefault()
+        self.undefine = wx.Button(panel, -1, _("Undefine keystroke"))
         self.execute = wx.Button(panel, -1, _(u"Execute action"))
         close = wx.Button(panel, wx.ID_CANCEL, _(u"Close"))
         secondSizer = wx.BoxSizer(wx.HORIZONTAL)
@@ -37,13 +37,18 @@ class keystrokeEditorDialog(baseDialog.BaseWXDialog):
                 continue
             action = actions[i]
             self.actions.append(i)
-   keystroke = keystrokes[i]
+            keystroke = keystrokes.get(i)
+            if keystroke == "":
+                keystroke = _("Undefined")
             self.keys.insert_item(False, *[action, keystroke])
         self.keys.select_item(selection)
 
     def get_action(self):
         return self.keys.get_selected()
 
+    def undefine_keystroke_confirmation(self):
+        return wx.MessageDialog(self, _("Are you sure you want to undefine this keystroke?"), _("Undefine keystroke"), wx.YES_NO|wx.CANCEL|wx.ICON_QUESTION).ShowModal()
+
 class editKeystrokeDialog(baseDialog.BaseWXDialog):
     def __init__(self):
         super(editKeystrokeDialog, self).__init__(parent=None, id=-1, title=_(u"Editing keystroke"))

src/locales/ru/LC_MESSAGES/twblue.po

@@ -6,7 +6,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: TW Blue 0.85\n"
 "POT-Creation-Date: 2019-03-17 13:34+Hora estndar romance\n"
-"PO-Revision-Date: 2020-10-23 14:30+0300\n"
+"PO-Revision-Date: 2021-07-05 16:03+0200\n"
 "Last-Translator: Artem Plaksin <admin@maniyax.ru>\n"
 "Language-Team: Alexander Jaszyn <a.jaszyn@ya.ru>\n"
 "Language: ru\n"
@@ -14,7 +14,7 @@ msgstr ""
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Generated-By: pygettext.py 1.5\n"
-"X-Generator: Poedit 1.8.8\n"
+"X-Generator: Poedit 3.0\n"
 "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
 "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
 "X-Poedit-SourceCharset: UTF-8\n"
@@ -208,14 +208,12 @@ msgstr ""
 "личных сообщений вместо этого."
 
 #: ../src\controller\buffers\twitterBuffers.py:983
-#, fuzzy
 msgid "{0} new followers."
-msgstr "Новый читатель."
+msgstr "{0} новых читателей."
 
 #: ../src\controller\buffers\twitterBuffers.py:1266
-#, fuzzy
 msgid "This action is not supported in the buffer, yet."
-msgstr "Это действие не поддерживается в данном буфере"
+msgstr "Это действие пока не поддерживается в буфере."
 
 #: ../src\controller\mainController.py:273
 msgid "Ready"
@@ -314,9 +312,8 @@ msgid "Select the user"
 msgstr "Выберите пользователя"
 
 #: ../src\controller\mainController.py:809 ../src\controller\messages.py:236
-#, fuzzy
 msgid "MMM D, YYYY. H:m"
-msgstr "dddd, MMMM D, YYYY H:m:s"
+msgstr "MMM D, YYYY. H:m"
 
 #: ../src\controller\mainController.py:934
 msgid "Conversation with {0}"
@@ -1702,9 +1699,8 @@ msgid "Opens the global settings dialogue"
 msgstr "Открыть основные настройки"
 
 #: ../src\keystrokeEditor\constants.py:54
-#, fuzzy
 msgid "Opens the list manager"
-msgstr "Менеджер Списков"
+msgstr "Открывает менеджер списков"
 
 #: ../src\keystrokeEditor\constants.py:55
 msgid "Opens the account settings dialogue"

src/paths.py

@@ -39,7 +39,7 @@ def logs_path():
         os.mkdir(path)
     return path
 
-def data_path(app_name='socializer'):
+def data_path(app_name='TW Blue'):
     if platform.system() == "Windows":
         data_path = os.path.join(os.getenv("AppData"), app_name)
     else:

src/run_tests.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+import unittest
+
+testmodules = ["test.test_cache"]
+
+suite = unittest.TestSuite()
+
+for t in testmodules:
+    try:
+        # If the module defines a suite() function, call it to get the suite.
+        mod = __import__(t, globals(), locals(), ['suite'])
+        suitefn = getattr(mod, 'suite')
+        suite.addTest(suitefn())
+    except (ImportError, AttributeError):
+        # else, just load all the test cases from the module.
+        suite.addTest(unittest.defaultTestLoader.loadTestsFromName(t))
+
+unittest.TextTestRunner(verbosity=2).run(suite)

src/sessionmanager/sessionManager.py

@@ -17,7 +17,7 @@ from sessions.twitter import session
 from . import manager
 import config_utils
 import config
-from tweepy.error import TweepError
+from tweepy.errors import TweepyException
 log = logging.getLogger("sessionmanager.sessionManager")
 
 class sessionManagerController(object):
@@ -83,7 +83,7 @@ class sessionManagerController(object):
             if i not in config.app["sessions"]["ignored_sessions"]:
                 try:
                     s.login()
-    except TweepError:
+                except TweepyException:
                     self.show_auth_error(s.settings["twitter"]["user_name"])
                     continue
             sessions.sessions[i] = s

src/sessions/base.py

@@ -1,9 +1,5 @@
 # -*- coding: utf-8 -*-
 """ A base class to be derived in possible new sessions for TWBlue and services."""
-from __future__ import absolute_import
-from __future__ import unicode_literals
-from builtins import str
-from builtins import object
 import os
 import paths
 import output
@@ -11,9 +7,8 @@ import time
 import sound
 import logging
 import config_utils
-import shelve
+import sqlitedict
 import application
-import os
 from . import session_exceptions as Exceptions
 log = logging.getLogger("sessionmanager.session")
 
@@ -48,6 +43,10 @@ class baseSession(object):
         self.logged = False
         self.settings = None
         self.db={}
+        # Config specification file.
+        self.config_spec = "conf.defaults"
+        # Session type.
+        self.type = "base"
 
     @property
     def is_logged(self):
@@ -57,9 +56,9 @@ class baseSession(object):
         """ Get settings for a session."""
         file_ = "%s/session.conf" % (self.session_id,)
         log.debug("Creating config file %s" % (file_,))
-		self.settings = config_utils.load_config(os.path.join(paths.config_path(), file_), os.path.join(paths.app_path(), "Conf.defaults"))
+        self.settings = config_utils.load_config(os.path.join(paths.config_path(), file_), os.path.join(paths.app_path(), self.config_spec))
         self.init_sound()
-		self.deshelve()
+        self.load_persistent_data()
 
     def init_sound(self):
         try: self.sound = sound.soundSystem(self.settings["sound"])
@@ -73,48 +72,88 @@ class baseSession(object):
     def authorise(self):
         pass
 
-	def shelve(self):
-		"""Shelve the database to allow for persistance."""
-		shelfname=os.path.join(paths.config_path(), str(self.session_id), "cache")
-		if self.settings["general"]["persist_size"] == 0:
-			if os.path.exists(shelfname+".dat"):
-				os.remove(shelfname+".dat")
-			return
-		try:
-			if not os.path.exists(shelfname+".dat"):
-				output.speak("Generating database, this might take a while.",True)
-			shelf=shelve.open(os.path.join(paths.config_path(), shelfname),'c')
-			for key, value in list(self.db.items()):
-				if type(key) != str and type(key) != str:
-					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)) + "!")
-				if type(value) == list and self.settings["general"]["persist_size"] != -1 and len(value) > self.settings["general"]["persist_size"]:
-					shelf[key]=value[self.settings["general"]["persist_size"]:]
+    def get_sized_buffer(self, buffer, size, reversed=False):
+        """ Returns a list with the amount of items specified by size."""
+        if isinstance(buffer, list) and size != -1 and len(buffer) > size:
+            log.debug("Requesting {} items from a list of {} items. Reversed mode: {}".format(size, len(buffer), reversed))
+            if reversed == True:
+                return buffer[:size]
             else:
-					shelf[key]=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)
+                return buffer[len(buffer)-size:]
+        else:
+            return buffer
 
-	def deshelve(self):
-		"""Import a shelved database."""
-		shelfname=os.path.join(paths.config_path(), str(self.session_id)+"/cache")
+    def save_persistent_data(self):
+        """ Save the data to a persistent sqlite backed file. ."""
+        dbname=os.path.join(paths.config_path(), str(self.session_id), "cache.db")
+        log.debug("Saving storage information...")
+        # persist_size set to 0 means not saving data actually.
         if self.settings["general"]["persist_size"] == 0:
-			if os.path.exists(shelfname+".dat"):
-				os.remove(shelfname+".dat")
+            if os.path.exists(dbname):
+                os.remove(dbname)
             return
+        # Let's check if we need to create a new SqliteDict object (when loading db in memory) or we just need to call to commit in self (if reading from disk).db.
+        # If we read from disk, we cannot modify the buffer size here as we could damage the app's integrity.
+        # We will modify buffer's size (managed by persist_size) upon loading the db into memory in app startup.
+        if self.settings["general"]["load_cache_in_memory"] and isinstance(self.db, dict):
+            log.debug("Opening database to dump memory contents...")
+            db=sqlitedict.SqliteDict(dbname, 'c')
+            for k in self.db.keys():
+                sized_buff = self.get_sized_buffer(self.db[k], self.settings["general"]["persist_size"], self.settings["general"]["reverse_timelines"])
+                db[k] = sized_buff
+            db.commit(blocking=True)
+            db.close()
+            log.debug("Data has been saved in the database.")
+        else:
             try:
-			shelf=shelve.open(os.path.join(paths.config_path(), shelfname),'c')
-			for key,value in list(shelf.items()):
-				self.db[key]=value
-			shelf.close()
+                log.debug("Syncing new data to disk...")
+                if hasattr(self.db, "commit"):
+                    self.db.commit()
             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)
+                output.speak(_("An exception occurred while saving the {app} database. It will be deleted and rebuilt automatically. If this error persists, send the error log to the {app} developers.").format(app=application.name),True)
+                log.exception("Exception while saving {}".format(dbname))
+                os.remove(dbname)
+
+    def load_persistent_data(self):
+        """Import data from a database file from user config."""
+        log.debug("Loading storage data...")
+        dbname=os.path.join(paths.config_path(), str(self.session_id), "cache.db")
+        # If persist_size is set to 0, we should remove the db file as we are no longer going to save anything.
+        if self.settings["general"]["persist_size"] == 0:
+            if os.path.exists(dbname):
+                os.remove(dbname)
+            # Let's return from here, as we are not loading anything.
+            return
+        # try to load the db file.
         try:
-				os.remove(shelfname)
+            log.debug("Opening database...")
+            db=sqlitedict.SqliteDict(os.path.join(paths.config_path(), dbname), 'c')
+            # If load_cache_in_memory is set to true, we will load the whole database into memory for faster access.
+            # This is going to be faster when retrieving specific objects, at the cost of more memory.
+            # Setting this to False will read the objects from database as they are needed, which might be slower for bigger datasets.
+            if self.settings["general"]["load_cache_in_memory"]:
+                log.debug("Loading database contents into memory...")
+                for k in db.keys():
+                    self.db[k] = db[k]
+                db.commit(blocking=True)
+                db.close()
+                log.debug("Contents were loaded successfully.")
+            else:
+                log.debug("Instantiating database from disk.")
+                self.db = db
+                # We must make sure we won't load more than the amount of buffer specified.
+                log.debug("Checking if we will load all content...")
+                for k in self.db.keys():
+                    sized_buffer = self.get_sized_buffer(self.db[k], self.settings["general"]["persist_size"], self.settings["general"]["reverse_timelines"])
+                    self.db[k] = sized_buffer
+            if self.db.get("cursors") == None:
+                cursors = dict(direct_messages=-1)
+                self.db["cursors"] = cursors
+        except:
+            output.speak(_("An exception occurred while loading the {app} database. It will be deleted and rebuilt automatically. If this error persists, send the error log to the {app} developers.").format(app=application.name), True)
+            log.exception("Exception while loading {}".format(dbname))
+            try: 
+                os.remove(dbname)
             except:
                 pass
 

src/sessions/twitter/compose.py

@@ -1,11 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import absolute_import
-from __future__ import unicode_literals
-from future import standard_library
-standard_library.install_aliases()
-from builtins import str
-from builtins import chr
-from builtins import range
 import platform
 system = platform.system()
 from . import utils
@@ -52,33 +45,32 @@ def compose_tweet(tweet, db, relative_times, show_screen_names=False, session=No
     else:
         value = "text"
     if hasattr(tweet, "retweeted_status") and value != "message":
-  text = StripChars(getattr(tweet.retweeted_status, value))
+        text = utils.clean_mentions(StripChars(getattr(tweet.retweeted_status, value)))
     else:
-  text = StripChars(getattr(tweet, value))
+        text = utils.clean_mentions(StripChars(getattr(tweet, value)))
     if show_screen_names:
-  user = tweet.user.screen_name
+        user = session.get_user(tweet.user).screen_name
     else:
-  user = tweet.user.name
+        user = session.get_user(tweet.user).name
     source = re.sub(r"(?s)<.*?>", "", tweet.source)
     if hasattr(tweet, "retweeted_status"):
-  if (hasattr(tweet, "message")) == False and tweet.retweeted_status.is_quote_status == False:
-   text = "RT @%s: %s" % (tweet.retweeted_status.user.screen_name, text)
-  elif tweet.retweeted_status.is_quote_status:
+        if hasattr(tweet, "message") == False and hasattr(tweet.retweeted_status, "is_quote_status") == False:
+            text = "RT @%s: %s" % (session.get_user(tweet.retweeted_status.user).screen_name, text)
+        elif hasattr(tweet.retweeted_status, "is_quote_status"):
             text = "%s" % (text)
         else:
-   text = "RT @%s: %s" % (tweet.retweeted_status.user.screen_name, text)
+            text = "RT @%s: %s" % (session.get_user(tweet.retweeted_status.user).screen_name, text)
     if not hasattr(tweet, "message"):
-
         if hasattr(tweet, "retweeted_status"):
+            if hasattr(tweet.retweeted_status, "entities"):
                 text = utils.expand_urls(text, tweet.retweeted_status.entities)
         else:
+            if hasattr(tweet, "entities"):
                 text = utils.expand_urls(text, tweet.entities)
         if config.app['app-settings']['handle_longtweets']: pass
     return [user+", ", text, ts+", ", source]
 
 def compose_direct_message(item, db, relative_times, show_screen_names=False, session=None):
- # for a while this function will be together with compose_dm.
- # this one composes direct messages based on events (new API Endpoints).
     if system == "Windows":
         # Let's remove the last 3 digits in the timestamp string.
         # Twitter sends their "epoch" timestamp with 3 digits for milliseconds and arrow doesn't like it.
@@ -119,24 +111,29 @@ def compose_quoted_tweet(quoted_tweet, original_tweet, show_screen_names=False,
             value = "full_text"
         else:
             value = "text"
-  text = StripChars(getattr(quoted_tweet, value))
+        text = utils.clean_mentions(StripChars(getattr(quoted_tweet, value)))
     if show_screen_names:
-  quoting_user = quoted_tweet.user.screen_name
+        quoting_user = session.get_user(quoted_tweet.user).screen_name
     else:
-  quoting_user = quoted_tweet.user.name
+        quoting_user = session.get_user(quoted_tweet.user).name
     source = quoted_tweet.source
     if hasattr(quoted_tweet, "retweeted_status"):
-  text = "rt @%s: %s" % (quoted_tweet.retweeted_status.user.screen_name, text)
+        text = "rt @%s: %s" % (session.get_user(quoted_tweet.retweeted_status.user).screen_name, text)
     if text[-1] in chars: text=text+"."
- original_user = original_tweet.user.screen_name
+    original_user = session.get_user(original_tweet.user).screen_name
     if hasattr(original_tweet, "message"):
         original_text = original_tweet.message
     elif hasattr(original_tweet, "full_text"):
-  original_text = StripChars(original_tweet.full_text)
+        original_text = utils.clean_mentions(StripChars(original_tweet.full_text))
     else:
-   original_text = StripChars(original_tweet.text)
+        original_text = utils.clean_mentions(StripChars(original_tweet.text))
     quoted_tweet.message = _(u"{0}. Quoted  tweet from @{1}: {2}").format( text, original_user, original_text)
     quoted_tweet = tweets.clear_url(quoted_tweet)
+    if hasattr(original_tweet, "entities") and original_tweet.entities.get("urls"):
+        if hasattr(quoted_tweet, "entities") == False:
+            quoted_tweet.entities = {}
+        if quoted_tweet.entities.get("urls") == None:
+            quoted_tweet.entities["urls"] = []
         quoted_tweet.entities["urls"].extend(original_tweet.entities["urls"])
     return quoted_tweet
 

src/sessions/twitter/long_tweets/twishort.py

@@ -40,6 +40,7 @@ def is_long(tweet):
     """ Check if the passed tweet is made with Twishort.
      returns True if is a long tweet, False otherwise."""
     long = False
+    if hasattr(tweet, "entities") and tweet.entities.get("urls"):
         for url in range(0, len(tweet.entities["urls"])):
             try:
                 if tweet.entities["urls"][url] != None and "twishort.com" in tweet.entities["urls"][url]["expanded_url"]:
@@ -51,14 +52,7 @@ def is_long(tweet):
             except TypeError:
                 pass
     if long == False and hasattr(tweet, "retweeted_status"):
-  for url in range(0, len(tweet.retweeted_status.entities["urls"])):
-   try:
-    if tweet.retweeted_status.entities["urls"][url] != None and "twishort.com" in tweet.retweeted_status.entities["urls"][url]["expanded_url"]:
-     long = get_twishort_uri(tweet.retweeted_status.entities["urls"][url]["expanded_url"])
-   except IndexError:
-    pass
-   except TypeError:
-    pass
+        return is_long(tweet.retweeted_status)
     return long
 
 def get_full_text(uri):

src/sessions/twitter/reduce.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+""" Strips unneeded tweet information in order to store tweet objects by using less memory. This is especially useful when buffers start to contain more than a certain amount of items. """
+from tweepy.models import Status
+
+def reduce_tweet(tweet):
+    """ generates a new Tweet model with the fields we currently need, excluding everything else  including null values and empty collections. """
+    allowed_values = ["created_at", "id", "full_text", "text", "message", "in_reply_to_status_id", "in_reply_to_user_id", "is_quote_status", "lang", "source", "coordinates", "quoted_status_id", "extended_entities"]
+    allowed_entities = ["hashtags", "media", "urls", "user_mentions", "polls"]
+    status_dict = {}
+    for key in allowed_values:
+        if tweet._json.get(key):
+            status_dict[key] = tweet._json[key]
+    entities = dict()
+    for key in allowed_entities:
+        if tweet._json["entities"].get(key) and tweet._json["entities"].get(key) != None:
+            entities[key] = tweet._json["entities"][key]
+    status_dict["entities"] = entities
+    # If tweet comes from the cached database, it does not include an API,  so we can pass None here as we do not use that reference to tweepy's API.
+    if hasattr(tweet, "_api"):
+        api = tweet._api
+    else:
+        api = None
+    status = Status().parse(api=api, json=status_dict)
+    # Quotes and retweets are different objects. So we parse a new tweet when we have a quoted or retweeted status here.
+    if tweet._json.get("quoted_status"):
+        quoted_tweet = reduce_tweet(tweet.quoted_status)
+        status.quoted_status = quoted_tweet
+    if tweet._json.get("retweeted_status"):
+        retweeted_tweet = reduce_tweet(tweet.retweeted_status)
+        status.retweeted_status = retweeted_tweet
+    # Adds user ID to here so we can reference it later.
+    # Sometimes, the conversations buffer would send an already reduced tweet here so we will need to return it as is.
+    if isinstance(tweet.user, str) == False:
+        status.user = tweet.user.id_str
+    else:
+        return tweet
+    return status

src/sessions/twitter/session.py

@@ -8,14 +8,17 @@ import wx
 import config
 import output
 import application
+import appkeys
 from pubsub import pub
 import tweepy
-from tweepy.error import TweepError
+from tweepy.errors import TweepyException, Forbidden, NotFound
+from tweepy.models import User as UserModel
 from mysc.thread_utils import call_threaded
 from keys import keyring
 from sessions import base
 from sessions.twitter import utils, compose
 from sessions.twitter.long_tweets import tweets, twishort
+from . import reduce, streaming
 from .wxUI import authorisationDialog
 
 log = logging.getLogger("sessions.twitterSession")
@@ -37,26 +40,27 @@ class Session(base.baseSession):
             self.db[name] = []
         if ("users" in self.db) == False:
             self.db["users"] = {}
+        objects = self.db[name]
         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
+        self.add_users_from_results(data)
         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 utils.find_item(i, self.db[name]) == None and     utils.is_allowed(i, self.settings, name) == True:
                 if i == False: continue
-    if self.settings["general"]["reverse_timelines"] == False: self.db[name].append(i)
-    else: self.db[name].insert(0, i)
+                reduced_object = reduce.reduce_tweet(i)
+                reduced_object = self.check_quoted_status(reduced_object)
+                reduced_object = self.check_long_tweet(reduced_object)
+                if self.settings["general"]["reverse_timelines"] == False: objects.append(reduced_object)
+                else: objects.insert(0, reduced_object)
                 num = num+1
-    if hasattr(i, "user"):
-     if (i.user.id in self.db["users"]) == False:
-      self.db["users"][i.user.id] = i.user
+        self.db[name] = objects
         return num
 
     def order_people(self, name, data):
@@ -67,11 +71,13 @@ class Session(base.baseSession):
         num = 0
         if (name in self.db) == False:
             self.db[name] = []
+        objects = self.db[name]
         for i in data:
-   if utils.find_item(i.id, self.db[name]) == None:
-    if self.settings["general"]["reverse_timelines"] == False: self.db[name].append(i)
-    else: self.db[name].insert(0, i)
+            if utils.find_item(i, self.db[name]) == None:
+                if self.settings["general"]["reverse_timelines"] == False: objects.append(i)
+                else: objects.insert(0, i)
                 num = num+1
+        self.db[name] = objects
         return num
 
     def order_direct_messages(self, data):
@@ -82,19 +88,27 @@ class Session(base.baseSession):
         sent = 0
         if ("direct_messages" in self.db) == False:
             self.db["direct_messages"] = []
+        if ("sent_direct_messages" in self.db) == False:
+            self.db["sent_direct_messages"] = []
+        objects = self.db["direct_messages"]
+        sent_objects = self.db["sent_direct_messages"]
         for i in data:
             # Twitter returns sender_id as str, which must be converted to int in order to match to our user_id object.
             if int(i.message_create["sender_id"]) == self.db["user_id"]:
-    if "sent_direct_messages" in self.db and utils.find_item(i.id, self.db["sent_direct_messages"]) == None:
-     if self.settings["general"]["reverse_timelines"] == False: self.db["sent_direct_messages"].append(i)
-     else: self.db["sent_direct_messages"].insert(0, i)
+                if "sent_direct_messages" in self.db and utils.find_item(i, self.db["sent_direct_messages"]) == None:
+                    if self.settings["general"]["reverse_timelines"] == False: sent_objects.append(i)
+                    else: sent_objects.insert(0, i)
                     sent = sent+1
             else:
-    if utils.find_item(i.id, self.db["direct_messages"]) == None:
-     if self.settings["general"]["reverse_timelines"] == False: self.db["direct_messages"].append(i)
-     else: self.db["direct_messages"].insert(0, i)
+                if utils.find_item(i, self.db["direct_messages"]) == None:
+                    if self.settings["general"]["reverse_timelines"] == False: objects.append(i)
+                    else: objects.insert(0, i)
                     incoming = incoming+1
+        self.db["direct_messages"] = objects
+
+        self.db["sent_direct_messages"] = sent_objects
         pub.sendMessage("sent-dms-updated", total=sent, account=self.db["user_name"])
+
         return incoming
 
     def __init__(self, *args, **kwargs):
@@ -105,6 +119,15 @@ class Session(base.baseSession):
         self.reconnection_function_active = False
         self.counter = 0
         self.lists = []
+        # As users are cached for accessing them with not too many twitter calls,
+        # there could be a weird situation where a deleted user who sent direct messages to the current account will not be able to be retrieved at twitter.
+        # So we need to store an "user deleted" object in the cache, but have the ID of the deleted user in a local reference.
+        # This will be especially useful because if the user reactivates their account later, TWblue will try to retrieve such user again at startup.
+        # If we wouldn't implement this approach, TWBlue would save permanently the "deleted user" object.
+        self.deleted_users = {}
+        self.type = "twitter"
+        pub.subscribe(self.handle_new_status, "newStatus")
+        pub.subscribe(self.handle_connected, "streamConnected")
 
 # @_require_configuration
     def login(self, verify_credentials=True):
@@ -113,9 +136,10 @@ class Session(base.baseSession):
         if self.settings["twitter"]["user_key"] != None and self.settings["twitter"]["user_secret"] != None:
             try:
                 log.debug("Logging in to twitter...")
-    self.auth = tweepy.OAuthHandler(keyring.get("api_key"), keyring.get("api_secret"))
+                self.auth = tweepy.OAuthHandler(appkeys.twitter_api_key, appkeys.twitter_api_secret)
                 self.auth.set_access_token(self.settings["twitter"]["user_key"], self.settings["twitter"]["user_secret"])
                 self.twitter = tweepy.API(self.auth)
+                self.twitter_v2 = tweepy.Client(consumer_key=appkeys.twitter_api_key, consumer_secret=appkeys.twitter_api_secret, access_token=self.settings["twitter"]["user_key"], access_token_secret=self.settings["twitter"]["user_secret"])
                 if verify_credentials == True:
                     self.credentials = self.twitter.verify_credentials()
                 self.logged = True
@@ -134,7 +158,7 @@ class Session(base.baseSession):
         if self.logged == True:
             raise Exceptions.AlreadyAuthorisedError("The authorisation process is not needed at this time.")
         else:
-   self.auth = tweepy.OAuthHandler(keyring.get("api_key"), keyring.get("api_secret"))
+            self.auth = tweepy.OAuthHandler(appkeys.twitter_api_key, appkeys.twitter_api_secret)
             redirect_url = self.auth.get_authorization_url()
             webbrowser.open_new_tab(redirect_url)
             self.authorisation_dialog = authorisationDialog()
@@ -160,35 +184,6 @@ class Session(base.baseSession):
         self.verify_authorisation(pincode)
         self.authorisation_dialog.Destroy()
 
- def get_more_items(self, update_function, users=False, dm=False, name=None, *args, **kwargs):
-  """ Get more items for twitter objects.
-  update_function str: function to call for getting more items. Must be member of self.twitter.
-  users, dm bool: If any of these is set to True, the function will treat items as users or dm (they need different handling).
-  name str: name of the database item to put new element in."""
-  results = []
-  if "cursor" in kwargs and kwargs["cursor"] == 0:
-   output.speak(_(u"There are no more items to retrieve in this buffer."))
-   return
-  data = getattr(self.twitter, update_function)(*args, **kwargs)
-  if users == True:
-   if type(data) == dict and "next_cursor" in data:
-    if "next_cursor" in data: # There are more objects to retrieve.
-     self.db[name]["cursor"] = data["next_cursor"]
-    else: # Set cursor to 0, wich means no more items available.
-     self.db[name]["cursor"] = 0
-    for i in data["users"]: results.append(i)
-   elif type(data) == list:
-    results.extend(data[1:])
-  elif dm == True:
-   if "next_cursor" in data: # There are more objects to retrieve.
-    self.db[name]["cursor"] = data["next_cursor"]
-   else: # Set cursor to 0, wich means no more items available.
-    self.db[name]["cursor"] = 0
-   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.
@@ -206,14 +201,14 @@ class Session(base.baseSession):
             try:
                 val = getattr(self.twitter, call_name)(*args, **kwargs)
                 finished = True
-   except TweepError as e:
-    output.speak(e.reason)
+            except TweepyException as e:
+                output.speak(str(e))
                 val = None
-    if e.error_code != 403 and e.error_code != 404:
+                if type(e) != NotFound and type(e) != Forvidden:
                     tries = tries+1
                     time.sleep(5)
-    elif report_failure and hasattr(e, 'reason'):
-     output.speak(_("%s failed.  Reason: %s") % (action, e.reason))
+                elif report_failure:
+                    output.speak(_("%s failed.  Reason: %s") % (action, str(e)))
                 finished = True
 #   except:
 #    tries = tries + 1
@@ -225,7 +220,7 @@ class Session(base.baseSession):
 
     def search(self, name, *args, **kwargs):
         """ Search in twitter, passing args and kwargs as arguments to the Twython function."""
-  tl = self.twitter.search(*args, **kwargs)
+        tl = self.twitter.search_tweets(*args, **kwargs)
         tl.reverse()
         return tl
 
@@ -278,12 +273,12 @@ class Session(base.baseSession):
 # @_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.lists_all(reverse=True)
+        self.db["lists"] = self.twitter.get_lists(reverse=True)
 
 # @_require_login
     def get_muted_users(self):
         """ Gets muted users (oh really?)."""
-  self.db["muted_users"] = self.twitter.mutes_ids()
+        self.db["muted_users"] = self.twitter.get_muted_ids()
 
 # @_require_login
     def get_stream(self, name, function, *args, **kwargs):
@@ -358,10 +353,11 @@ class Session(base.baseSession):
             value = "full_text"
         else:
             value = "text"
+        if hasattr(quoted_tweet, "entities"):
             setattr(quoted_tweet, value, utils.expand_urls(getattr(quoted_tweet, value), quoted_tweet.entities))
-  if quoted_tweet.is_quote_status == True and hasattr(quoted_tweet, "quoted_status"):
+        if hasattr(quoted_tweet, "is_quote_status") == True and hasattr(quoted_tweet, "quoted_status"):
             original_tweet = quoted_tweet.quoted_status
-  elif hasattr(quoted_tweet, "retweeted_status") and quoted_tweet.retweeted_status.is_quote_status == True and hasattr(quoted_tweet.retweeted_status, "quoted_status"):
+        elif hasattr(quoted_tweet, "retweeted_status") and hasattr(quoted_tweet.retweeted_status, "is_quote_status") == True and hasattr(quoted_tweet.retweeted_status, "quoted_status"):
             original_tweet = quoted_tweet.retweeted_status.quoted_status
         else:
             return quoted_tweet
@@ -372,13 +368,17 @@ class Session(base.baseSession):
             value = "message"
         else:
             value = "text"
+        if hasattr(original_tweet, "entities"):
             setattr(original_tweet, value, utils.expand_urls(getattr(original_tweet, value), original_tweet.entities))
-  return compose.compose_quoted_tweet(quoted_tweet, original_tweet)
+        # ToDo: Shall we check whether we should add show_screen_names here?
+        return compose.compose_quoted_tweet(quoted_tweet, original_tweet, session=self)
 
     def check_long_tweet(self, tweet):
         """ Process a tweet and add extra info if it's a long tweet made with Twyshort.
         tweet dict: a tweet object.
         returns a tweet with a new argument message, or original tweet if it's not a long tweet."""
+        long = False
+        if hasattr(tweet, "entities") and tweet.entities.get("urls"):
             long = twishort.is_long(tweet)
         if long != False and config.app["app-settings"]["handle_longtweets"]:
             message = twishort.get_full_text(long)
@@ -386,35 +386,72 @@ class Session(base.baseSession):
                 tweet.quoted_status.message = message
                 if tweet.quoted_status.message == False: return False
                 tweet.quoted_status.twishort = True
+                if hasattr(tweet.quoted_status, "entities") and tweet.quoted_status.entities.get("user_mentions"):
                     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 hasattr(tweet.quoted_status, "retweeted_status")  and tweet.retweeted_status.user.screen_name == i["screen_name"]:
+                        if "@%s" % (i["screen_name"]) not in tweet.quoted_status.message and i["screen_name"] != self.get_user(tweet.user).screen_name:
+                            if hasattr(tweet.quoted_status, "retweeted_status")  and self.get_user(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
+                if hasattr(tweet, "entities") and tweet.entities.get("user_mentions"):
                     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 hasattr(tweet, "retweeted_status") and tweet.retweeted_status.user.screen_name == i["screen_name"]:
+                        if "@%s" % (i["screen_name"]) not in tweet.message and i["screen_name"] != self.get_user(tweet.user).screen_name:
+                            if hasattr(tweet, "retweeted_status") and self.get_user(tweet.retweeted_status.user).screen_name == i["screen_name"]:
                                 continue
+                            tweet.message = u"@%s %s" % (i["screen_name"], tweet.message)
         return tweet
 
     def get_user(self, id):
         """ Returns an user object associated with an ID.
         id str: User identifier, provided by Twitter.
-  returns an user dict."""
-  if ("users" in self.db) == False or (id in self.db["users"]) == False:
+        returns a tweepy user object."""
+        if hasattr(id, "id_str"):
+            log.error("Called get_user function by passing a full user id as a parameter.")
+            id = id.id_str
+        # Check if the user has been added to the list of deleted users previously.
+        if id in self.deleted_users:
+            log.debug("Returning user {} from the list of deleted users.".format(id))
+            return self.deleted_users[id]
+        if ("users" in self.db) == False or (str(id) in self.db["users"]) == False:
+            log.debug("Requesting user id {} as it is not present in the users database.".format(id))
             try:
                 user = self.twitter.get_user(id=id)
-   except TweepError as err:
-    user = dict(screen_name="deleted_account", name="Deleted account")
-    return user
-   self.db["users"][user.id_str] = user
+            except TweepyException as err:
+                user = UserModel(None)
+                user.screen_name = "deleted_user"
+                user.id = id
+                user.name = _("Deleted account")
+                if type(err) == NotFound:
+                    self.deleted_users[id] = user
                     return user
                 else:
-   return self.db["users"][id]
+                    log.exception("Error when attempting to retrieve an user from Twitter.")
+                    return user
+            users = self.db["users"]
+            users[user.id_str] = user
+            self.db["users"] = users
+            user.name = self.get_user_alias(user)
+            return user
+        else:
+            user = self.db["users"][str(id)]
+            user.name = self.get_user_alias(user)
+            return user
+
+    def get_user_alias(self, user):
+        """ Retrieves an alias for the passed user model, if exists.
+        @ user Tweepy.models.user: An user object.
+        """
+        aliases = self.settings.get("user-aliases")
+        if aliases == None:
+            log.error("Aliases are not defined for this config spec.")
+            return user.name
+        user_alias = aliases.get(user.id_str)
+        if user_alias != None:
+            return user_alias
+        return user.name
 
     def get_user_by_screen_name(self, screen_name):
         """ Returns an user identifier associated with a screen_name.
@@ -422,28 +459,135 @@ class Session(base.baseSession):
         returns an user ID."""
         if ("users" in self.db) == False:
             user = utils.if_user_exists(self.twitter, screen_name)
-   self.db["users"][user["id_str"]] = user
-   return user["id_str"]
+            users = self.db["users"]
+            users[user["id"]] = user
+            self.db["users"] = users
+            return user["id"]
         else:
             for i in list(self.db["users"].keys()):
                 if self.db["users"][i].screen_name == screen_name:
-     return self.db["users"][i].id_str
+                    return self.db["users"][i].id
             user = utils.if_user_exists(self.twitter, screen_name)
-   self.db["users"][user.id_str] = user
-   return user.id_str
+            users = self.db["users"]
+            users[user.id] = user
+            self.db["users"] = users
+            return user.id
 
     def save_users(self, user_ids):
         """ Adds all new users to the users database. """
         if len(user_ids) == 0:
             return
         log.debug("Received %d user IDS to be added in the database." % (len(user_ids)))
-  users_to_retrieve = [user_id for user_id in user_ids if user_id not in self.db["users"]]
+        users_to_retrieve = [user_id for user_id in user_ids if (user_id not in self.db["users"] and user_id not in self.deleted_users)]
         # Remove duplicates
         users_to_retrieve = list(dict.fromkeys(users_to_retrieve))
         if len(users_to_retrieve) == 0:
             return
         log.debug("TWBlue will get %d new users from Twitter." % (len(users_to_retrieve)))
-  users = self.twitter.lookup_users(user_ids=users_to_retrieve, tweet_mode="extended")
+        try:
+            users = self.twitter.lookup_users(user_id=users_to_retrieve, tweet_mode="extended")
+            users_db = self.db["users"]
             for user in users:
-   self.db["users"][user.id_str] = user
+                users_db[user.id_str] = user
             log.debug("Added %d new users" % (len(users)))
+            self.db["users"] = users_db
+        except TweepyException as err:
+            if type(err) == NotFound: # User not found.
+                log.error("The specified users {} were not found in twitter.".format(user_ids))
+                # Creates a deleted user object for every user_id not found here.
+                # This will make TWBlue to not waste Twitter API calls when attempting to retrieve those users again.
+                # As deleted_users is not saved across restarts, when restarting TWBlue, it will retrieve the correct users if they enabled their accounts.
+                for id in users_to_retrieve:
+                    user = UserModel(None)
+                    user.screen_name = "deleted_user"
+                    user.id = id
+                    user.name = _("Deleted account")
+                    self.deleted_users[id] = user
+            else:
+                log.exception("An exception happened while attempting to retrieve a list of users from direct messages in Twitter.")
+
+    def add_users_from_results(self, data):
+        users = self.db["users"]
+        for i in data:
+            if hasattr(i, "user"):
+                if isinstance(i.user, str):
+                    log.warning("A String was passed to be added as an user. This is normal only if TWBlue tried to load a conversation.")
+                    continue
+                if (i.user.id_str in self.db["users"]) == False:
+                    users[i.user.id_str] = i.user
+                if hasattr(i, "quoted_status") and (i.quoted_status.user.id_str in self.db["users"]) == False:
+                    users[i.quoted_status.user.id_str] = i.quoted_status.user
+
+                if hasattr(i, "retweeted_status") and (i.retweeted_status.user.id_str in self.db["users"]) == False:
+                    users[i.retweeted_status.user.id_str] = i.retweeted_status.user
+        self.db["users"] = users
+
+    def start_streaming(self):
+        if config.app["app-settings"]["no_streaming"]:
+            return
+        self.stream = streaming.Stream(twitter_api=self.twitter, user=self.db["user_name"], user_id=self.db["user_id"], muted_users=self.db["muted_users"], consumer_key=appkeys.twitter_api_key, consumer_secret=appkeys.twitter_api_secret, access_token=self.settings["twitter"]["user_key"], access_token_secret=self.settings["twitter"]["user_secret"], chunk_size=1025)
+        self.stream_thread = call_threaded(self.stream.filter, follow=self.stream.users, stall_warnings=True)
+
+    def stop_streaming(self):
+        if config.app["app-settings"]["no_streaming"]:
+            return
+        if hasattr(self, "stream"):
+            self.stream.running = False
+            log.debug("Stream stopped for accounr {}".format(self.db["user_name"]))
+
+    def handle_new_status(self, status, user):
+        """ Handles a new status present in the Streaming API. """
+        if self.logged == False:
+            return
+        # Discard processing the status if the streaming sends a tweet for another account.
+        if self.db["user_name"] != user:
+            return
+        # the Streaming API sends non-extended tweets with an optional parameter "extended_tweets" which contains full_text and other data.
+        # so we have to make sure we check it before processing the normal status.
+        # As usual, we handle also quotes and retweets at first.
+        if hasattr(status, "retweeted_status") and hasattr(status.retweeted_status, "extended_tweet"):
+            status.retweeted_status._json = {**status.retweeted_status._json, **status.retweeted_status._json["extended_tweet"]}
+            # compose.compose_tweet requires the parent tweet to have a full_text field, so we have to add it to retweets here.
+            status._json["full_text"] = status._json["text"]
+        if hasattr(status, "quoted_status") and hasattr(status.quoted_status, "extended_tweet"):
+            status.quoted_status._json = {**status.quoted_status._json, **status.quoted_status._json["extended_tweet"]}
+        if status.truncated:
+            status._json = {**status._json, **status._json["extended_tweet"]}
+        # Sends status to database, where it will be reduced and changed according to our needs.
+        buffers_to_send = []
+        if status.user.id_str in self.stream.users:
+            buffers_to_send.append("home_timeline")
+        if status.user.id == self.db["user_id"]:
+            buffers_to_send.append("sent_tweets")
+        for user in status.entities["user_mentions"]:
+            if user["id"] == self.db["user_id"]:
+                buffers_to_send.append("mentions")
+        users_with_timeline = [user.split("-")[0] for user in self.db.keys() if user.endswith("-timeline")]
+        for user in users_with_timeline:
+            if status.user.id_str == user:
+                buffers_to_send.append("{}-timeline".format(user))
+        for buffer in buffers_to_send[::]:
+            num = self.order_buffer(buffer, [status])
+            if num == 0:
+                buffers_to_send.remove(buffer)
+        # However, we have to do the "reduce and change" process here because the status we sent to the db is going to be a different object that the one sent to database.
+        status = reduce.reduce_tweet(status)
+        status = self.check_quoted_status(status)
+        status = self.check_long_tweet(status)
+        # Send it to the main controller object.
+        pub.sendMessage("newTweet", data=status, user=self.db["user_name"], _buffers=buffers_to_send)
+
+    def check_streams(self):
+        if config.app["app-settings"]["no_streaming"]:
+            return
+        if not hasattr(self, "stream"):
+            return
+        log.debug("Status of running stream for user {}: {}".format(self.db["user_name"], self.stream.running))
+        if self.stream.running == False:
+            self.start_streaming()
+
+    def handle_connected(self, user):
+        if self.logged == False:
+            return
+        if user != self.db["user_name"]:
+            log.debug("Connected streaming endpoint on account {}".format(user))

src/sessions/twitter/streaming.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+""" Streaming support for TWBlue. """
+import time
+import sys
+import six
+import requests
+import urllib3
+import ssl
+import tweepy
+import logging
+from pubsub import pub
+
+log = logging.getLogger("sessions.twitter.streaming")
+
+class Stream(tweepy.Stream):
+
+    def __init__(self, twitter_api, user, user_id, muted_users=[], *args, **kwargs):
+        super(Stream, self).__init__(*args, **kwargs)
+        log.debug("Starting streaming listener for account {}".format(user))
+        self.started = False
+        self.users = []
+        self.api = twitter_api
+        self.user = user
+        self.user_id = user_id
+        friends = self.api.get_friend_ids()
+        log.debug("Retrieved {} friends to add to the streaming listener.".format(len(friends)))
+        self.users.append(str(self.user_id))
+        log.debug("Got {} muted users.".format(len(muted_users)))
+        for user in friends:
+            if user not in muted_users:
+                self.users.append(str(user))
+        self.started = True
+        log.debug("Streaming listener started with {} users to follow.".format(len(self.users)))
+
+    def on_connect(self):
+        pub.sendMessage("streamConnected", user=self.user)
+
+    def on_exception(self, ex):
+        log.exception("Exception received on streaming endpoint for user {}".format(self.user))
+
+    def on_status(self, status):
+        """ Checks data arriving as a tweet. """
+        # Hide replies to users not followed by current account.
+        if status.in_reply_to_user_id_str != None and status.in_reply_to_user_id_str not in self.users and status.user.screen_name != self.user:
+            return
+        if status.user.id_str in self.users:
+            pub.sendMessage("newStatus", status=status, user=self.user)

src/sessions/twitter/utils.py

@@ -6,7 +6,7 @@ import logging
 import requests
 import time
 import sound
-from tweepy.error import TweepError
+from tweepy.errors import TweepyException, NotFound, Forbidden
 log = logging.getLogger("twitter.utils")
 """ Some utilities for the twitter interface."""
 
@@ -21,28 +21,29 @@ bad_chars = '\'\\\n.,[](){}:;"'
 def find_urls_in_text(text):
     return  url_re2.findall(text)
 
-def find_urls (tweet):
+def find_urls (tweet, twitter_media=False):
     urls = []
+    if twitter_media and hasattr(tweet, "extended_entities"):
+        for mediaItem in tweet.extended_entities["media"]:
+            if mediaItem["type"] == "video":
+                for variant in mediaItem["video_info"]["variants"]:
+                    if variant["content_type"] == "video/mp4":
+                        urls.append(variant["url"])
+                        break
     # Let's add URLS from tweet entities.
     if hasattr(tweet, "message_create"):
         entities = tweet.message_create["message_data"]["entities"]
     else:
+        if hasattr(tweet, "entities") == True:
             entities = tweet.entities
+    if entities.get("urls") != None:
         for i in entities["urls"]:
             if i["expanded_url"] not in urls:
                 urls.append(i["expanded_url"])
     if hasattr(tweet, "quoted_status"):
-  for i in tweet.quoted_status.entities["urls"]:
-   if i["expanded_url"] not in urls:
-    urls.append(i["expanded_url"])
+        urls.extend(find_urls(tweet.quoted_status, twitter_media))
     if hasattr(tweet, "retweeted_status"):
-  for i in tweet.retweeted_status.entities["urls"]:
-   if i["expanded_url"] not in urls:
-    urls.append(i["expanded_url"])
-  if hasattr(tweet["retweeted_status"], "quoted_status"):
-   for i in tweet.retweeted_status.quoted_status.entities["urls"]:
-    if i["expanded_url"] not in urls:
-     urls.append(i["expanded_url"])
+        urls.extend(find_urls(tweet.retweeted_status, twitter_media))
     if hasattr(tweet, "message"):
         i = "message"
     elif hasattr(tweet, "full_text"):
@@ -59,9 +60,13 @@ def find_urls (tweet):
             urls.append(i)
     return urls
 
-def find_item(id, listItem):
- for i in range(0, len(listItem)):
-  if listItem[i].id == id: return i
+def find_item(item, listItems):
+    for i in range(0, len(listItems)):
+        if listItems[i].id == item.id:
+            return i
+        # Check also retweets.
+        if hasattr(item, "retweeted_status") and item.retweeted_status.id == listItems[i].id:
+            return i
     return None
 
 def find_list(name, lists):
@@ -69,19 +74,33 @@ def find_list(name, lists):
         if lists[i].name == name:  return lists[i].id
 
 def is_audio(tweet):
+    if hasattr(tweet, "quoted_status") and hasattr(tweet.quoted_status, "extended_entities"):
+        result = is_audio(tweet.quoted_status)
+        if result != None:
+            return result
+    if hasattr(tweet, "retweeted_status") and hasattr(tweet.retweeted_status, "extended_entities"):
+        result = is_audio(tweet.retweeted_status)
+        if result == True:
+            return result
+    # Checks firstly for Twitter videos and audios.
+    if hasattr(tweet, "extended_entities"):
+        for mediaItem in tweet.extended_entities["media"]:
+            if mediaItem["type"] == "video":
+                return True
     try:
         if len(find_urls(tweet)) < 1:
             return False
         if hasattr(tweet, "message_create"):
             entities = tweet.message_create["message_data"]["entities"]
         else:
+            if hasattr(tweet, "entities") == False or tweet.entities.get("hashtags") == None:
+                return False
             entities = tweet.entities
         if len(entities["hashtags"]) > 0:
             for i in entities["hashtags"]:
                 if i["text"] == "audio":
                     return True
     except IndexError:
-  print(tweet.entities["hashtags"])
         log.exception("Exception while executing is_audio hashtag algorithm")
 
 def is_geocoded(tweet):
@@ -92,6 +111,8 @@ def is_media(tweet):
     if hasattr(tweet, "message_create"):
         entities = tweet.message_create["message_data"]["entities"]
     else:
+        if hasattr(tweet, "entities") == False or tweet.entities.get("hashtags") == None:
+            return False
         entities = tweet.entities
     if entities.get("media") == None:
         return False
@@ -103,36 +124,43 @@ def is_media(tweet):
 def get_all_mentioned(tweet, conf, field="screen_name"):
     """ Gets all users that have been mentioned."""
     results = []
+    if hasattr(tweet, "retweeted_status"):
+        results.extend(get_all_mentioned(tweet.retweeted_status, conf, field))
+    if hasattr(tweet, "quoted_status"):
+        results.extend(get_all_mentioned(tweet.quoted_status, conf, field))
+    if hasattr(tweet, "entities") and tweet.entities.get("user_mentions"):
         for i in tweet.entities["user_mentions"]:
-  if i["screen_name"] != conf["user_name"] and i["screen_name"] != tweet.user.screen_name:
+            if i["screen_name"] != conf["user_name"] and i["id_str"] != tweet.user:
                 if i.get(field) not in results:
                     results.append(i.get(field))
     return results
 
-def get_all_users(tweet, conf):
+def get_all_users(tweet, session):
     string = []
+    user = session.get_user(tweet.user)
+    if user.screen_name != session.db["user_name"]:
+        string.append(user.screen_name)
     if hasattr(tweet, "retweeted_status"):
-  string.append(tweet.user.screen_name)
-  tweet = tweet.retweeted_status
- if hasattr(tweet, "sender"):
-  string.append(tweet.sender.screen_name)
- else:
-  if tweet.user.screen_name != conf["user_name"]:
-   string.append(tweet.user.screen_name)
+        string.extend(get_all_users(tweet.retweeted_status, session))
+    if hasattr(tweet, "quoted_status"):
+        string.extend(get_all_users(tweet.quoted_status, session))
+    if hasattr(tweet, "entities") and tweet.entities.get("user_mentions"):
         for i in tweet.entities["user_mentions"]:
-   if i["screen_name"] != conf["user_name"] and i["screen_name"] != tweet.user.screen_name:
+            if i["screen_name"] != session.db["user_name"] and i["screen_name"] != user.screen_name:
                 if i["screen_name"] not in string:
                     string.append(i["screen_name"])
+    # Attempt to remove duplicates, tipically caused by nested tweets.
+    string = list(dict.fromkeys(string))
     if len(string) == 0:
-  string.append(tweet.user.screen_name)
+        string.append(user.screen_name)
     return string
 
 def if_user_exists(twitter, user):
     try:
         data = twitter.get_user(screen_name=user)
         return data
- except TweepError as err:
-  if err.api_code == 50:
+    except TweepyException as err:
+        if type(err) == NotFound:
             return None
         else:
             return user
@@ -144,7 +172,7 @@ def is_allowed(tweet, settings, buffer_name):
     tweet_data = {}
     if hasattr(tweet, "retweeted_status"):
         tweet_data["retweet"] = True
- if tweet.in_reply_to_status_id_str != None:
+    if hasattr(tweet, "in_reply_to_status_id"):
         tweet_data["reply"] = True
     if hasattr(tweet, "quoted_status"):
         tweet_data["quote"] = True
@@ -199,18 +227,37 @@ def filter_tweet(tweet, tweet_data, settings, buffer_name):
     return True
 
 def twitter_error(error):
- if error.api_code == 179:
+    if type(error) == Forbidden:
         msg = _(u"Sorry, you are not authorised to see this status.")
- elif error.api_code == 144:
+    elif type(error) == NotFound:
         msg = _(u"No status found with that ID")
     else:
-  msg = _(u"Error code {0}").format(error.api_code,)
+        msg = _(u"Error {0}").format(str(error),)
     output.speak(msg)
 
 def expand_urls(text, entities):
     """ Expand all URLS present in text with information found in entities"""
+    if entities.get("urls") == None:
+        return text
     urls = find_urls_in_text(text)
     for url in entities["urls"]:
         if url["url"] in text:
             text = text.replace(url["url"], url["expanded_url"])
     return text
+
+def clean_mentions(text):
+    new_text = text
+    mentionned_people = [u for u in re.finditer("(?<=^|(?<=[^a-zA-Z0-9-\.]))@([A-Za-z0-9_]+)", text)]
+    if len(mentionned_people) <= 2:
+        return text
+    end = -2
+    total_users = 0
+    for user in mentionned_people:
+        if abs(user.start()-end) < 3:
+            new_text = new_text.replace(user.group(0), "", 1)
+            total_users = total_users+1
+            end = user.end()
+    if total_users-2 < 1:
+        return text
+    new_text = _("{user_1}, {user_2} and {all_users} more: {text}").format(user_1=mentionned_people[0].group(0), user_2=mentionned_people[1].group(0), all_users=total_users-2, text=new_text)
+    return new_text

src/setup.py

@@ -3,7 +3,7 @@ import sys
 import application
 import platform
 import os
-from cx_Freeze import setup, Executable
+from cx_Freeze import setup, Executable, winmsvcr
 from requests import certs
 
 def get_architecture_files():
@@ -40,16 +40,19 @@ build_exe_options = dict(
     build_exe="dist",
     optimize=1,
     includes=["enchant.tokenize.en"], # This is not handled automatically by cx_freeze.
-	include_msvcr=True,
+    include_msvcr=False,
     replace_paths = [("*", "")],
     include_files=["icon.ico", "conf.defaults", "app-configuration.defaults", "keymaps", "locales", "sounds", "documentation", ("keys/lib", "keys/lib"), find_sound_lib_datafiles(), find_accessible_output2_datafiles()]+get_architecture_files(),
     packages=["wxUI"],
+    bin_path_excludes=["C:\\Program Files", "C:\Program Files (x86)"],
 )
 
 executables = [
-    Executable('main.py', base=base, targetName="twblue")
+    Executable('main.py', base=base, target_name="twblue")
 ]
 
+winmsvcr.FILES = ()
+winmsvcr.FILES_TO_DUPLICATE = ()
 setup(name=application.name,
       version=application.version,
       description=application.description,

src/sound.py

@@ -114,6 +114,8 @@ class URLStream(object):
         # LibVLC controls.
         self.instance = vlc.Instance()
         self.player = self.instance.media_player_new()
+        self.event_manager = self.player.event_manager()
+        self.event_manager.event_attach(vlc.EventType.MediaPlayerEndReached, self.end_callback)
 
     def prepare(self, url):
         """ Takes an URL and prepares it to be streamed. This function will try to unshorten the passed URL and, if needed, to transform it into a valid URL."""
@@ -158,3 +160,9 @@ class URLStream(object):
     def stop_audio(self):
         output.speak(_(u"Stopped."), True)
         self.player.stop()
+
+    def end_callback(self, event, *args, **kwargs):
+        call_threaded(self.player.stop)
+
+    def __del__(self):
+        self.event_manager.event_detach(vlc.EventType.MediaPlayerEndReached)

src/test/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

src/test/test_cache.py

@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+""" Test case to check some of the scenarios we might face when storing tweets in cache, both loading into memory or rreading from disk. """
+import unittest
+import os
+import paths
+import sqlitedict
+import shutil
+# The base session module requires sound as a dependency, and this needs libVLC to be locatable.
+os.environ['PYTHON_VLC_MODULE_PATH']=os.path.abspath(os.path.join(paths.app_path(), "..", "windows-dependencies", "x86"))
+os.environ['PYTHON_VLC_LIB_PATH']=os.path.abspath(os.path.join(paths.app_path(), "..", "windows-dependencies", "x86", "libvlc.dll"))
+from sessions import base
+
+class cacheTestCase(unittest.TestCase):
+
+    def setUp(self):
+        """ Configures a fake session to check caching objects here. """
+        self.session = base.baseSession("testing")
+        if os.path.exists(os.path.join(paths.config_path(), "testing")) == False:
+            os.mkdir(os.path.join(paths.config_path(), "testing"))
+        self.session.get_configuration()
+
+    def tearDown(self):
+        """ Removes the previously configured session. """
+        session_folder = os.path.join(paths.config_path(), "testing")
+        if os.path.exists(session_folder):
+            shutil.rmtree(session_folder)
+
+    def generate_dataset(self):
+        """ Generates a sample dataset"""
+        dataset = dict(home_timeline=["message" for i in range(10000)], mentions_timeline=["mention" for i in range(20000)])
+        return dataset
+
+    ### Testing database being read from disk.
+
+    def test_cache_in_disk_unlimited_size(self):
+        """ Tests cache database being read from disk, storing the whole datasets. """
+        dataset = self.generate_dataset()
+        self.session.settings["general"]["load_cache_in_memory"] = False
+        self.session.settings["general"]["persist_size"] = -1
+        self.session.load_persistent_data()
+        self.session.db["home_timeline"] = dataset["home_timeline"]
+        self.session.db["mentions_timeline"] = dataset["mentions_timeline"]
+        self.session.save_persistent_data()
+        self.assertIsInstance(self.session.db, sqlitedict.SqliteDict)
+        self.assertTrue(self.session.db.get("home_timeline") != None)
+        self.assertTrue(self.session.db.get("mentions_timeline") != None)
+        self.assertEquals(len(self.session.db.get("home_timeline")), 10000)
+        self.assertEquals(len(self.session.db.get("mentions_timeline")), 20000)
+        self.session.db.close()
+
+    def test_cache_in_disk_limited_dataset(self):
+        """ Tests wether the cache stores only the amount of items we ask it to store. """
+        dataset = self.generate_dataset()
+        self.session.settings["general"]["load_cache_in_memory"] = False
+        self.session.settings["general"]["persist_size"] = 100
+        self.session.load_persistent_data()
+        self.session.db["home_timeline"] = dataset["home_timeline"]
+        self.session.db["mentions_timeline"] = dataset["mentions_timeline"]
+        # We need to save and load the db again because we cannot modify buffers' size while the database is opened.
+        # As TWBlue reads directly from db when reading from disk, an attempt to modify buffers size while Blue is reading the db
+        # Might cause an out of sync error between the GUI lists and the database.
+        # So we perform the changes to buffer size when loading data during app startup if the DB is read from disk.
+        self.session.save_persistent_data()
+        self.session.db = dict()
+        self.session.load_persistent_data()
+        self.assertIsInstance(self.session.db, sqlitedict.SqliteDict)
+        self.assertTrue(self.session.db.get("home_timeline") != None)
+        self.assertTrue(self.session.db.get("mentions_timeline") != None)
+        self.assertEquals(len(self.session.db.get("home_timeline")), 100)
+        self.assertEquals(len(self.session.db.get("mentions_timeline")), 100)
+        self.session.db.close()
+
+    def test_cache_in_disk_limited_dataset_unreversed(self):
+        """Test if the cache is saved properly in unreversed buffers, when newest items are at the end of the list. """
+        dataset = dict(home_timeline=[i for i in range(20)], mentions_timeline=[i for i in range(20)])
+        self.session.settings["general"]["load_cache_in_memory"] = False
+        self.session.settings["general"]["persist_size"] = 10
+        self.session.load_persistent_data()
+        self.session.db["home_timeline"] = dataset["home_timeline"]
+        self.session.db["mentions_timeline"] = dataset["mentions_timeline"]
+        # We need to save and load the db again because we cannot modify buffers' size while the database is opened.
+        # As TWBlue reads directly from db when reading from disk, an attempt to modify buffers size while Blue is reading the db
+        # Might cause an out of sync error between the GUI lists and the database.
+        # So we perform the changes to buffer size when loading data during app startup if the DB is read from disk.
+        self.session.save_persistent_data()
+        self.session.db = dict()
+        self.session.load_persistent_data()
+        self.assertIsInstance(self.session.db, sqlitedict.SqliteDict)
+        self.assertTrue(self.session.db.get("home_timeline") != None)
+        self.assertTrue(self.session.db.get("mentions_timeline") != None)
+        self.assertEquals(self.session.db.get("home_timeline")[0], 10)
+        self.assertEquals(self.session.db.get("mentions_timeline")[0], 10)
+        self.assertEquals(self.session.db.get("home_timeline")[-1], 19)
+        self.assertEquals(self.session.db.get("mentions_timeline")[-1], 19)
+        self.session.db.close()
+
+    def test_cache_in_disk_limited_dataset_reversed(self):
+        """Test if the cache is saved properly in reversed buffers, when newest items are at the start of the list. """
+        dataset = dict(home_timeline=[i for i in range(19, -1, -1)], mentions_timeline=[i for i in range(19, -1, -1)])
+        self.session.settings["general"]["load_cache_in_memory"] = False
+        self.session.settings["general"]["persist_size"] = 10
+        self.session.settings["general"]["reverse_timelines"] = True
+        self.session.load_persistent_data()
+        self.session.db["home_timeline"] = dataset["home_timeline"]
+        self.session.db["mentions_timeline"] = dataset["mentions_timeline"]
+        # We need to save and load the db again because we cannot modify buffers' size while the database is opened.
+        # As TWBlue reads directly from db when reading from disk, an attempt to modify buffers size while Blue is reading the db
+        # Might cause an out of sync error between the GUI lists and the database.
+        # So we perform the changes to buffer size when loading data during app startup if the DB is read from disk.
+        self.session.save_persistent_data()
+        self.session.db = dict()
+        self.session.load_persistent_data()
+        self.assertIsInstance(self.session.db, sqlitedict.SqliteDict)
+        self.assertTrue(self.session.db.get("home_timeline") != None)
+        self.assertTrue(self.session.db.get("mentions_timeline") != None)
+        self.assertEquals(self.session.db.get("home_timeline")[0], 19)
+        self.assertEquals(self.session.db.get("mentions_timeline")[0], 19)
+        self.assertEquals(self.session.db.get("home_timeline")[-1], 10)
+        self.assertEquals(self.session.db.get("mentions_timeline")[-1], 10)
+        self.session.db.close()
+
+    ### Testing database being loaded into memory. Those tests should give the same results than before
+    ### but as we have different code depending whether we load db into memory or read it from disk,
+    ### We need to test this anyways.
+    def test_cache_in_memory_unlimited_size(self):
+        """ Tests cache database being loaded in memory, storing the whole datasets. """
+        dataset = self.generate_dataset()
+        self.session.settings["general"]["load_cache_in_memory"] = True
+        self.session.settings["general"]["persist_size"] = -1
+        self.session.load_persistent_data()
+        self.session.db["home_timeline"] = dataset["home_timeline"]
+        self.session.db["mentions_timeline"] = dataset["mentions_timeline"]
+        self.session.save_persistent_data()
+        self.session.db = dict()
+        self.session.load_persistent_data()
+        self.assertIsInstance(self.session.db, dict)
+        self.assertTrue(self.session.db.get("home_timeline") != None)
+        self.assertTrue(self.session.db.get("mentions_timeline") != None)
+        self.assertEquals(len(self.session.db.get("home_timeline")), 10000)
+        self.assertEquals(len(self.session.db.get("mentions_timeline")), 20000)
+
+    def test_cache_in_memory_limited_dataset(self):
+        """ Tests wether the cache stores only the amount of items we ask it to store, when loaded in memory. """
+        dataset = self.generate_dataset()
+        self.session.settings["general"]["load_cache_in_memory"] = True
+        self.session.settings["general"]["persist_size"] = 100
+        self.session.load_persistent_data()
+        self.session.db["home_timeline"] = dataset["home_timeline"]
+        self.session.db["mentions_timeline"] = dataset["mentions_timeline"]
+        self.session.save_persistent_data()
+        self.session.db = dict()
+        self.session.load_persistent_data()
+        self.assertIsInstance(self.session.db, dict)
+        self.assertTrue(self.session.db.get("home_timeline") != None)
+        self.assertTrue(self.session.db.get("mentions_timeline") != None)
+        self.assertEquals(len(self.session.db.get("home_timeline")), 100)
+        self.assertEquals(len(self.session.db.get("mentions_timeline")), 100)
+
+    def test_cache_in_memory_limited_dataset_unreversed(self):
+        """Test if the cache is saved properly when loaded in memory in unreversed buffers, when newest items are at the end of the list. """
+        dataset = dict(home_timeline=[i for i in range(20)], mentions_timeline=[i for i in range(20)])
+        self.session.settings["general"]["load_cache_in_memory"] = True
+        self.session.settings["general"]["persist_size"] = 10
+        self.session.load_persistent_data()
+        self.assertTrue(len(self.session.db)==1)
+        self.session.db["home_timeline"] = dataset["home_timeline"]
+        self.session.db["mentions_timeline"] = dataset["mentions_timeline"]
+        self.session.save_persistent_data()
+        self.session.db = dict()
+        self.session.load_persistent_data()
+        self.assertIsInstance(self.session.db, dict)
+        self.assertTrue(self.session.db.get("home_timeline") != None)
+        self.assertTrue(self.session.db.get("mentions_timeline") != None)
+        self.assertEquals(self.session.db.get("home_timeline")[0], 10)
+        self.assertEquals(self.session.db.get("mentions_timeline")[0], 10)
+        self.assertEquals(self.session.db.get("home_timeline")[-1], 19)
+        self.assertEquals(self.session.db.get("mentions_timeline")[-1], 19)
+
+    def test_cache_in_memory_limited_dataset_reversed(self):
+        """Test if the cache is saved properly in reversed buffers, when newest items are at the start of the list. This test if for db read into memory. """
+        dataset = dict(home_timeline=[i for i in range(19, -1, -1)], mentions_timeline=[i for i in range(19, -1, -1)])
+        self.session.settings["general"]["load_cache_in_memory"] = True
+        self.session.settings["general"]["persist_size"] = 10
+        self.session.settings["general"]["reverse_timelines"] = True
+        self.session.load_persistent_data()
+        self.session.db["home_timeline"] = dataset["home_timeline"]
+        self.session.db["mentions_timeline"] = dataset["mentions_timeline"]
+        self.session.save_persistent_data()
+        self.session.db = dict()
+        self.session.load_persistent_data()
+        self.assertIsInstance(self.session.db, dict)
+        self.assertTrue(self.session.db.get("home_timeline") != None)
+        self.assertTrue(self.session.db.get("mentions_timeline") != None)
+        self.assertEquals(self.session.db.get("home_timeline")[0], 19)
+        self.assertEquals(self.session.db.get("mentions_timeline")[0], 19)
+        self.assertEquals(self.session.db.get("home_timeline")[-1], 10)
+        self.assertEquals(self.session.db.get("mentions_timeline")[-1], 10)
+
+if __name__ == "__main__":
+    unittest.main()

src/update/update.py

@@ -1,4 +1,3 @@
-from __future__ import unicode_literals
 from logging import getLogger
 logger = getLogger('update')
 
@@ -24,8 +23,8 @@ def perform_update(endpoint, current_version, app_name='', password=None, update
     if not available_update:
         logger.debug("No update available")
         return False
- available_version = float(available_update['current_version'])
- if not float(available_version) > float(current_version) or platform.system()+platform.architecture()[0][:2] not in available_update['downloads']:
+    available_version = available_update['current_version']
+    if available_version == current_version or platform.system()+platform.architecture()[0][:2] not in available_update['downloads']:
         logger.debug("No update for this architecture")
         return False
     available_description = available_update.get('description', None)
@@ -42,10 +41,10 @@ def perform_update(endpoint, current_version, app_name='', password=None, update
     downloaded = download_update(update_url, download_path, requests_session=requests_session, progress_callback=progress_callback)
     extracted = extract_update(downloaded, update_path, password=password)
     bootstrap_path = move_bootstrap(extracted)
- execute_bootstrap(bootstrap_path, extracted)
- logger.info("Update prepared for installation.")
     if callable(update_complete_callback):
         update_complete_callback()
+    execute_bootstrap(bootstrap_path, extracted)
+    logger.info("Update prepared for installation.")
 
 def create_requests_session(app_name=None, version=None):
     user_agent = ''

src/update/updater.py

@@ -1,6 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import absolute_import
-from __future__ import unicode_literals
 import application
 from . import update
 import platform

src/write_version_data.py

@@ -0,0 +1,38 @@
+#! /usr/bin/env python# -*- coding: iso-8859-1 -*-
+""" Write version info (taken from the last commit) to application.py. This method has been implemented this way for running updates.
+This file is not intended to be called by the user. It will be used only by the Gitlab CI runner."""
+import os
+import requests
+from codecs import open
+
+print("Writing version data for update...")
+commit_info = requests.get("https://gitlab.com/api/v4/projects/23482196/repository/commits/next-gen")
+commit_info = commit_info.json()
+commit = commit_info["short_id"]
+print("Got new version info: {commit}".format(commit=commit,))
+file = open("application.py", "r", encoding="utf-8")
+lines = file.readlines()
+lines[-1] = 'version = "{}"'.format(commit_info["created_at"][:10].replace("-", "."))
+file.close()
+file2 = open("application.py", "w", encoding="utf-8")
+file2.writelines(lines)
+file2.close()
+print("Wrote application.py with the new version info.")
+
+print("Updating next version on installer setup...")
+file = open("..\\scripts\\twblue.nsi", "r", encoding="utf-8")
+contents = file.read()
+contents = contents.replace("0.95", commit_info["created_at"][:10].replace("-", "."))
+file.close()
+file2 = open("..\\scripts\\twblue.nsi", "w", encoding="utf-8")
+file2.write(contents)
+file2.close()
+print("done")
+print("Writing keys to module...")
+file3 = open("appkeys.py", "w")
+keys = """twitter_api_key = "{}"
+twitter_api_secret = "{}"
+""".format(os.environ.get("TWITTER_API_KEY"), os.environ.get("TWITTER_API_SECRET"))
+file3.write(keys)
+file3.close()
+print("Wrote set of keys for consumer of {}".format(os.environ.get("TWITTER_API_KEY")))

src/wxUI/dialogs/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import absolute_import
 from __future__ import unicode_literals
-from . import baseDialog, trends, configuration, lists, message, search, find, show_user, update_profile, urlList, userSelection, utils, filterDialogs
+from . import baseDialog, trends, configuration, lists, message, search, find, show_user, update_profile, urlList, userSelection, utils, filterDialogs, userAliasDialogs

src/wxUI/dialogs/configuration.py

@@ -1,7 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import absolute_import
-from __future__ import unicode_literals
-from builtins import range
 import logging as original_logger
 import wx
 import application
@@ -127,6 +124,7 @@ class generalAccount(wx.Panel, baseDialog.BaseWXDialog):
         self.persist_size = wx.TextCtrl(self, -1)
         sizer.Add(PersistSizeLabel, 0, wx.ALL, 5)
         sizer.Add(self.persist_size, 0, wx.ALL, 5)
+        self.load_cache_in_memory = wx.CheckBox(self, wx.NewId(), _("Load cache for tweets in memory (much faster in big datasets but requires more RAM)"))
         self.SetSizer(sizer)
 
 class reporting(wx.Panel, baseDialog.BaseWXDialog):

src/wxUI/dialogs/message.py

@@ -1,6 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import unicode_literals
-from builtins import str
 import wx
 import widgetUtils
 
@@ -221,7 +219,7 @@ class dm(textLimited):
 
     def __init__(self, title, message,  users, *args, **kwargs):
         super(dm, self).__init__()
-  self.createControls(message, title, users)
+        self.createControls(title, message, users)
 #  self.onTimer(wx.EVT_CHAR_HOOK)
 #  self.SetClientSize(self.mainBox.CalcMin())
 
@@ -356,6 +354,8 @@ class viewTweet(widgetUtils.BaseDialog):
         infoBox.Add(sourceBox, 0, wx.ALL, 5)
         mainBox.Add(infoBox, 0, wx.ALL, 5)
         mainBox.Add(dateBox, 0, wx.ALL, 5)
+        self.share = wx.Button(panel, wx.ID_ANY, _("Copy link to clipboard"))
+        self.share.Enable(False)
         self.spellcheck = wx.Button(panel, -1, _("Check &spelling..."), size=wx.DefaultSize)
         self.unshortenButton = wx.Button(panel, -1, _(u"&Expand URL"), size=wx.DefaultSize)
         self.unshortenButton.Disable()
@@ -363,6 +363,7 @@ class viewTweet(widgetUtils.BaseDialog):
         cancelButton = wx.Button(panel, wx.ID_CANCEL, _(u"C&lose"), size=wx.DefaultSize)
         cancelButton.SetDefault()
         buttonsBox = wx.BoxSizer(wx.HORIZONTAL)
+        buttonsBox.Add(self.share, 0, wx.ALL, 5)
         buttonsBox.Add(self.spellcheck, 0, wx.ALL, 5)
         buttonsBox.Add(self.unshortenButton, 0, wx.ALL, 5)
         buttonsBox.Add(self.translateButton, 0, wx.ALL, 5)
@@ -429,6 +430,8 @@ class viewNonTweet(widgetUtils.BaseDialog):
             dateBox.Add(dateLabel, 0, wx.ALL, 5)
             dateBox.Add(date, 0, wx.ALL, 5)
             mainBox.Add(dateBox, 0, wx.ALL, 5)
+        self.share = wx.Button(panel, wx.ID_ANY, _("Copy link to clipboard"))
+        self.share.Enable(False)
         self.spellcheck = wx.Button(panel, -1, _("Check &spelling..."), size=wx.DefaultSize)
         self.unshortenButton = wx.Button(panel, -1, _(u"&Expand URL"), size=wx.DefaultSize)
         self.unshortenButton.Disable()
@@ -436,6 +439,7 @@ class viewNonTweet(widgetUtils.BaseDialog):
         cancelButton = wx.Button(panel, wx.ID_CANCEL, _(u"C&lose"), size=wx.DefaultSize)
         cancelButton.SetDefault()
         buttonsBox = wx.BoxSizer(wx.HORIZONTAL)
+        buttonsBox.Add(self.share, 0, wx.ALL, 5)
         buttonsBox.Add(self.spellcheck, 0, wx.ALL, 5)
         buttonsBox.Add(self.unshortenButton, 0, wx.ALL, 5)
         buttonsBox.Add(self.translateButton, 0, wx.ALL, 5)
@@ -463,5 +467,5 @@ class viewNonTweet(widgetUtils.BaseDialog):
         self.text.SetFocus()
 
     def enable_button(self, buttonName):
-  if getattr(self, buttonName):
+        if hasattr(self, buttonName):
             return getattr(self, buttonName).Enable()

src/wxUI/dialogs/userAliasDialogs.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+import wx
+import gettext
+from . import baseDialog
+
+class addAliasDialog(baseDialog.BaseWXDialog):
+    def __init__(self, title, users):
+        super(addAliasDialog, self).__init__(parent=None, id=wx.ID_ANY, title=title)
+        panel = wx.Panel(self)
+        userSizer = wx.BoxSizer()
+        self.cb = wx.ComboBox(panel, -1, choices=users, value=users[0], size=wx.DefaultSize)
+        self.cb.SetFocus()
+        self.autocompletion = wx.Button(panel, -1, _(u"&Autocomplete users"))
+        userSizer.Add(wx.StaticText(panel, -1, _(u"User")), 0, wx.ALL, 5)
+        userSizer.Add(self.cb, 0, wx.ALL, 5)
+        userSizer.Add(self.autocompletion, 0, wx.ALL, 5)
+        aliasSizer = wx.BoxSizer(wx.HORIZONTAL)
+        aliasLabel = wx.StaticText(panel, wx.ID_ANY, _("Alias"))
+        self.alias = wx.TextCtrl(panel, wx.ID_ANY)
+        aliasSizer.Add(aliasLabel, 0, wx.ALL, 5)
+        aliasSizer.Add(self.alias, 0, wx.ALL, 5)
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        ok = wx.Button(panel, wx.ID_OK, _(u"OK"))
+        ok.SetDefault()
+        cancel = wx.Button(panel, wx.ID_CANCEL, _(u"Close"))
+        btnsizer = wx.BoxSizer()
+        btnsizer.Add(ok, 0, wx.ALL, 5)
+        btnsizer.Add(cancel, 0, wx.ALL, 5)
+        sizer.Add(userSizer, 0, wx.ALL, 5)
+        sizer.Add(aliasSizer, 0, wx.ALL, 5)
+        sizer.Add(btnsizer, 0, wx.ALL, 5)
+        panel.SetSizer(sizer)
+        self.SetClientSize(sizer.CalcMin())
+
+    def get_user(self):
+        return (self.cb.GetValue(), self.alias.GetValue())
+
+class userAliasEditorDialog(wx.Dialog):
+    def __init__(self, *args, **kwds):
+        super(userAliasEditorDialog, self).__init__(parent=None)
+        self.SetTitle(_("Edit user aliases"))
+        main_sizer = wx.BoxSizer(wx.VERTICAL)
+        userListSizer = wx.StaticBoxSizer(wx.StaticBox(self, wx.ID_ANY, _("Users")), wx.VERTICAL)
+        main_sizer.Add(userListSizer, 1, wx.EXPAND, 0)
+        self.users = wx.ListBox(self, wx.ID_ANY, choices=[])
+        self.users.Bind(wx.EVT_LISTBOX, self.on_selection_changes)
+        userListSizer.Add(self.users, 0, 0, 0)
+        actionsSizer = wx.StaticBoxSizer(wx.StaticBox(self, wx.ID_ANY, _("Actions")), wx.HORIZONTAL)
+        main_sizer.Add(actionsSizer, 1, wx.EXPAND, 0)
+        self.add = wx.Button(self, wx.ID_ANY, _("Add alias"))
+        self.add.SetToolTip(_("Adds a new user alias"))
+        actionsSizer.Add(self.add, 0, 0, 0)
+        self.edit = wx.Button(self, wx.ID_ANY, _("Edit"))
+        self.edit.SetToolTip(_("Edit the currently focused user Alias."))
+        self.edit.Enable(False)
+        actionsSizer.Add(self.edit, 0, 0, 0)
+        self.remove = wx.Button(self, wx.ID_ANY, _("Remove"))
+        self.remove.SetToolTip(_("Remove the currently focused user alias."))
+        self.remove.Enable(False)
+        actionsSizer.Add(self.remove, 0, 0, 0)
+        btnSizer = wx.StdDialogButtonSizer()
+        main_sizer.Add(btnSizer, 0, wx.ALIGN_RIGHT | wx.ALL, 4)
+        self.button_CLOSE = wx.Button(self, wx.ID_CLOSE, "")
+        btnSizer.AddButton(self.button_CLOSE)
+        btnSizer.Realize()
+        self.SetSizer(main_sizer)
+        main_sizer.Fit(self)
+        self.SetEscapeId(self.button_CLOSE.GetId())
+        self.Layout()
+
+    def on_selection_changes(self, *args, **kwargs):
+        selection = self.users.GetSelection()
+        if selection == -1:
+            self.enable_action_buttons(False)
+        else:
+            self.enable_action_buttons(True)
+
+    def get_selected_user(self):
+        return self.users.GetStringSelection()
+
+    def remove_alias_dialog(self, *args, **kwargs):
+        dlg = wx.MessageDialog(self, _("Are you sure you want to delete this user alias?"), _("Remove user alias"), wx.YES_NO)
+        if dlg.ShowModal() == wx.ID_YES:
+            return True
+        else:
+            return False
+
+    def enable_action_buttons(self, enabled=True):
+        self.edit.Enable(enabled)
+        self.remove.Enable(enabled)
+
+    def edit_alias_dialog(self, title):
+        dlg = wx.TextEntryDialog(self, title, _("User alias"))
+        if dlg.ShowModal() == wx.ID_OK:
+            return dlg.GetValue()

src/wxUI/dialogs/utils.py

@@ -47,4 +47,3 @@ class selectUserDialog(baseDialog.BaseWXDialog):
 
     def get_user(self):
         return self.cb.GetValue()
-

src/wxUI/view.py

@@ -20,6 +20,7 @@ class mainFrame(wx.Frame):
         self.show_hide = app.Append(wx.ID_ANY, _(u"&Hide window"))
         self.menuitem_search = app.Append(wx.ID_ANY, _(u"&Search"))
         self.lists = app.Append(wx.ID_ANY, _(u"&Lists manager"))
+        self.manageAliases = app.Append(wx.ID_ANY, _("Manage user aliases"))
         self.keystroke_editor = app.Append(wx.ID_ANY, _(u"&Edit keystrokes"))
         self.account_settings = app.Append(wx.ID_ANY, _(u"Account se&ttings"))
         self.prefs = app.Append(wx.ID_PREFERENCES, _(u"&Global settings"))
@@ -43,6 +44,7 @@ class mainFrame(wx.Frame):
         self.follow = user.Append(wx.ID_ANY, _(u"&Actions..."))
         self.timeline = user.Append(wx.ID_ANY, _(u"&View timeline..."))
         self.dm = user.Append(wx.ID_ANY, _(u"Direct me&ssage"))
+        self.addAlias = user.Append(wx.ID_ANY, _("Add a&lias"))
         self.addToList = user.Append(wx.ID_ANY, _(u"&Add to list"))
         self.removeFromList = user.Append(wx.ID_ANY, _(u"R&emove from list"))
         self.viewLists = user.Append(wx.ID_ANY, _(u"&View lists"))

updates/snapshots.json

@@ -1,5 +0,0 @@
-{"current_version": "5",
-"description": "Snapshot version.",
-"date": "unknown",
-"downloads":
-{"Windows32": "https://twblue.es/pubs/snapshot.zip"}}

updates/stable.json

@@ -1,6 +0,0 @@
-{"current_version": "0.95",
-"description": "The first version for the new generation of TWBlue.",
-"date": "day_name_abr month day_numb, 2016",
-"downloads":
-{"Windows32": "http://twblue.es/pubs/twblue_ngen_0.80_x86.zip",
-"Windows64": "http://twblue.es/pubs/twblue_ngen_0.80_x64.zip"}}

updates/updates.json

@@ -0,0 +1,7 @@
+{"current_version": "11",
+"description": "Snapshot version.",
+"date": "unknown",
+"downloads":
+{"Windows32": "https://twblue.es/pubs/twblue_snapshot_x86.zip",
+{"Windows64": "https://twblue.es/pubs/twblue_snapshot_x64.zip"
+}