gazouilloire 1.1.0

A command line tool for long-term tweets collection. Gazouilloire combines two methods to collect tweets from the Twitter API ("search" and "filter") in order to maximize the number of collected tweets, and automatically fills the gaps in the collection in case of connexion errors or reboots. It handles various config options such as:

• collecting only during specific time periods
• limiting the collection to some locations
• resolving redirected urls
• downloading only certain types of media contents (only photos and no videos, for example)
• unfolding Twitter conversations

Python >= 3.7 compatible.

Summary

• Installation
• Quick start
• Disk space
• Export the tweets
• Advanced parameters
• Daemon mode
• Reset
• Development
• Troubleshooting
• Publications
• Credits & Licenses

Installation

• Install gazouilloire

  pip install gazouilloire
  

• Install ElasticSearch, version 7.X (you can also use Docker for this)

• Init gazouilloire collection in a specific directory...

  gazou init path/to/collection/directory
  

• ...or in the current directory

  gazou init
  

a config.json file is created. Open it to configure the collection parameters.

Quick start

• Set your Twitter API key and generate the related Access Token

  "twitter": {
      "key": "<Consumer Key (API Key)>xxxxxxxxxxxxxxxxxxxxx",
      "secret": "<Consumer Secret (API Secret)>xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
      "oauth_token": "<Access Token>xxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
      "oauth_secret": "<Access Token Secret>xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
  }
  

• Set your ElasticSearch connection (host & port) within the database section and choose a database name that will host your corpus' index:

  "database": {
      "host": "localhost",
      "port": 9200,
      "db_name": "medialab-tweets"
  }
  

Note that ElasticSearch's databases names must be lowercased and without any space or accented character.

• Write down the list of desired keywords and @users and/or the list of desired url_pieces as json arrays:

  "keywords": [
      "amour",
      "\"mots successifs\"",
      "@medialab_scpo"
  ],
  "url_pieces": [
      "medialab.sciencespo.fr/fr"
  ],
  

  Read below the advanced settings section to setup more filters and options or to get precisions on how to properly write your queries within keywords.

• Start the collection by typing the following command in your terminal:

  gazou run
  

  or, if the config file is located in another directory than the current one:

  gazou run path/to/collection/directory
  

  Read below the daemon section to let gazouilloire run continuously on a server and how to set up automatic restarts.

Disk space

Before starting the collection, you should make sure that you will have enough disk space. It takes about 1GB per million tweets collected (without images and other media contents).

You should also consider starting gazouilloire in multi-index mode if the collection is planed to exceed 100 million tweets, or simply restart your collection in a new folder and a new db_name (i.e. open another ElasticSearch index) if the current collection exceeds 150 million tweets.

As a point of comparison, here is the number of tweets sent during the whole year 2021 containing certain keywords (the values were obtained with the API V2 tweets count endpoint):

Export the tweets in CSV format

• Data is stored in your ElasticSearch, which you can direcly query. But you can also export it easily in CSV format:

  # Export all fields from all tweets:
  gazou export
  

• By default, the export command writes in stdout. You can also use the -o option to write into a file:

  gazou export > my_tweets_file.csv
  # is equivalent to
  gazou export -o my_tweets_file.csv
  

  Although if you interrupt the export and need to resume it to complete in multiple sequences, only the -o option will work with the --resume option.

• Other available options:

  # Get documentation for all options of gazou export (-h or --help)
  gazou export -h
  
  # By default, the export will show a progressbar, which you can disable like this:
  gazou export --quiet
  
  # Export a csv of all tweets between 2 dates or datetimes (--since is inclusive and --until exclusive):
  gazou export --since 2021-03-24 --until 2021-03-25
  # or
  gazou export --since 2021-03-24T12:00:00 --until 2021-03-24T13:00:00
  
  # Export a csv of all tweets having a specific word in their text:
  gazou export medialab
  
  # Export a csv of all tweets having one of many specific words in their text:
  gazou export medialab digitalhumanities datajournalism '#python'
  
  # List all available fields for each tweet:
  gazou export --list-fields
  
  # Export only a selection of fields (-c / --columns or -s / --select the xsv way):
  gazou export -c id,user_screen_name,local_time,links
  # or for example to export only the text of the tweets:
  gazou export --select text
  
  # Exclude tweets collected via conversations or quotes (i.e. which do not match the keywords defined in config.json)
  gazou export --exclude-threads
  
  # Exclude retweets from the export
  gazou export --exclude-retweets
  
  # Export all tweets matching a specific ElasticSearch term query, for instance by user name:
  gazou export "{'user_screen_name': 'medialab_ScPo'}"
  
  # Take a csv file with an "id" column and export only the tweets whose ids are included in this file:
  gazou export --export-tweets-from-file list_of_ids.csv
  
  # You can of course combine all of these options, for instance:
  gazou export medialab --since "2021-03-24" --until "2021-03-25" -c text --exclude-threads --exclude-retweets -o medialab_tweets_210324_no_threads_no_rts.csv
  

Advanced parameters

Many advanced settings can be used to better filter the tweets collected and complete the corpus. They can all be modified within the config.json file.

- keywords

Some advanced filters can be used in combination with the keywords, such as -undesiredkeyword, filter:links, -filter:media, -filter:retweets, etc. See Twitter API's documentation for more details.

When adding a Twitter user as a keyword, such as "@medialab_ScPo", Gazouilloire will query specifically "from:medialab_Scpo OR to:medialab_ScPo OR @medialab_ScPo" so that all tweets mentionning the user will also be collected.

Using upper or lower case characters in keywords won't change anything.

Avoid using accented characters (Twitter will automatically return both tweets with and without accents, for instance searching "heros" will find both tweets with "heros" and "héros").

Regarding hashtags, note that querying a word without the # character will return both tweets with the regular word and tweets with the hashtag. Adding a hashtag with the # characters inside keywords will only collect tweets with the hashtag.

Note that there are three possibilities to filter further:

- language

In order to collect only tweets written in a specific language: just add "language": "fr" to the config (the language should be written in ISO 639-1 code)

- geolocation

Just add "geolocation": "Paris, France" field to the config with the desired geographical boundaries or give in coordinates of the desired box (for instance [48.70908786918211, 2.1533203125, 49.00274483644453, 2.610626220703125])

- time_limited_keywords

In order to filter on specific keywords during planned time periods, for instance:

"time_limited_keywords": {
      "#fosdem": [
          ["2021-01-27 04:30", "2021-01-28 23:30"]
      ]
  }

- url_pieces

To search for specific parts of websites, one can input pieces of urls as keywords in this field. For instance:

"url_pieces": [
    "medialab.sciencespo.fr",
    "github.com/medialab"
]

- resolve_redirected_links

Set to true or false to enable or disable automatic resolution of all links found in tweets (t.co links are always handled, but this allows resolving also for all other shorteners such as bit.ly).

The resolving_delay (set to 30 by default) defines for how many days urls returning errors will be retried before leaving them as such.

- grab_conversations

Set to true to activate automatic recursive retrieval within the corpus of all tweets to which collected tweets are answering (warning: one should account for the presence of these when processing data, it often results in collecting tweets which do not contain the queried keywords and/or which are way out of the collection time period).

- catchup_past_week

Twitter's free API allows to collect tweets up to 7 days in the past, which gazouilloire does by default when starting a new corpus. Set this option to false to disable this and only collect tweets posted after the collection was started.

- download_media

Configure this option to activate automatic downloading within media_directory of photos and/or videos posted by users within the collected tweets (this does not include images from social cards). For instance the following configuration will only collect pictures without videos or gifs:

"download_media": {
    "photo": true,
    "video": false,
    "animated_gif": false,
    "media_directory": "path/to/media/directory"
}

All fields can also be set to true to download everything. media_directory is the folder where Gazouilloire stores the images & videos. It should either be an absolute path ("/home/user/gazouilloire/my_collection/my_images"), or a path relative to the directory where config.json is located ("my_images").

- timezone

Adjust the timezone within which tweets timestamps should be computed. Allowed values are proposed on Gazouilloire's startup when setting up an invalid one.

- verbose

When set to true, logs will be way more explicit regarding Gazouilloire's interactions with Twitter's API.

Daemon mode

For production use and long term data collection, Gazouilloire can run as a daemon (which means that it executes in the background, and you can safely close the window within which you started it).

• Start the collection in daemon mode with:

  gazou start
  

• Stop the daemon with:

  gazou stop
  

• Restart the daemon with:

  gazou restart
  

• Access the current collection status (running/not running, nomber of collected tweets, disk usage, etc.) with

  gazou status
  

• Gazouilloire should normally restart on its own in case of temporary internet access outages but it might occasionnally fail for various reasons such as ElasticSearch having crashed for instance. In order to ensure a long term collection remains up and running without always checking it, we recommand to program automatic restarts of Gazouilloire at least once every week using cronjobs (missing tweets will be completed up to 7 days after a crash). In order to do so, a restart.sh script is proposed that handles restarting ElasticSearch whenever necessary. Just copy paste it within your corpus directory. Usecases and cronjobs examples are proposed as comments at the top of the script.

• An example script daily_mail_export.sh is also proposed to perform daily tweets exports and get them by e-mail. Feel free to reuse and tailor it to your own needs.

Reset

• Gazouilloire stores its current search state in the collection directory. This means that if you restart Gazouilloire in the same directory, it will not search again for tweets that were already collected. If you want a fresh start, you can reset the search state, as well as everything that was saved on disk, using:

  gazou reset
  

• You can also choose to delete only some elements, e.g. the tweets stored in ElasticSearch and the media files:

  gazou reset --only tweets,media
  

  Possible values for the --only argument: tweets,links,logs,piles,search_state,media

Development

To install Gazouilloire's latest development version or to help develop it, clone the repository and install your local version using the setup.py file:

git clone https://github.com/medialab/gazouilloire
cd gazouilloire
python setup.py install

Gazouilloire's main code relies in gazouilloire/run.py in which the whole multiprocess architecture is orchestrated. Below is a diagram of all processes and queues.

• The searcher collects tweets querying Twitter's search API v1.1 for all keywords sequentially as much as the API rates allows
• The streamer collects realtime tweets using Twitter's streaming API v1.1 and info on deleted tweets from users explicity followed as keywords
• The depiler processes and reformats tweets and deleted tweets using twitwi before indexing them into ElasticSearch. It also extracts media urls and parent tweets to feed the downloader and the catchupper
• The downloader requests all media urls and stores them on the filesystem (if the download_media option is enabled)
• The catchupper collects recursively via Twitter's lookup API v1.1 parent tweets of all collected tweets that are part of a thread and feeds back the depiler (if the grab_conversations option is enabled)
• The resolver runs multithreaded queries on all urls found as links within the collected tweets and tries to resolve them to get unshortened and harmonized urls (if the resolve_redirected_links option is enabled) thanks to minet

All three queues are backed up on filesystem in pile_***.json files to be reloaded at next restart whenever Gazouilloire is shut down.

Troubleshooting

ElasticSearch

• Remember to set the heap size (at 1GB by default) when moving to production. 1GB is fine for indices under 15-20 million tweets, but be sure to set a higher value for heavier corpora.

  Set these values here /etc/elasticsearch/jvm.options (if you use ElasticSearch as a service) or here your_installation_folder/config/jvm.options (if you have a custom installation folder):

  -Xms2g
  -Xmx2g
  

  Here the heap size is set at 2GB (set the values at -Xms5g -Xmx5g if you need 5GB, etc).

• If you encounter this ElasticSearch error message: max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144]:

  :arrow_right: Increase the max_map_count value:

  sudo sysctl -w vm.max_map_count=262144
  

  (source)

• If you get a ClusterBlockException [SERVICE_UNAVAILABLE/1/state not recovered / initialized] when starting ElasticSearch:

  :arrow_right: Check the value of gateway.recover_after_nodes in /etc/elasticsearch/elasticsearch.yml:

  sudo [YOUR TEXT EDITOR] /etc/elasticsearch/elasticsearch.yml
  

  Edit the value of gateway.recover_after_nodes to match your number of nodes (usually 1 - easily checked here : http://host:port/_nodes).

Publications

Gazouilloire presentations

• Video @ FOSDEM (english): MAZOYER Béatrice, "Gazouilloire: a command line tool for long-term tweets collection". Open Research Tools and Technologies devroom, FOSDEM 2021.

• Slides (french): OOGHE-TABANOU Benjamin, "Gazouilloire : Collecter des données dans la mare de tweets". Séminaire MORDEV, Laboratoire de Linguistique Formelle, Paris 2019.

Publications using Gazouilloire

• CASTALDO Maria, VENTURINI Tommaso, FRASCA Paolo, GARGIULO Floriana, "The Rhythms of the Night: increase in online night activity and emotional resilience during the Covid-19 lockdown" (2020). arXiv preprint arXiv:2007.09353.

• WARD Jeremy K, GUILLE-ESCURET Paul, ALAPETITE Clément, "Les « antivaccins », figure de l’anti-Science" (2019), in Déviance et Société, 2019/2 (Vol. 43), p. 221-251. DOI: 10.3917/ds.432.0221

• RICCI, Donato, COLOMBO, Gabriele, MEUNIER, Axel, et al. Designing Digital Methods to monitor and inform Urban Policy. The case of Paris and its Urban Nature initiative. In: 3rd International Conference on Public Policy (ICPP3)-Panel T10P6 Session 1 Digital Methods for Public Policy. SGP, 2017. p. 1-37.

• DOUAY, Nicolas, REYS, Aurélien, ROBIN, Sabrina. L’usage de Twitter par les maires d’Île-de-France. NETCOM, 29-3/4 | 2015 : Visualisation des réseaux, de l’information et de l’espace, p. 275-296.

• ANTOLINOS-BASSO Diégo, PADDEU Flaminia, DOUAY Nicolas, BLANC Nathalie. Pourquoi le débat #EuropaCity n’a pas pris sur Twitter ?. RESET, 7 | 2018. DOI : 10.4000/reset.1070

Publications talking about Gazouilloire

• JULLIARD, Virginie. #Theoriedugenre: comment débat-on du genre sur Twitter ?. Questions de communication, 2016, no 2, p. 135-157.

• BOTTINI, Thomas et JULLIARD, Virginie. Entre informatique et sémiotique. Réseaux, 2017, no 4, p. 35-69.

Credits & License

Benjamin Ooghe-Tabanou, Jules Farjas, Béatrice Mazoyer & al @ Sciences Po médialab

Read more about Gazouilloire's migration from Python2 & Mongo to Python3 & ElasticSearch in Jules' report.

Discover more of our projects at médialab tools.

This work has been supported by DIME-Web, part of DIME-SHS research equipment financed by the EQUIPEX program (ANR-10-EQPX-19-01).

Gazouilloire is a free open source software released under GPL 3.0 license.