Upload MuMiN-Build - MuMiN misinformation dataset builder toolkit

.flake8

@@ -0,0 +1,5 @@
+[flake8]
+ignore = E203, E266, E501, W503, F403, F401, C901
+max-line-length = 87
+max-complexity = 18
+select = B,C,E,F,W,T4,B9

.github/workflows/ci.yaml

@@ -0,0 +1,66 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: jpetrucciani/black-check@master
+
+  pytest:
+    strategy:
+        matrix:
+            os:
+              - macos-latest
+              - windows-latest
+              - ubuntu-latest
+            python-version:
+              - '3.8'
+              - '3.9'
+              - '3.10'
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Poetry
+        uses: abatilo/actions-poetry@v2.0.0
+        with:
+          poetry-version: 1.1.10
+
+      - name: Set Poetry config
+        run: |
+          poetry config virtualenvs.create true
+          poetry config virtualenvs.in-project false
+          poetry config virtualenvs.path ~/.virtualenvs
+
+      - name: Cache Poetry virtualenv
+        uses: actions/cache@v1
+        id: cache
+        with:
+          path: ~/.virtualenvs
+          key: poetry-${{ matrix.os }}-${{ matrix.python-version }}-${{ hashFiles('**/poetry.lock') }}
+          restore-keys: |
+            poetry-${{ matrix.os }}-${{ matrix.python-version }}-${{ hashFiles('**/poetry.lock') }}
+
+      - name: Install Dependencies
+        run: poetry install
+        if: steps.cache.outputs.cache-hit != 'true'
+
+      - name: Test with pytest
+        run: poetry run pytest -n 1
+        env:
+          TWITTER_API_KEY: ${{ secrets.TWITTER_API_KEY }}

.github/workflows/docs.yaml

@@ -0,0 +1,80 @@
+name: website
+
+# Build the documentation whenever there are new commits on main
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+    types:
+      - ready_for_review
+      - review_requested
+
+# Security: restrict permissions for CI jobs.
+permissions:
+  contents: read
+
+jobs:
+  # Build the documentation and upload the static HTML files as an artifact.
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Poetry
+        uses: abatilo/actions-poetry@v2.0.0
+        with:
+          poetry-version: 1.1.10
+
+      - name: Set Poetry config
+        run: |
+          poetry config virtualenvs.create true
+          poetry config virtualenvs.in-project false
+          poetry config virtualenvs.path ~/.virtualenvs
+
+      - name: Cache Poetry virtualenv
+        uses: actions/cache@v1
+        id: cache
+        with:
+          path: ~/.virtualenvs
+          key: poetry-${{ matrix.os }}-${{ matrix.python-version }}-${{ hashFiles('**/poetry.lock') }}
+          restore-keys: |
+            poetry-${{ matrix.os }}-${{ matrix.python-version }}-${{ hashFiles('**/poetry.lock') }}
+
+      - name: Install Dependencies
+        run: poetry install
+        if: steps.cache.outputs.cache-hit != 'true'
+
+      - name: Build documentation
+        run: poetry run pdoc --docformat google src/mumin -o docs
+
+      - name: Compress documentation
+        run: tar --directory docs/ -hcf artifact.tar .
+
+      - name: Upload documentation
+        uses: actions/upload-artifact@v3
+        with:
+          name: github-pages
+          path: ./artifact.tar
+
+  # Deploy the artifact to GitHub pages.
+  # This is a separate job so that only actions/deploy-pages has the necessary permissions.
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v1

.gitignore

@@ -0,0 +1,106 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+.venv
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# DotEnv configuration
+.env
+
+# Database
+*.db
+*.rdb
+
+# Pycharm
+.idea
+
+# VS Code
+.vscode/
+
+# Spyder
+.spyproject/
+
+# Jupyter NB Checkpoints
+.ipynb_checkpoints/
+
+# Mac OS-specific storage files
+.DS_Store
+
+# vim
+*.swp
+*.swo
+
+# Mypy cache
+.mypy_cache/
+
+# pytest cache
+.pytest_cache/
+
+# Checkpoints
+checkpoint-*
+
+# Documentation
+docs/mumin/
+docs/index.html
+docs/mumin.html
+docs/search.json
+
+# Testing
+mumin-*.zip
+test.py
+
+# Data
+data/*

.pre-commit-config.yaml

@@ -0,0 +1,22 @@
+repos:
+-   repo: https://github.com/ambv/black
+    rev: 22.3.0
+    hooks:
+    - id: black
+-   repo: https://github.com/timothycrosley/isort
+    rev: 5.7.0
+    hooks:
+    -   id: isort
+-   repo: https://gitlab.com/pycqa/flake8
+    rev: 3.8.4
+    hooks:
+    - id: flake8
+-   repo: https://github.com/kynan/nbstripout
+    rev: 0.5.0
+    hooks:
+    -   id: nbstripout
+-   repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v0.782
+    hooks:
+    -   id: mypy
+        args: [--ignore-missing-imports]

CHANGELOG.md

@@ -0,0 +1,423 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on
+[Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to
+[Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+
+## [v1.10.0] - 2022-07-31
+### Added
+- Added `n_jobs` and `chunksize` arguments to `MuminDataset`, to enable customisation
+  of these.
+
+### Changed
+- Lowered the default value of `chunksize` from 50 to 10, which also lowers the memory
+  requirements when processing articles and images, as fewer of these are kept in
+  memory at a time.
+- Now stores all images as `uint8` NumPy arrays rather than `int64`, reducing memory
+  usage of images significantly.
+
+
+## [v1.9.0] - 2022-07-22
+### Added
+- Added checkpoint after rehydration. This means that if compilation fails for whatever
+  reason after this point, the next compilation will resume after the rehydration
+  process.
+- Added some more unit tests.
+
+### Fixed
+- Fixed bug on Windows where some tweet IDs were negative.
+- Fixed another bug on Windows where the timeout decorator did not work, due to the use
+  of signals, which are not available on Windows machines.
+- Fixed bug on MacOS causing Python to crash during parallel extraction of articles and
+  images.
+
+### Changed
+- Refactored repository to use the more modern `pyproject.toml` with `poetry`.
+
+
+## [v1.8.0] - 2022-04-14
+### Changed
+- Now allows instantiation of `MuminDataset` without having any Twitter bearer
+  token, neither as an explicit argument nor as an environment variable, which
+  is useful for pre-compiled datasets. If the dataset needs to be compiled then
+  a `RuntimeError` will be raised when calling the `compile` method.
+
+
+## [v1.7.0] - 2022-03-24
+### Added
+- Now allows setting `twitter_bearer_token=None` in the constructor of
+  `MuminDataset`, which uses the environment variable `TWITTER_API_KEY`
+  instead, which can be stored in a separate `.env` file. This is now the
+  default value of `twitter_bearer_token`.
+
+### Changed
+- Replaced `DataFrame.append` calls with `pd.concat`, as the former is
+  deprecated and will be removed from `pandas` in the future.
+
+
+## [v1.6.2] - 2022-03-21
+### Fixed
+- Now removes claims that are only connected to deleted tweets when calling
+  `to_dgl`. This previously caused a bug that was due to a mismatch between
+  nodes in the dataset (which includes deleted ones) and nodes in the DGL graph
+  (which does not contain the deleted ones).
+
+
+## [v1.6.1] - 2022-03-17
+### Fixed
+- Now correctly catches JSONDecodeError during rehydration.
+
+
+## [v1.6.0] - 2022-03-10
+### Changed
+- Changed the download link from Git-LFS to the official data.bris data
+  repository, with URI
+  [https://doi.org/10.5523/bris.23yv276we2mll25fjakkfim2ml](https://doi.org/10.5523/bris.23yv276we2mll25fjakkfim2ml).
+
+
+## [v1.5.0] - 2022-02-19
+### Changed
+- Now using dicts rather than Series in `to_dgl`. This improved the wall time
+  from 1.5 hours to 2 seconds!
+
+### Fixed
+- There was a bug in the call to `dgl.data.utils.load_graphs` causing
+  `load_dgl_graph` to fail. This is fixed now.
+
+
+## [v1.4.1] - 2022-02-19
+### Changed
+- Now only saves dataset at the end of `add_embeddings` if any embeddings were
+  added.
+
+
+## [v1.4.0] - 2022-02-19
+### Added
+- The `to_dgl` method is now being parallelised, speeding export up
+  significantly.
+- Added convenience functions `save_dgl_graph` and `load_dgl_graph`, which
+  stores the Boolean train/val/test masks as unsigned 8-bit integers and
+  handles the conversion. Using the `dgl`-native `save_graphs` and
+  `load_graphs` causes an error, as it cannot handle Boolean tensors. These two
+  convenience functions can be loaded simply as
+  `from mumin import save_dgl_graph, load_dgl_graph`.
+
+
+## [v1.3.0] - 2022-02-18
+### Added
+- Now uses GPU to embed all the text and images, if available.
+
+
+## [v1.2.5] - 2022-02-06
+### Fixed
+- Now does not raise an error if we are not authorised to rehydrate a tweet,
+  and instead merely skips it.
+
+
+## [v1.2.4] - 2022-01-24
+### Fixed
+- Changed the minimum Python version compatible with `mumin` to 3.7, rather
+  than 3.4.
+
+
+## [v1.2.3] - 2021-12-15
+### Fixed
+- During rehydration, the authors of the source tweets were not included, and
+  the images from tweets were not included either. They are now included.
+
+
+## [v1.2.2] - 2021-12-15
+### Fixed
+- Now replacing NaN values for Numpy features with `np.nan` instead of an
+  array, as `fillna` does not accept that. These are then converted in a scalar
+  array with a `np.nan` value.
+
+
+## [v1.2.1] - 2021-12-15
+### Fixed
+- When running `add_embeddings`, only embeddings to existing nodes will be
+  added. This caused an error when e.g. images were not included in the
+  dataset.
+
+
+## [v1.2.0] - 2021-12-14
+### Changed
+- If tweets have been deleted (and thus cannot be rehydrated) then we keep them
+  along with their related entities, just without being able to populate their
+  features. When exporting to DGL then neither these tweets nor their replies
+  are included.
+
+### Added
+- Now includes a check that tweets are actually rehydrated, and raises an error
+  if they are not. Such an error is usually due to the inputted Twitter Bearer
+  Token being invalid.
+
+
+## [v1.1.1] - 2021-12-13
+### Fixed
+- Fixed bug in producing embeddings
+
+
+## [v1.1.0] - 2021-12-12
+### Fixed
+- Updated the dataset with deduplicated entries. The deduplication is done such
+  that the duplicate with the largest `relevance` parameter is kept.
+- Include checks of whether nodes and relations exist, before extracting data
+  from them.
+
+### Added
+- Added `include_timelines` option, which allows one to not include all the
+  extra tweets in the timelines if not needed. As this greatly increases the
+  amount of tweets needed to rehydrate, it defaults to False.
+
+
+## [v1.0.2] - 2021-12-09
+### Fixed
+- Removed the relations from the dump which we are getting through compilation
+  anyway.
+- Updated the filtering mechanism, so that the `relevance` parameter is built
+  in to all nodes and relations upon download.
+- Deal with the situation where no relations exist of a certain type, above a
+  specified threshold.
+
+
+## [v1.0.1] - 2021-12-05
+### Fixed
+- Added in the `POSTED` relation, as leaving this out effectively meant that
+  all the new tweets were filtered out during compilation.
+
+
+## [v1.0.0] - 2021-12-03
+### Changed
+- Added new version of the dataset, which now includes a sample of ~100
+  timeline tweets for every user. This approximately doubles the dataset size,
+  to ~200MB before compilation. This new dataset includes different
+  train/val/test splits as well, which is now 80/10/10 rather than 60/10/30.
+  This means that the training dataset will see a much more varied amount of
+  events (6-7) compared to the previous 2.
+
+
+## [v0.7.0] - 2021-12-02
+### Changed
+- Changed `include_images` to `include_tweet_images`, which now only includes
+  the images from the tweets themselves. Further, `include_user_images` is
+  changed to `include_extra_images`, which now includes both profile pictures
+  and the top images from articles. The tweet pictures are included by default,
+  and the extras are not. This is to reduce the size of the default dataset, to
+  make it easier to use.
+
+
+## [v0.6.0] - 2021-12-01
+### Changed
+- Split up the `include_images` into `include_images` and
+  `include_user_images`, with the former including images from tweets and
+  articles, and the latter being profile pictures. The former has been set to
+  True by default, and the latter False. This is due to the large amount of
+  profile pictures making the dataset excessively large.
+
+### Fixed
+- Now catches connection errors when attempting to rehydrate tweets.
+
+
+## [v0.5.3] - 2021-11-26
+### Fixed
+- Masks have been changed to boolean tensors, as otherwise indexing did not
+  work properly.
+- In the case where a claim/tweet does not have any label, this produces NaN
+  values in the mask- and label tensors. These are now substituted for zeroes.
+  This means that they will always be masked out, and so the label will not
+  matter anyway.
+
+
+## [v0.5.2] - 2021-11-24
+### Fixed
+- Now converting masks to long tensors, which is required for them to be used
+  as indexing tensors in PyTorch.
+
+### Changed
+- Now only dumping dataset once while adding embeddings, where previously it
+  dumped the dataset after adding embeddings to each node type. This is done to
+  add embeddings faster, as the dumping of the dataset can take quite a long
+  time.
+- Now blanket catching all errors when processing images and articles, as there
+  were too many edge cases.
+
+
+## [v0.5.1] - 2021-11-09
+### Fixed
+- When encountering HTTP status 401 (unauthorized) during rehydration, we skip
+  that batch of tweets.
+- Image relations were extracted incorrectly, due to a wrong treatment of the
+  images coming directly from the tweets via the `media_key` identifier, and
+  the images coming from URLs present in the tweets themselves. Both are now
+  correctly included in a uniform fashion.
+- Datatypes are now only set for a given node if the node is included in the
+  dataset. For instance, datatypes for the article features are only set if
+  `include_articles == True`.
+
+
+## [v0.5.0] - 2021-11-08
+### Added
+- The `Claim` nodes now have `language`, `keywords`, `cluster_keywords` and
+  `cluster` attributes.
+- Now sets datatypes for all the dataframes, to reduce memory usage.
+
+### Fixed
+- Updated `README` to a single zip file, rather than stating that the dataset
+  is saved as a bunch of CSV files.
+- Fixed image embedding shape from (1, 768) to (768,).
+- Article embeddings are now computed correctly.
+- Catch `IndexError` and `LocationParseError` when processing images.
+
+### Changed
+- Now dumping files incrementally rather than keeping all of them in memory, to
+  avoid out-of-memory issues when saving the dataset.
+- Dataset `size` argument now defaults to 'small', rather than 'large'.
+- Updated the dataset. This is still not the final version: timelines of users
+  are currently missing.
+- Now storing the dataset in a zip file of Pickle files instead of HDF. This is
+  because of HDF requiring extra installation, and there being maximal storage
+  requirements in the dataframes when storing as HDF. The resulting zip file of
+  Pickle files is stored with protocol 4, making it compatible with Python 3.4
+  and newer. Further, the dataset being downloaded has been heavily compressed,
+  taking up a quarter of the disk space compared to the previous CSV approach.
+  When the dataset has been downloaded it will be converted to a less
+  compressed version, taking up more space but making loading and saving much
+  faster.
+
+### Removed
+- Disabled `numexpr`, `transformers` and `bs4` logging.
+
+
+## [v0.4.0] - 2021-10-26
+### Fixed
+- All embeddings are now extracted from the pooler output, corresponding to the
+  `[CLS]` tag.
+- Ensured that train/val/test masks are boolean tensors when exporting to DGL,
+  as opposed to binary integers.
+- Content embeddings for articles were not aggregated per chunk, but now a mean
+  is taken across all content chunks.
+- Assign zero embeddings to user descriptions if they are not available.
+
+### Changed
+- The DGL graph returned by the `to_dgl` method now returns a bidirectional
+  graph.
+- The `verbose` argument of `MuminDataset` now defaults to `True`.
+- Now storing the dataset as a single HDF file instead of a zipped folder of
+  CSV files, primarily because data types are being preserved in this way, and
+  that HDF is a binary format supported by Pandas which can handle
+  multidimensional ndarrays as entries in a dataframe.
+- The default models used to embed texts and images are now `xlm-roberta-base`
+  and `google/vit-base-patch16-224-in21k`.
+
+### Removed
+- Removed the `poll` and `place` nodes, as they were too few to matter.
+- Removed the `(:User)-[:HAS_PINNED]->(:Tweet)` relation, as there were too few
+  of them to matter.
+
+
+## [v0.3.1] - 2021-10-19
+### Fixed
+- Fixed the shape of the user description embeddings.
+
+
+## [v0.3.0] - 2021-10-18
+### Fixed
+- Now catches `SSLError` and `OSError` when processing images.
+- Now catches `ReadTimeoutError` when processing articles.
+- The `(:Tweet)-[:MENTIONS]->(:User)` was missing in the dataset. It has now
+  been added back in.
+- Added tokenizer truncation when adding node embeddings.
+- Fixed an issue with embedding user descriptions when the description is not
+  available.
+
+### Changed
+- Changed the download link to the dataset, which now fetches the dataset from
+  a specific commit, enabling proper dataset versioning.
+- Changed the timeout parameter when downloading images from five seconds to
+  ten seconds.
+- Now processing 50 articles and images on each worker, compared to the
+  previous 5.
+- When loading in an existing dataset, auxilliaries and islands are removed.
+  This ensures that `to_dgl` works properly.
+
+### Removed
+- Removed the review warning from the `README` and when initialising the
+  dataset. The dataset is still not complete, in the sense that we will add
+  retweets and timelines, but we will instead just keep versioning the dataset
+  until we have included these extra features.
+
+
+## [v0.2.0] - 2021-10-12
+### Added
+- Added claim embeddings to Claim nodes, being the transformer embeddings of
+  the claims translated to English, as described in the paper.
+- Added train/val/test split to claim nodes. When exporting to DGL using the
+  `to_dgl` method, the Claim and Tweet nodes will have `train_mask`, `val_mask`
+  and `test_mask` attributes that can be used to control loss and metric
+  calculation. These are consistent, meaning that tweets connected to claims
+  will always belong to the same split.
+- Added labels to both Tweet and Claim nodes.
+
+### Fixed
+- Properly embeds reviewers of claims in case a claim has been reviewed by
+  multiple reviewers.
+- Load claim embeddings properly.
+- Catches `TooManyRequests` exception when extracting images.
+- Load dataset CSVs with Python engine, as the C engine caused errors.
+- Disable tokenizer parallelism, which caused warning messages during
+  rehydration of tweets.
+- Ensure proper quoting of strings when dumping dataset to CSVs.
+- Enable truncation of strings before tokenizing, when embedding texts.
+- Convert masks to integers, which caused an issue when exporting to a DGL
+  graph.
+- Bug when computing reviewer embeddings for claims.
+- Now properly shows `compiled=True` when printing the dataset, after
+  compilation.
+
+### Changed
+- Changed disclaimer about review period.
+
+
+## [v0.1.4] - 2021-09-13
+### Fixed
+- Include `(:User)-[:POSTED]->(:Reply)` in the dataset, extracted from the
+  rehydrated reply and quote tweets.
+
+
+## [v0.1.3] - 2021-09-13
+### Fixed
+- Compilation error when including images.
+- Only include videos if they are present in the dataset.
+- Ensure that article embeddings can properly be converted to PyTorch tensors
+  when exporting to DGL.
+
+
+## [v0.1.2] - 2021-09-13
+### Fixed
+- The replies were not reduced correctly when the `small` or `medium` variants
+  of the dataset was compiled.
+- The reply features were not filtered and renamed properly, to keep them
+  consistent with the tweet nodes.
+- Users without any description now gets assigned a zero vector as their
+  description embedding.
+- If a relation does not have any node pairs then do not try to create a
+  corresponding DGL relation.
+- Reset `nodes` and `rels` attributes when loading dataset.
+- Add embeddings for `Reply` nodes.
+
+
+## [v0.1.1] - 2021-09-08
+### Changed
+- Changed installation instructions in readme to `pip install mumin`.
+
+
+## [v0.1.0] - 2021-09-07
+### Added
+- First release, including a `MuminDataset` class that can compile the dataset
+  dump the compiled dataset to local `csv` files, and export it as a `dgl`
+  graph.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-2022 CLARITI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,105 @@
+# MuMiN-Build
+This repository contains the package used to build the MuMiN dataset from the
+paper [Nielsen and McConville: _MuMiN: A Large-Scale Multilingual Multimodal
+Fact-Checked Misinformation Social Network Dataset_
+(2021)](https://arxiv.org/abs/2202.11684).
+
+See [the MuMiN website](https://mumin-dataset.github.io/) for more information,
+including a leaderboard of the top performing models.
+
+______________________________________________________________________
+[![PyPI Status](https://badge.fury.io/py/mumin.svg)](https://pypi.org/project/mumin/)
+[![Documentation](https://img.shields.io/badge/docs-passing-green)](https://mumin-dataset.github.io/mumin-build/mumin.html)
+[![License](https://img.shields.io/github/license/mumin-dataset/mumin-build)](https://github.com/mumin-dataset/mumin-build/blob/main/LICENSE)
+[![LastCommit](https://img.shields.io/github/last-commit/mumin-dataset/mumin-build)](https://github.com/mumin-dataset/mumin-build/commits/main)
+[![Code Coverage](https://img.shields.io/badge/Coverage-76%25-yellowgreen.svg)](https://github.com/mumin-dataset/mumin-build/tree/dev/tests)
+
+
+## Installation
+The `mumin` package can be installed using `pip`:
+```
+$ pip install mumin
+```
+
+To be able to build the dataset, Twitter data needs to be downloaded, which
+requires a Twitter API key. You can get one
+[for free here](https://developer.twitter.com/en/portal/dashboard). You will
+need the _Bearer Token_.
+
+
+## Quickstart
+The main class of the package is the `MuminDataset` class:
+```
+>>> from mumin import MuminDataset
+>>> dataset = MuminDataset(twitter_bearer_token=XXXXX)
+>>> dataset
+MuminDataset(size='small', compiled=False)
+```
+
+By default, this loads the small version of the dataset. This can be changed by
+setting the `size` argument of `MuminDataset` to one of 'small', 'medium' or
+'large'. To begin using the dataset, it first needs to be compiled. This will
+download the dataset, rehydrate the tweets and users, and download all the
+associated news articles, images and videos. This usually takes a while.
+```
+>>> dataset.compile()
+MuminDataset(num_nodes=388,149, num_relations=475,490, size='small', compiled=True)
+```
+
+Note that this dataset does not contain _all_ the nodes and relations in
+MuMiN-small, as that would take way longer to compile. The data left out are
+timelines, profile pictures and article images. These can be included by
+specifying `include_extra_images=True` and/or `include_timelines=True` in the
+constructor of `MuminDataset`.
+
+After compilation, the dataset can also be found in the `mumin-<size>.zip`
+file. This file name can be changed using the `dataset_path` argument when
+initialising the `MuminDataset` class. If you need embeddings of the nodes, for
+instance for use in machine learning models, then you can simply call the
+`add_embeddings` method:
+```
+>>> dataset.add_embeddings()
+MuminDataset(num_nodes=388,149, num_relations=475,490, size='small', compiled=True)
+```
+
+**Note**: If you need to use the `add_embeddings` method, you need to install
+the `mumin` package as either `pip install mumin[embeddings]` or `pip install
+mumin[all]`, which will install the `transformers` and `torch` libraries. This
+is to ensure that such large libraries are only downloaded if needed.
+
+It is possible to export the dataset to the
+[Deep Graph Library](https://www.dgl.ai/), using the `to_dgl` method:
+```
+>>> dgl_graph = dataset.to_dgl()
+>>> type(dgl_graph)
+dgl.heterograph.DGLHeteroGraph
+```
+
+**Note**: If you need to use the `to_dgl` method, you need to install the
+`mumin` package as `pip install mumin[dgl]` or `pip install mumin[all]`, which
+will install the `dgl` and `torch` libraries.
+
+For a more in-depth tutorial of how to work with the dataset, including
+training multiple different misinformation classifiers, see [the
+tutorial](https://colab.research.google.com/drive/1Kz0EQtySYQTo1ui8F2KZ6ERneZVf5TIN).
+
+
+## Dataset Statistics
+
+| Dataset | #Claims | #Threads | #Tweets | #Users | #Articles | #Images | #Languages | %Misinfo |
+| ---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: |
+| MuMiN-large | 12,914 | 26,048 | 21,565,018 | 1,986,354 | 10,920 | 6,573 | 41 | 94.57% |
+| MuMiN-medium | 5,565 | 10,832 | 12,650,371 | 1,150,259 | 4,212 | 2,510 | 37 | 94.07% |
+| MuMiN-small | 2,183 | 4,344 | 7,202,506 | 639,559 | 1,497 | 1,036 | 35 | 92.87% |
+
+
+## Related Repositories
+- [MuMiN website](https://mumin-dataset.github.io/), the central place for the
+  MuMiN ecosystem, containing tutorials, leaderboards and links to the paper
+  and related repositories.
+- [MuMiN](https://github.com/MuMiN-dataset/mumin), containing the
+  paper in PDF and LaTeX form.
+- [MuMiN-trawl](https://github.com/MuMiN-dataset/mumin-trawl),
+  containing the source code used to construct the dataset from scratch.
+- [MuMiN-baseline](https://github.com/MuMiN-dataset/mumin-baseline),
+  containing the source code for the baselines.

makefile

@@ -0,0 +1,116 @@
+# This ensures that we can call `make <target>` even if `<target>` exists as a file or
+# directory.
+.PHONY: notebook docs
+
+# Exports all variables defined in the makefile available to scripts
+.EXPORT_ALL_VARIABLES:
+
+install-poetry:
+	@echo "Installing poetry..."
+	@curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python3 -
+
+uninstall-poetry:
+	@echo "Uninstalling poetry..."
+	@curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python3 - --uninstall
+
+install:
+	@echo "Installing..."
+	@if [ "$(shell which poetry)" = "" ]; then \
+		make install-poetry; \
+	fi
+	@if [ "$(shell which gpg)" = "" ]; then \
+		echo "GPG not installed, so an error will occur. Install GPG on MacOS with "\
+			 "`brew install gnupg` or on Ubuntu with `apt install gnupg` and run "\
+			 "`make install` again."; \
+	fi
+	@poetry env use python3
+	@poetry run python3 -m src.scripts.fix_dot_env_file
+	@git init
+	@. .env; \
+		git config --local user.name "$${GIT_NAME}"; \
+		git config --local user.email "$${GIT_EMAIL}"
+	@. .env; \
+		if [ "$${GPG_KEY_ID}" = "" ]; then \
+			echo "No GPG key ID specified. Skipping GPG signing."; \
+			git config --local commit.gpgsign false; \
+		else \
+			echo "Signing with GPG key ID $${GPG_KEY_ID}..."; \
+			git config --local commit.gpgsign true; \
+			git config --local user.signingkey "$${GPG_KEY_ID}"; \
+		fi
+	@poetry install
+	@poetry run pre-commit install
+
+remove-env:
+	@poetry env remove python3
+	@echo "Removed virtual environment."
+
+docs:
+	@poetry run pdoc --docformat google -o docs src/mumin
+	@echo "Saved documentation."
+
+view-docs:
+	@echo "Viewing API documentation..."
+	@open docs/mumin.html
+
+clean:
+	@find . -type f -name "*.py[co]" -delete
+	@find . -type d -name "__pycache__" -delete
+	@rm -rf .pytest_cache
+	@echo "Cleaned repository."
+
+test:
+	@pytest && readme-cov
+
+tree:
+	@tree -a \
+		-I .git \
+		-I .mypy_cache . \
+		-I .env \
+		-I .venv \
+		-I poetry.lock \
+		-I .ipynb_checkpoints \
+		-I dist \
+		-I .gitkeep \
+		-I docs \
+		-I .pytest_cache
+
+bump-major:
+	@poetry run python -m src.scripts.versioning --major
+	@echo "Bumped major version."
+
+bump-minor:
+	@poetry run python -m src.scripts.versioning --minor
+	@echo "Bumped minor version."
+
+bump-patch:
+	@poetry run python -m src.scripts.versioning --patch
+	@echo "Bumped patch version."
+
+publish:
+	@. .env; \
+		printf "Preparing to publish to PyPI. Have you ensured to change the package version with 'make bump-X' for 'X' being 'major', 'minor' or 'patch', as well as run unit tests with 'make test'? [y/n] : "; \
+		read -r answer; \
+		if [ "$${answer}" = "y" ]; then \
+			if [ "$${PYPI_API_TOKEN}" = "" ]; then \
+				echo "No PyPI API token specified in the '.env' file, so cannot publish."; \
+			else \
+				echo "Publishing to PyPI..."; \
+				poetry publish --build --username "__token__" --password "$${PYPI_API_TOKEN}"; \
+				echo "Published!"; \
+			fi \
+		else \
+			echo "Publishing aborted."; \
+		fi
+
+compile-small:
+	@poetry run python -m src.scripts.compile_mumin small
+
+compile-medium:
+	@poetry run python -m src.scripts.compile_mumin medium
+
+compile-large:
+	@poetry run python -m src.scripts.compile_mumin large
+
+compile-test:
+	@poetry run python -m src.scripts.compile_mumin test

poetry.toml

@@ -0,0 +1,3 @@
+[virtualenvs]
+create = true
+in-project = true

pyproject.toml

@@ -0,0 +1,73 @@
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+name = "mumin"
+version = "1.10.0"
+description = "Seamlessly build the MuMiN dataset."
+authors = [
+    "Dan Saattrup Nielsen <dan.nielsen@alexandra.dk>",
+    "Ryan McConville <ryan.mcconville@bristol.ac.uk>",
+]
+readme = "README.md"
+license = "MIT"
+homepage = "https://mumin-dataset.github.io/"
+repository = "https://github.com/MuMiN-dataset/mumin-build"
+
+[tool.poetry.dependencies]
+python = ">=3.8,<3.11"
+tqdm = "^4.62.0"
+transformers = "^4.20.0"
+torch = "^1.12.0"
+newspaper3k = "^0.2.8"
+pandas = "^1.4.3"
+python-dotenv = "^0.20.0"
+wrapt-timeout-decorator = "^1.3.12"
+
+[tool.poetry.dev-dependencies]
+pdoc = "^7.1.1"
+pytest = "^6.2.5"
+pre-commit = "^2.17.0"
+black = "^22.3.0"
+isort = "^5.10.1"
+pytest-xdist = "^2.5.0"
+pytest-cov = "^3.0.0"
+readme-coverage-badger = "^0.1.2"
+python-dotenv = "^0.20.0"
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = [
+    '--verbose',
+    '--durations=10',
+    '--color=yes',
+    '-s',
+    '-vv',
+    '--doctest-modules',
+    '--cov=src/mumin',
+    '-n 1',
+]
+xfail_strict = true
+filterwarnings = ["error"]
+log_cli_level = "info"
+testpaths = ["tests", "src/mumin"]
+
+[tool.black]
+line-length = 88
+include = '\.pyi?$'
+exclude = '''
+/(
+	\.git
+| \.hg
+| \.mypy_cache
+| \.tox
+| \.venv
+| _build
+| buck-out
+| build
+)/
+'''
+
+[tool.isort]
+profile = "black"

src/mumin/__init__.py

@@ -0,0 +1,29 @@
+"""
+.. include:: ../../README.md
+"""
+
+import logging
+
+import pkg_resources  # noqa: E402
+
+# Set up logging
+fmt = "%(asctime)s [%(levelname)s] %(message)s"
+logging.basicConfig(level=logging.INFO, format=fmt)
+logging.getLogger("urllib3").disabled = True
+logging.getLogger("urllib3").propagate = False
+logging.getLogger("newspaper").disabled = True
+logging.getLogger("newspaper").propagate = False
+logging.getLogger("jieba").disabled = True
+logging.getLogger("jieba").propagate = False
+logging.getLogger("numexpr").disabled = True
+logging.getLogger("numexpr").propagate = False
+logging.getLogger("bs4").disabled = True
+logging.getLogger("bs4").propagate = False
+logging.getLogger("transformers").disabled = True
+logging.getLogger("transformers").propagate = False
+
+from .dataset import MuminDataset  # noqa
+from .dgl import load_dgl_graph, save_dgl_graph  # noqa
+
+# Fetches the version of the package as defined in pyproject.toml
+__version__ = pkg_resources.get_distribution("mumin").version

src/mumin/article.py

@@ -0,0 +1,79 @@
+"""Functions related to processing articles"""
+
+import datetime as dt
+import re
+import warnings
+from typing import Optional, Union
+
+from newspaper import Article
+from wrapt_timeout_decorator.wrapt_timeout_decorator import timeout
+
+
+@timeout(10)
+def download_article_with_timeout(article: Article):
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=DeprecationWarning)
+        article.download()
+    return article
+
+
+def process_article_url(url: str) -> Union[None, dict]:
+    """Process the URL and extract the article.
+
+    Args:
+        url (str): The URL.
+
+    Returns:
+        dict or None:
+            The processed article, or None if the URL could not be parsed.
+    """
+    # Remove GET arguments from the URL
+    stripped_url = re.sub(r'(\?.*"|\/$)', "", url)
+
+    try:
+        article = Article(stripped_url)
+        article = download_article_with_timeout(article)
+        article.parse()
+    except Exception:  # noqa
+        return None
+
+    # Extract the title and skip URL if it is empty
+    title = article.title
+    if title == "":
+        return None
+    else:
+        title = re.sub("\n+", "\n", title)
+        title = re.sub(" +", " ", title)
+        title = title.strip()
+
+    # Extract the content and skip URL if it is empty
+    content = article.text.strip()
+    if content == "":
+        return None
+    else:
+        content = re.sub("\n+", "\n", content)
+        content = re.sub(" +", " ", content)
+        content = content.strip()
+
+    # Extract the authors, the publishing date and the top image
+    authors = list(article.authors)
+    publish_date: Optional[str]
+    if article.publish_date is not None:
+        date = article.publish_date
+        publish_date = dt.datetime.strftime(date, "%Y-%m-%d")
+    else:
+        publish_date = None
+    try:
+        top_image_url = article.top_image
+    except AttributeError:
+        top_image_url = None
+
+    data_dict = dict(
+        url=stripped_url,
+        title=title,
+        content=content,
+        authors=authors,
+        publish_date=publish_date,
+        top_image_url=top_image_url,
+    )
+    return data_dict

src/mumin/data_extractor.py

@@ -0,0 +1,1382 @@
+"""Extract node and relation data from the rehydrated Twitter data"""
+
+import multiprocessing as mp
+import re
+from collections import defaultdict
+from typing import Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import pandas as pd
+from tqdm.auto import tqdm
+
+from .article import process_article_url
+from .image import process_image_url
+
+
+class DataExtractor:
+    """Extract node and relation data from the rehydrated Twitter data.
+
+    Args:
+        include_replies (bool):
+            Whether to include replies.
+        include_articles (bool):
+            Whether to include articles.
+        include_tweet_images (bool):
+            Whether to include tweet images.
+        include_extra_images (bool):
+            Whether to include extra images.
+        include_hashtags (bool):
+            Whether to include hashtags.
+        include_mentions (bool):
+            Whether to include mentions.
+        n_jobs (int):
+            The number of parallel jobs to use.
+        chunksize (int):
+            The number of samples to process at a time.
+
+    Attributes:
+        include_replies (bool):
+            Whether to include replies.
+        include_articles (bool):
+            Whether to include articles.
+        include_tweet_images (bool):
+            Whether to include tweet images.
+        include_extra_images (bool):
+            Whether to include extra images.
+        include_hashtags (bool):
+            Whether to include hashtags.
+        include_mentions (bool):
+            Whether to include mentions.
+    """
+
+    def __init__(
+        self,
+        include_replies: bool,
+        include_articles: bool,
+        include_tweet_images: bool,
+        include_extra_images: bool,
+        include_hashtags: bool,
+        include_mentions: bool,
+        n_jobs: int,
+        chunksize: int,
+    ):
+        self.include_replies = include_replies
+        self.include_articles = include_articles
+        self.include_tweet_images = include_tweet_images
+        self.include_extra_images = include_extra_images
+        self.include_hashtags = include_hashtags
+        self.include_mentions = include_mentions
+        self.n_jobs = n_jobs
+        self.chunksize = chunksize
+
+    def extract_all(
+        self,
+        nodes: Dict[str, pd.DataFrame],
+        rels: Dict[Tuple[str, str, str], pd.DataFrame],
+    ) -> Tuple[dict, dict]:
+        """Extract all node and relation data.
+
+        Args:
+            nodes (Dict[str, pd.DataFrame]):
+                A dictionary of node dataframes.
+            rels (Dict[Tuple[str, str, str], pd.DataFrame]):
+                A dictionary of relation dataframes.
+
+        Returns:
+            pair of dicts:
+                A tuple of updated node and relation dictionaries.
+        """
+        # Extract data directly from the rehydrated data
+        nodes["hashtag"] = self._extract_hashtags(
+            tweet_df=nodes["tweet"], user_df=nodes["user"]
+        )
+        rels[("user", "posted", "tweet")] = self._extract_user_posted_tweet(
+            tweet_df=nodes["tweet"], user_df=nodes["user"]
+        )
+        rels[("user", "posted", "reply")] = self._extract_user_posted_reply(
+            reply_df=nodes["reply"], user_df=nodes["user"]
+        )
+        rels[("tweet", "mentions", "user")] = self._extract_tweet_mentions_user(
+            tweet_df=nodes["tweet"], user_df=nodes["user"]
+        )
+        rels[("user", "mentions", "user")] = self._extract_user_mentions_user(
+            user_df=nodes["user"]
+        )
+
+        # Extract data relying on hashtag data
+        rels[
+            ("tweet", "has_hashtag", "hashtag")
+        ] = self._extract_tweet_has_hashtag_hashtag(
+            tweet_df=nodes["tweet"], hashtag_df=nodes["hashtag"]
+        )
+        rels[
+            ("user", "has_hashtag", "hashtag")
+        ] = self._extract_user_has_hashtag_hashtag(
+            user_df=nodes["user"], hashtag_df=nodes["hashtag"]
+        )
+
+        # Extract data relying on the pre-extracted article and image data, as well has
+        # the (:User)-[:POSTED]->(:Tweet) relation
+        nodes["url"] = self._extract_urls(
+            tweet_dicusses_claim_df=rels[("tweet", "discusses", "claim")],
+            user_posted_tweet_df=rels[("user", "posted", "tweet")],
+            user_df=nodes["user"],
+            tweet_df=nodes["tweet"],
+            article_df=nodes.get("article"),
+            image_df=nodes.get("image"),
+        )
+
+        # Extract data relying on the URL data without the URLs from the articles
+        nodes["article"] = self._extract_articles(
+            url_df=nodes["url"],
+        )
+
+        # Update the URLs with URLs from the articles
+        nodes["url"] = self._update_urls_from_articles(
+            url_df=nodes["url"], article_df=nodes["article"]
+        )
+
+        # Extract data relying on url data
+        rels[("user", "has_url", "url")] = self._extract_user_has_url_url(
+            user_df=nodes["user"], url_df=nodes["url"]
+        )
+        rels[
+            ("user", "has_profile_picture_url", "url")
+        ] = self._extract_user_has_profile_picture_url_url(
+            user_df=nodes["user"], url_df=nodes["url"]
+        )
+
+        # Extract data relying on url and pre-extracted image data
+        rels[("tweet", "has_url", "url")] = self._extract_tweet_has_url_url(
+            tweet_df=nodes["tweet"], url_df=nodes["url"], image_df=nodes.get("image")
+        )
+
+        # Extract data relying on article and url data
+        nodes["image"] = self._extract_images(
+            url_df=nodes["url"], article_df=nodes["article"]
+        )
+        rels[
+            ("article", "has_top_image_url", "url")
+        ] = self._extract_article_has_top_image_url_url(
+            article_df=nodes["article"], url_df=nodes["url"]
+        )
+
+        # Extract data relying on article and url data, as well has the
+        # (:Tweet)-[:HAS_URL]->(:Url) relation
+        rels[
+            ("tweet", "has_article", "article")
+        ] = self._extract_tweet_has_article_article(
+            tweet_has_url_url_df=rels[("tweet", "has_url", "url")],
+            article_df=nodes["article"],
+            url_df=nodes["url"],
+        )
+
+        # Extract data relying on image and url data, as well has the
+        # (:Tweet)-[:HAS_URL]->(:Url) relation
+        rels[("tweet", "has_image", "image")] = self._extract_tweet_has_image_image(
+            tweet_has_url_url_df=rels[("tweet", "has_url", "url")],
+            url_df=nodes["url"],
+            image_df=nodes["image"],
+        )
+
+        # Extract data relying on article, image and url data, as well has the
+        # (:Article)-[:HAS_TOP_IMAGE_URL]->(:Url) relation
+        top_image_url_rel = rels[("article", "has_top_image_url", "url")]
+        rels[
+            ("article", "has_top_image", "image")
+        ] = self._extract_article_has_top_image_image(
+            article_has_top_image_url_url_df=top_image_url_rel,
+            url_df=nodes["url"],
+            image_df=nodes["image"],
+        )
+
+        # Extract data relying on image and url data, as well has the
+        # (:User)-[:HAS_PROFILE_PICTURE_URL]->(:Url) relation
+        has_profile_pic_df = rels[("user", "has_profile_picture_url", "url")]
+        rels[
+            ("user", "has_profile_picture", "image")
+        ] = self._extract_user_has_profile_picture_image(
+            user_has_profile_picture_url_url_df=has_profile_pic_df,
+            url_df=nodes["url"],
+            image_df=nodes["image"],
+        )
+
+        return nodes, rels
+
+    def _extract_user_posted_tweet(
+        self, tweet_df: pd.DataFrame, user_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Extract (:User)-[:POSTED]->(:Tweet) relation data.
+
+        Args:
+            tweet_df (pd.DataFrame):
+                A dataframe of tweets.
+            user_df (pd.DataFrame):
+                A dataframe of users.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of relations.
+        """
+        if len(tweet_df) and len(user_df):
+            merged = (
+                tweet_df[["author_id"]]
+                .dropna()
+                .reset_index()
+                .rename(columns=dict(index="tweet_idx"))
+                .astype({"author_id": np.uint64})
+                .merge(
+                    user_df[["user_id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="user_idx")),
+                    left_on="author_id",
+                    right_on="user_id",
+                )
+            )
+            data_dict = dict(
+                src=merged.user_idx.tolist(), tgt=merged.tweet_idx.tolist()
+            )
+            return pd.DataFrame(data_dict)
+        else:
+            return pd.DataFrame()
+
+    def _extract_user_posted_reply(
+        self, reply_df: pd.DataFrame, user_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Extract (:User)-[:POSTED]->(:Reply) relation data.
+
+        Args:
+            reply_df (pd.DataFrame):
+                A dataframe of replies.
+            user_df (pd.DataFrame):
+                A dataframe of users.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of relations.
+        """
+        if self.include_replies and len(reply_df) and len(user_df):
+            merged = (
+                reply_df[["author_id"]]
+                .dropna()
+                .reset_index()
+                .rename(columns=dict(index="reply_idx"))
+                .astype({"author_id": np.uint64})
+                .merge(
+                    user_df[["user_id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="user_idx")),
+                    left_on="author_id",
+                    right_on="user_id",
+                )
+            )
+            data_dict = dict(
+                src=merged.user_idx.tolist(), tgt=merged.reply_idx.tolist()
+            )
+            return pd.DataFrame(data_dict)
+        else:
+            return pd.DataFrame()
+
+    def _extract_tweet_mentions_user(
+        self, tweet_df: pd.DataFrame, user_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Extract (:Tweet)-[:MENTIONS]->(:User) relation data.
+
+        Args:
+            tweet_df (pd.DataFrame):
+                A dataframe of tweets.
+            user_df (pd.DataFrame):
+                A dataframe of users.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of relations.
+        """
+        mentions_exist = "entities.mentions" in tweet_df.columns
+        if self.include_mentions and mentions_exist and len(tweet_df) and len(user_df):
+
+            def extract_mention(dcts: List[dict]) -> List[Union[int, str]]:
+                """Extracts user ids from a list of dictionaries.
+
+                Args:
+                    dcts (List[dict]):
+                        A list of dictionaries.
+
+                Returns:
+                    List[Union[int, str]]:
+                        A list of user ids.
+                """
+                return [dct["id"] for dct in dcts]
+
+            merged = (
+                tweet_df[["entities.mentions"]]
+                .dropna()
+                .applymap(extract_mention)
+                .reset_index()
+                .rename(columns=dict(index="tweet_idx"))
+                .explode("entities.mentions")
+                .astype({"entities.mentions": np.uint64})
+                .merge(
+                    user_df[["user_id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="user_idx")),
+                    left_on="entities.mentions",
+                    right_on="user_id",
+                )
+            )
+            data_dict = dict(
+                src=merged.tweet_idx.tolist(), tgt=merged.user_idx.tolist()
+            )
+            return pd.DataFrame(data_dict)
+        else:
+            return pd.DataFrame()
+
+    def _extract_user_mentions_user(self, user_df: pd.DataFrame) -> pd.DataFrame:
+        """Extract (:User)-[:MENTIONS]->(:User) relation data.
+
+        Args:
+            user_df (pd.DataFrame):
+                A dataframe of users.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of relations.
+        """
+        user_cols = user_df.columns
+        mentions_exist = "entities.description.mentions" in user_cols
+        if self.include_mentions and mentions_exist and len(user_df):
+
+            def extract_mention(dcts: List[dict]) -> List[str]:
+                """Extracts user ids from a list of dictionaries.
+
+                Args:
+                    dcts (List[dict]):
+                        A list of dictionaries.
+
+                Returns:
+                    List[str]:
+                        A list of user ids.
+                """
+                return [dct["username"] for dct in dcts]
+
+            merged = (
+                user_df[["entities.description.mentions"]]
+                .dropna()
+                .applymap(extract_mention)
+                .reset_index()
+                .rename(columns=dict(index="user_idx1"))
+                .explode("entities.description.mentions")
+                .merge(
+                    user_df[["username"]]
+                    .reset_index()
+                    .rename(columns=dict(index="user_idx2")),
+                    left_on="entities.description.mentions",
+                    right_on="username",
+                )
+            )
+            data_dict = dict(
+                src=merged.user_idx1.tolist(), tgt=merged.user_idx2.tolist()
+            )
+            return pd.DataFrame(data_dict)
+        else:
+            return pd.DataFrame()
+
+    def _extract_tweet_has_hashtag_hashtag(
+        self, tweet_df: pd.DataFrame, hashtag_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Extract (:Tweet)-[:HAS_HASHTAG]->(:Hashtag) relation data.
+
+        Args:
+            tweet_df (pd.DataFrame):
+                A dataframe of tweets.
+            hashtag_df (pd.DataFrame):
+                A dataframe of hashtags.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of relations.
+        """
+        hashtags_exist = "entities.hashtags" in tweet_df.columns
+        if (
+            self.include_hashtags
+            and hashtags_exist
+            and len(tweet_df)
+            and len(hashtag_df)
+        ):
+
+            def extract_hashtag(dcts: List[dict]) -> List[Union[str, None]]:
+                """Extracts hashtags from a list of dictionaries.
+
+                Args:
+                    dcts (list of dict):
+                        A list of dictionaries.
+
+                Returns:
+                    list of str or None:
+                        A list of hashtags.
+                """
+                return [dct.get("tag") for dct in dcts]
+
+            merged = (
+                tweet_df[["entities.hashtags"]]
+                .dropna()
+                .applymap(extract_hashtag)
+                .reset_index()
+                .rename(columns=dict(index="tweet_idx"))
+                .explode("entities.hashtags")
+                .merge(
+                    hashtag_df[["tag"]]
+                    .reset_index()
+                    .rename(columns=dict(index="tag_idx")),
+                    left_on="entities.hashtags",
+                    right_on="tag",
+                )
+            )
+            data_dict = dict(src=merged.tweet_idx.tolist(), tgt=merged.tag_idx.tolist())
+            return pd.DataFrame(data_dict)
+        else:
+            return pd.DataFrame()
+
+    def _extract_user_has_hashtag_hashtag(
+        self, user_df: pd.DataFrame, hashtag_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Extract (:User)-[:HAS_HASHTAG]->(:Hashtag) relation data.
+
+        Args:
+            user_df (pd.DataFrame):
+                A dataframe of users.
+            hashtag_df (pd.DataFrame):
+                A dataframe of hashtags.
+
+        Returns:
+            pd.DataFrame: A dataframe of relations.
+        """
+        user_cols = user_df.columns
+        hashtags_exist = "entities.description.hashtags" in user_cols
+        if (
+            self.include_hashtags
+            and hashtags_exist
+            and len(user_df)
+            and len(hashtag_df)
+        ):
+
+            def extract_hashtag(dcts: List[dict]) -> List[Union[str, None]]:
+                """Extracts hashtags from a list of dictionaries.
+
+                Args:
+                    dcts (list of dict):
+                        A list of dictionaries.
+
+                Returns:
+                    list of str or None:
+                        A list of hashtags.
+                """
+                return [dct.get("tag") for dct in dcts]
+
+            merged = (
+                user_df[["entities.description.hashtags"]]
+                .dropna()
+                .applymap(extract_hashtag)
+                .reset_index()
+                .rename(columns=dict(index="user_idx"))
+                .explode("entities.description.hashtags")
+                .merge(
+                    hashtag_df[["tag"]]
+                    .reset_index()
+                    .rename(columns=dict(index="tag_idx")),
+                    left_on="entities.description.hashtags",
+                    right_on="tag",
+                )
+            )
+            data_dict = dict(src=merged.user_idx.tolist(), tgt=merged.tag_idx.tolist())
+            return pd.DataFrame(data_dict)
+        else:
+            return pd.DataFrame()
+
+    def _extract_tweet_has_url_url(
+        self,
+        tweet_df: pd.DataFrame,
+        url_df: pd.DataFrame,
+        image_df: Optional[pd.DataFrame] = None,
+    ) -> pd.DataFrame:
+        """Extract (:Tweet)-[:HAS_URL]->(:Url) relation data.
+
+        Args:
+            tweet_df (pd.DataFrame):
+                A dataframe of tweets.
+            url_df (pd.DataFrame):
+                A dataframe of urls.
+            image_df (pd.DataFrame or None, optional):
+                A dataframe of images, or None if it is not available. Defaults
+                to None.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of relations.
+        """
+        urls_exist = (
+            "entities.urls" in tweet_df.columns
+            or "attachments.media_keys" in tweet_df.columns
+        )
+        include_images = self.include_tweet_images or self.include_extra_images
+        if (
+            (self.include_articles or include_images)
+            and urls_exist
+            and len(tweet_df)
+            and len(url_df)
+        ):
+
+            # Add the urls from the tweets themselves
+            def extract_url(dcts: List[dict]) -> List[Union[str, None]]:
+                """Extracts urls from a list of dictionaries.
+
+                Args:
+                    dcts (List[dict]):
+                        A list of dictionaries.
+
+                Returns:
+                    List[str]:
+                        A list of urls.
+                """
+                return [dct.get("expanded_url") or dct.get("url") for dct in dcts]
+
+            merged = (
+                tweet_df[["entities.urls"]]
+                .dropna()
+                .applymap(extract_url)
+                .reset_index()
+                .rename(columns=dict(index="tweet_idx"))
+                .explode("entities.urls")
+                .merge(
+                    url_df[["url"]].reset_index().rename(columns=dict(index="ul_idx")),
+                    left_on="entities.urls",
+                    right_on="url",
+                )
+            )
+            data_dict = dict(src=merged.tweet_idx.tolist(), tgt=merged.ul_idx.tolist())
+            rel_df = pd.DataFrame(data_dict)
+
+            # Append the urls from the images
+            if image_df is not None and len(image_df) and include_images:
+                merged = (
+                    tweet_df.reset_index()
+                    .rename(columns=dict(index="tweet_idx"))
+                    .explode("attachments.media_keys")
+                    .merge(
+                        image_df[["media_key", "url"]],
+                        left_on="attachments.media_keys",
+                        right_on="media_key",
+                    )
+                    .merge(
+                        url_df[["url"]]
+                        .reset_index()
+                        .rename(columns=dict(index="ul_idx")),
+                        on="url",
+                    )
+                )
+                data_dict = dict(
+                    src=merged.tweet_idx.tolist(), tgt=merged.ul_idx.tolist()
+                )
+                rel_df = pd.concat((rel_df, pd.DataFrame(data_dict))).drop_duplicates()
+
+            return rel_df
+
+    def _extract_user_has_url_url(
+        self, user_df: pd.DataFrame, url_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Extract (:User)-[:HAS_URL]->(:Url) relation data.
+
+        Args:
+            user_df (pd.DataFrame):
+                A dataframe of users.
+            url_df (pd.DataFrame):
+                A dataframe of urls.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of relations.
+        """
+        user_cols = user_df.columns
+        url_urls_exist = "entities.url.urls" in user_cols
+        desc_urls_exist = "entities.description.urls" in user_cols
+        if url_urls_exist or desc_urls_exist and len(user_df) and len(url_df):
+
+            def extract_url(dcts: List[dict]) -> List[Union[str, None]]:
+                """Extracts urls from a list of dictionaries.
+
+                Args:
+                    dcts (list of dict):
+                        A list of dictionaries.
+
+                Returns:
+                    list of str or None:
+                        A list of urls.
+                """
+
+                return [dct.get("expanded_url") or dct.get("url") for dct in dcts]
+
+            # Initialise empty relation, which will be populated below
+            rel_df = pd.DataFrame()
+
+            if url_urls_exist:
+                merged = (
+                    user_df[["entities.url.urls"]]
+                    .dropna()
+                    .applymap(extract_url)
+                    .reset_index()
+                    .rename(columns=dict(index="user_idx"))
+                    .explode("entities.url.urls")
+                    .merge(
+                        url_df[["url"]]
+                        .reset_index()
+                        .rename(columns=dict(index="ul_idx")),
+                        left_on="entities.url.urls",
+                        right_on="url",
+                    )
+                )
+                data_dict = dict(
+                    src=merged.user_idx.tolist(), tgt=merged.ul_idx.tolist()
+                )
+                rel_df = (
+                    pd.concat((rel_df, pd.DataFrame(data_dict)), axis=0)
+                    .drop_duplicates()
+                    .reset_index(drop=True)
+                )
+
+            if desc_urls_exist:
+                merged = (
+                    user_df[["entities.description.urls"]]
+                    .dropna()
+                    .applymap(extract_url)
+                    .reset_index()
+                    .rename(columns=dict(index="user_idx"))
+                    .explode("entities.description.urls")
+                    .merge(
+                        url_df[["url"]]
+                        .reset_index()
+                        .rename(columns=dict(index="ul_idx")),
+                        left_on="entities.description.urls",
+                        right_on="url",
+                    )
+                )
+                data_dict = dict(
+                    src=merged.user_idx.tolist(), tgt=merged.ul_idx.tolist()
+                )
+                rel_df = (
+                    pd.concat((rel_df, pd.DataFrame(data_dict)), axis=0)
+                    .drop_duplicates()
+                    .reset_index(drop=True)
+                )
+
+            return rel_df
+        else:
+            return pd.DataFrame()
+
+    def _extract_user_has_profile_picture_url_url(
+        self, user_df: pd.DataFrame, url_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Extract (:User)-[:HAS_PROFILE_PICTURE]->(:Url) relation data.
+
+        Args:
+            user_df (pd.DataFrame):
+                A dataframe of users.
+            url_df (pd.DataFrame):
+                A dataframe of urls.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of relations.
+        """
+        user_cols = user_df.columns
+        profile_images_exist = "profile_image_url" in user_cols
+        if (
+            self.include_extra_images
+            and profile_images_exist
+            and len(user_df)
+            and len(url_df)
+        ):
+            merged = (
+                user_df[["profile_image_url"]]
+                .dropna()
+                .reset_index()
+                .rename(columns=dict(index="user_idx"))
+                .merge(
+                    url_df[["url"]].reset_index().rename(columns=dict(index="ul_idx")),
+                    left_on="profile_image_url",
+                    right_on="url",
+                )
+            )
+            data_dict = dict(src=merged.user_idx.tolist(), tgt=merged.ul_idx.tolist())
+            return pd.DataFrame(data_dict)
+        else:
+            return pd.DataFrame()
+
+    def _extract_articles(self, url_df: pd.DataFrame) -> pd.DataFrame:
+        """Extract (:Article) nodes.
+
+        Args:
+            url_df (pd.DataFrame):
+                A dataframe of urls.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of articles.
+        """
+        if self.include_articles and len(url_df):
+            # Create regex that filters out non-articles. These are common
+            # images, videos and social media websites
+            non_article_regexs = [
+                "youtu[.]*be",
+                "vimeo",
+                "spotify",
+                "twitter",
+                "instagram",
+                "tiktok",
+                "gab[.]com",
+                "https://t[.]me",
+                "imgur",
+                "/photo/",
+                "mp4",
+                "mov",
+                "jpg",
+                "jpeg",
+                "bmp",
+                "png",
+                "gif",
+                "pdf",
+            ]
+            non_article_regex = "(" + "|".join(non_article_regexs) + ")"
+
+            # Filter out the URLs to get the potential article URLs
+            article_urls = [
+                url
+                for url in url_df.url.tolist()
+                if re.search(non_article_regex, url) is None
+            ]
+
+            # Loop over all the Url nodes
+            data_dict = defaultdict(list)
+            with mp.Pool(processes=self.n_jobs) as pool:
+                for result in tqdm(
+                    pool.imap_unordered(
+                        process_article_url, article_urls, chunksize=self.chunksize
+                    ),
+                    desc="Parsing articles",
+                    total=len(article_urls),
+                ):
+
+                    # Skip result if URL is not parseable
+                    if result is None:
+                        continue
+
+                    # Store the data in the data dictionary
+                    data_dict["url"].append(result["url"])
+                    data_dict["title"].append(result["title"])
+                    data_dict["content"].append(result["content"])
+                    data_dict["authors"].append(result["authors"])
+                    data_dict["publish_date"].append(result["publish_date"])
+                    data_dict["top_image_url"].append(result["top_image_url"])
+
+            # Convert the data dictionary to a dataframe and return it
+            return pd.DataFrame(data_dict)
+        else:
+            return pd.DataFrame()
+
+    def _extract_article_has_top_image_url_url(
+        self, article_df: pd.DataFrame, url_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Extract (:Article)-[:HAS_TOP_IMAGE_URL]->(:Url) relation data.
+
+        Args:
+            article_df (pd.DataFrame):
+                A dataframe of articles.
+            url_df (pd.DataFrame):
+                A dataframe of urls.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of relations.
+        """
+        if (
+            self.include_articles
+            and self.include_extra_images
+            and len(article_df)
+            and len(url_df)
+        ):
+
+            # Create relation
+            merged = (
+                article_df[["top_image_url"]]
+                .dropna()
+                .reset_index()
+                .rename(columns=dict(index="art_idx"))
+                .merge(
+                    url_df[["url"]].reset_index().rename(columns=dict(index="ul_idx")),
+                    left_on="top_image_url",
+                    right_on="url",
+                )
+            )
+            data_dict = dict(src=merged.art_idx.tolist(), tgt=merged.ul_idx.tolist())
+            return pd.DataFrame(data_dict)
+        else:
+            return pd.DataFrame()
+
+    def _extract_tweet_has_article_article(
+        self,
+        tweet_has_url_url_df: pd.DataFrame,
+        article_df: pd.DataFrame,
+        url_df: pd.DataFrame,
+    ) -> pd.DataFrame:
+        """Extract (:Tweet)-[:HAS_ARTICLE]->(:Article) relation data.
+
+        Args:
+            tweet_has_url_url_df (pd.DataFrame):
+                A dataframe of relations.
+            article_df (pd.DataFrame):
+                A dataframe of articles.
+            url_df (pd.DataFrame):
+                A dataframe of urls.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of relations.
+        """
+        if (
+            self.include_articles
+            and len(tweet_has_url_url_df)
+            and len(article_df)
+            and len(url_df)
+        ):
+            merged = (
+                tweet_has_url_url_df.rename(columns=dict(src="tweet_idx", tgt="ul_idx"))
+                .merge(
+                    url_df[["url"]].reset_index().rename(columns=dict(index="ul_idx")),
+                    on="ul_idx",
+                )
+                .merge(
+                    article_df[["url"]]
+                    .reset_index()
+                    .rename(columns=dict(index="art_idx")),
+                    on="url",
+                )
+            )
+            data_dict = dict(src=merged.tweet_idx.tolist(), tgt=merged.art_idx.tolist())
+            return pd.DataFrame(data_dict)
+        else:
+            return pd.DataFrame()
+
+    def _extract_images(
+        self, url_df: pd.DataFrame, article_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Extract (:Image) nodes.
+
+        Args:
+            url_df (pd.DataFrame):
+                A dataframe of urls.
+            article_df (pd.DataFrame):
+                A dataframe of articles.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of images.
+        """
+        if self.include_tweet_images or self.include_extra_images and len(url_df):
+
+            # If there are no articles then set `article_df` to have an empty `url`
+            # column
+            if not len(article_df):
+                article_df = pd.DataFrame(columns=["url"])
+
+            # Start with all the URLs that have not already been parsed as articles
+            image_urls = [
+                url for url in url_df.url.tolist() if url not in article_df.url.tolist()
+            ]
+
+            # Filter the resulting list of URLs using a hardcoded list of image formats
+            regex = "|".join(
+                [
+                    "png",
+                    "jpg",
+                    "jpeg",
+                    "bmp",
+                    "pdf",
+                    "jfif",
+                    "tiff",
+                    "ppm",
+                    "pgm",
+                    "pbm",
+                    "pnm",
+                    "webp",
+                    "hdr",
+                    "heif",
+                ]
+            )
+            image_urls = [
+                url for url in image_urls if re.search(regex, url) is not None
+            ]
+
+            # Loop over all the Url nodes
+            data_dict = defaultdict(list)
+            with mp.Pool(processes=self.n_jobs) as pool:
+                for result in tqdm(
+                    pool.imap_unordered(
+                        process_image_url, image_urls, chunksize=self.chunksize
+                    ),
+                    desc="Parsing images",
+                    total=len(image_urls),
+                ):
+
+                    # Store the data in the data dictionary if it was parseable
+                    if (
+                        result is not None
+                        and len(result["pixels"].shape) == 3
+                        and result["pixels"].shape[2] == 3
+                    ):
+                        data_dict["url"].append(result["url"])
+                        data_dict["pixels"].append(result["pixels"])
+                        data_dict["height"].append(result["height"])
+                        data_dict["width"].append(result["width"])
+
+            # Convert the data dictionary to a dataframe and store it as the `Image`
+            # node.
+            return pd.DataFrame(data_dict)
+        else:
+            return pd.DataFrame()
+
+    def _extract_tweet_has_image_image(
+        self,
+        tweet_has_url_url_df: pd.DataFrame,
+        url_df: pd.DataFrame,
+        image_df: pd.DataFrame,
+    ) -> pd.DataFrame:
+        """Extract (:Tweet)-[:HAS_IMAGE]->(:Image) relation data.
+
+        Args:
+            tweet_has_url_url_df (pd.DataFrame):
+                A dataframe of relations.
+            url_df (pd.DataFrame):
+                A dataframe of urls.
+            image_df (pd.DataFrame):
+                A dataframe of images.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of relations.
+        """
+        if (
+            len(tweet_has_url_url_df)
+            and len(url_df)
+            and len(image_df)
+            and self.include_tweet_images
+        ):
+            url_idx = dict(index="ul_idx")
+            img_idx = dict(index="im_idx")
+            if len(tweet_has_url_url_df):
+                merged = (
+                    tweet_has_url_url_df.rename(
+                        columns=dict(src="tweet_idx", tgt="ul_idx")
+                    )
+                    .merge(
+                        url_df[["url"]].reset_index().rename(columns=url_idx),
+                        on="ul_idx",
+                    )
+                    .merge(
+                        image_df[["url"]].reset_index().rename(columns=img_idx),
+                        on="url",
+                    )
+                )
+                data_dict = dict(
+                    src=merged.tweet_idx.tolist(), tgt=merged.im_idx.tolist()
+                )
+                return pd.DataFrame(data_dict)
+            else:
+                return pd.DataFrame()
+
+    def _extract_article_has_top_image_image(
+        self,
+        article_has_top_image_url_url_df: pd.DataFrame,
+        url_df: pd.DataFrame,
+        image_df: pd.DataFrame,
+    ) -> pd.DataFrame:
+        """Extract (:Article)-[:HAS_TOP_IMAGE]->(:Image) relation data.
+
+        Args:
+            article_has_top_image_url_url_df (pd.DataFrame):
+                A dataframe of relations.
+            url_df (pd.DataFrame):
+                A dataframe of urls.
+            image_df (pd.DataFrame):
+                A dataframe of images.
+
+        Returns:
+            pd.DataFrame: A dataframe of relations.
+        """
+        if (
+            self.include_articles
+            and self.include_extra_images
+            and len(article_has_top_image_url_url_df)
+            and len(url_df)
+            and len(image_df)
+        ):
+            url_idx = dict(index="ul_idx")
+            img_idx = dict(index="im_idx")
+            if self.include_articles:
+                merged = (
+                    article_has_top_image_url_url_df.rename(
+                        columns=dict(src="art_idx", tgt="ul_idx")
+                    )
+                    .merge(
+                        url_df[["url"]].reset_index().rename(columns=url_idx),
+                        on="ul_idx",
+                    )
+                    .merge(
+                        image_df[["url"]].reset_index().rename(columns=img_idx),
+                        on="url",
+                    )
+                )
+                data_dict = dict(
+                    src=merged.art_idx.tolist(), tgt=merged.im_idx.tolist()
+                )
+                return pd.DataFrame(data_dict)
+        else:
+            return pd.DataFrame()
+
+    def _extract_user_has_profile_picture_image(
+        self,
+        user_has_profile_picture_url_url_df: pd.DataFrame,
+        url_df: pd.DataFrame,
+        image_df: pd.DataFrame,
+    ) -> pd.DataFrame:
+        """Extract (:User)-[:HAS_PROFILE_PICTURE]->(:Image) relation data.
+
+        Args:
+            user_has_profile_picture_url_url_df (pd.DataFrame):
+                A dataframe of relations.
+            url_df (pd.DataFrame):
+                A dataframe of urls.
+            image_df (pd.DataFrame):
+                A dataframe of images.
+
+        Returns:
+            pd.DataFrame: A dataframe of relations.
+        """
+        if (
+            self.include_extra_images
+            and len(image_df)
+            and len(url_df)
+            and len(user_has_profile_picture_url_url_df)
+        ):
+            merged = (
+                user_has_profile_picture_url_url_df.rename(
+                    columns=dict(src="user_idx", tgt="ul_idx")
+                )
+                .merge(
+                    url_df[["url"]].reset_index().rename(columns=dict(index="ul_idx")),
+                    on="ul_idx",
+                )
+                .merge(
+                    image_df[["url"]]
+                    .reset_index()
+                    .rename(columns=dict(index="im_idx")),
+                    on="url",
+                )
+            )
+            data_dict = dict(src=merged.user_idx.tolist(), tgt=merged.im_idx.tolist())
+            return pd.DataFrame(data_dict)
+        else:
+            return pd.DataFrame()
+
+    def _extract_hashtags(
+        self, tweet_df: pd.DataFrame, user_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Extract (:Hashtag) node data.
+
+        Args:
+            tweet_df (pd.DataFrame):
+                A dataframe of tweets.
+            user_df (pd.DataFrame):
+                A dataframe of users.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe of hashtags.
+        """
+        if self.include_hashtags and len(tweet_df) and len(user_df):
+
+            # Initialise the hashtag dataframe
+            hashtag_df = pd.DataFrame()
+
+            def extract_hashtag(dcts: List[dict]) -> List[Union[str, None]]:
+                """Extracts hashtags from a list of dictionaries.
+
+                Args:
+                    dcts (list of dict):
+                        A list of dictionaries.
+
+                Returns:
+                    list of str or None:
+                        A list of hashtags.
+                """
+                return [dct.get("tag") for dct in dcts]
+
+            # Add hashtags from tweets
+            if "entities.hashtags" in tweet_df.columns:
+                hashtags = (
+                    tweet_df["entities.hashtags"]
+                    .dropna()
+                    .map(extract_hashtag)
+                    .explode()
+                    .tolist()
+                )
+                hashtag_dict = pd.DataFrame(dict(tag=hashtags))
+                hashtag_df = (
+                    pd.concat((hashtag_df, pd.DataFrame(hashtag_dict)), axis=0)
+                    .drop_duplicates()
+                    .reset_index(drop=True)
+                )
+
+            # Add hashtags from users
+            if "entities.description.hashtags" in user_df.columns:
+                hashtags = (
+                    user_df["entities.description.hashtags"]
+                    .dropna()
+                    .map(extract_hashtag)
+                    .explode()
+                    .tolist()
+                )
+                hashtag_dict = pd.DataFrame(dict(tag=hashtags))
+                hashtag_df = (
+                    pd.concat((hashtag_df, pd.DataFrame(hashtag_dict)), axis=0)
+                    .drop_duplicates()
+                    .reset_index(drop=True)
+                )
+
+            return hashtag_df
+        else:
+            return pd.DataFrame()
+
+    def _extract_urls(
+        self,
+        tweet_dicusses_claim_df: pd.DataFrame,
+        user_posted_tweet_df: pd.DataFrame,
+        user_df: pd.DataFrame,
+        tweet_df: pd.DataFrame,
+        article_df: Optional[pd.DataFrame] = None,
+        image_df: Optional[pd.DataFrame] = None,
+    ) -> pd.DataFrame:
+        """Extract (:Url) node data.
+
+        Note that this does not extract the top image urls from the articles.
+        This will be added with the _update_urls_from_articles method, after
+        the articles have been extracted.
+
+        Args:
+            tweet_dicusses_claim_df (pd.DataFrame):
+                A dataframe of tweet_dicusses_claim nodes.
+            user_posted_tweet_df (pd.DataFrame):
+                A dataframe of user_posted_tweet nodes.
+            user_df (pd.DataFrame):
+                A dataframe of user nodes.
+            tweet_df (pd.DataFrame):
+                A dataframe of tweet nodes.
+            article_df (pd.DataFrame or None, optional):
+                A dataframe of article nodes, of None if no articles are
+                available. Defaults to None.
+            image_df (pd.DataFrame, or None, optional):
+                A dataframe of image nodes, or None if no images are available.
+                Defaults to None.
+
+        Returns:
+            pd.DataFrame: A dataframe of url nodes.
+        """
+        if (
+            len(tweet_dicusses_claim_df) == 0
+            or len(user_df) == 0
+            or len(tweet_df) == 0
+            or len(user_posted_tweet_df) == 0
+        ):
+            return pd.DataFrame()
+
+        # Define dataframe with the source tweets
+        is_src = tweet_df.index.isin(tweet_dicusses_claim_df.src.tolist())
+        src_tweets = tweet_df[is_src]
+
+        # Define dataframe with the source users
+        posted_rel = user_posted_tweet_df
+        is_src = posted_rel[posted_rel.tgt.isin(src_tweets.index.tolist())].src.tolist()
+        src_users = user_df.loc[is_src]
+
+        # Initialise empty URL dataframe
+        url_df = pd.DataFrame()
+
+        # Add urls from source tweets
+        if "entities.urls" in tweet_df.columns:
+
+            def extract_url(dcts: List[dict]) -> List[Union[str, None]]:
+                """Extracts urls from a list of dictionaries.
+
+                Args:
+                    dcts (List[dict]):
+                        A list of dictionaries.
+
+                Returns:
+                    List[Union[str, None]]:
+                        A list of urls.
+                """
+                return [dct.get("expanded_url") or dct.get("url") for dct in dcts]
+
+            urls = (
+                src_tweets["entities.urls"].dropna().map(extract_url).explode().tolist()
+            )
+            url_dict = pd.DataFrame(dict(url=urls))
+            url_df = (
+                pd.concat((url_df, pd.DataFrame(url_dict)), axis=0)
+                .drop_duplicates()
+                .reset_index(drop=True)
+            )
+
+        # Add urls from source user urls
+        if "entities.url.urls" in user_df.columns:
+
+            def extract_url(dcts: List[dict]) -> List[Union[str, None]]:
+                """Extracts urls from a list of dictionaries.
+
+                Args:
+                    dcts (List[dict]):
+                        A list of dictionaries.
+
+                Returns:
+                    List[Union[str, None]]:
+                        A list of urls.
+                """
+                return [dct.get("expanded_url") or dct.get("url") for dct in dcts]
+
+            urls = (
+                src_users["entities.url.urls"]
+                .dropna()
+                .map(extract_url)
+                .explode()
+                .tolist()
+            )
+            url_dict = pd.DataFrame(dict(url=urls))
+            url_df = (
+                pd.concat((url_df, pd.DataFrame(url_dict)), axis=0)
+                .drop_duplicates()
+                .reset_index(drop=True)
+            )
+
+        # Add urls from source user descriptions
+        if "entities.description.urls" in user_df.columns:
+
+            def extract_url(dcts: List[dict]) -> List[Union[str, None]]:
+                """Extracts urls from a list of dictionaries.
+
+                Args:
+                    dcts (List[dict]):
+                        A list of dictionaries.
+
+                Returns:
+                    List[Union[str, None]]:
+                        A list of urls.
+                """
+                return [dct.get("expanded_url") or dct.get("url") for dct in dcts]
+
+            urls = (
+                src_users["entities.description.urls"]
+                .dropna()
+                .map(extract_url)
+                .explode()
+                .tolist()
+            )
+            url_dict = pd.DataFrame(dict(url=urls))
+            url_df = (
+                pd.concat((url_df, pd.DataFrame(url_dict)), axis=0)
+                .drop_duplicates()
+                .reset_index(drop=True)
+            )
+
+        # Add urls from images
+        if (
+            image_df is not None
+            and len(image_df)
+            and self.include_tweet_images
+            and "attachments.media_keys" in tweet_df.columns
+        ):
+            urls = (
+                src_tweets[["attachments.media_keys"]]
+                .dropna()
+                .explode("attachments.media_keys")
+                .merge(
+                    image_df[["media_key", "url"]],
+                    left_on="attachments.media_keys",
+                    right_on="media_key",
+                )
+                .url.tolist()
+            )
+            url_dict = pd.DataFrame(dict(url=urls))
+            url_df = (
+                pd.concat((url_df, pd.DataFrame(url_dict)), axis=0)
+                .drop_duplicates()
+                .reset_index(drop=True)
+            )
+
+        # Add urls from profile pictures
+        if self.include_extra_images and "profile_image_url" in user_df.columns:
+
+            def extract_url(dcts: List[dict]) -> List[Union[str, None]]:
+                """Extracts urls from a list of dictionaries.
+
+                Args:
+                    dcts (List[dict]):
+                        A list of dictionaries.
+
+                Returns:
+                    List[Union[str, None]]:
+                        A list of urls.
+                """
+                return [dct.get("expanded_url") or dct.get("url") for dct in dcts]
+
+            urls = src_users["profile_image_url"].dropna().tolist()
+            url_dict = pd.DataFrame(dict(url=urls))
+            url_df = (
+                pd.concat((url_df, pd.DataFrame(url_dict)), axis=0)
+                .drop_duplicates()
+                .reset_index(drop=True)
+            )
+
+        # Add urls from articles
+        if article_df is not None and len(article_df) and self.include_articles:
+            urls = article_df.url.dropna().tolist()
+            url_dict = pd.DataFrame(dict(url=urls))
+            url_df = (
+                pd.concat((url_df, pd.DataFrame(url_dict)), axis=0)
+                .drop_duplicates()
+                .reset_index(drop=True)
+            )
+
+        return url_df
+
+    def _update_urls_from_articles(
+        self, url_df: pd.DataFrame, article_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Updates the url_df with the urls from the articles.
+
+        Args:
+            url_df (pd.DataFrame):
+                A dataframe with the urls.
+            article_df (pd.DataFrame):
+                A dataframe with the articles.
+
+        Returns:
+            pd.DataFrame:
+                A dataframe with the urls.
+        """
+        if self.include_extra_images and len(article_df) and len(url_df):
+            urls = article_df.top_image_url.dropna().tolist()
+            url_dict = pd.DataFrame(dict(url=urls))
+            url_df = (
+                pd.concat((url_df, pd.DataFrame(url_dict)), axis=0)
+                .drop_duplicates()
+                .reset_index(drop=True)
+            )
+        return url_df

src/mumin/dataset.py

@@ -0,0 +1,1152 @@
+"""Script containing the main dataset class"""
+
+import io
+import logging
+import multiprocessing as mp
+import os
+import warnings
+import zipfile
+from functools import partial
+from pathlib import Path
+from shutil import rmtree
+from typing import Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import pandas as pd
+import requests
+from dotenv import load_dotenv
+from tqdm.auto import tqdm
+
+from .data_extractor import DataExtractor
+from .dgl import build_dgl_dataset
+from .embedder import Embedder
+from .id_updator import IdUpdator
+from .twitter import Twitter
+
+# Load environment variables
+load_dotenv()
+
+
+# Set up logging
+logger = logging.getLogger(__name__)
+
+
+# Disable tokenizer parallelism
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+
+# Prevents crashes during data extraction on MacOS
+os.environ["OBJC_DISABLE_INITIALIZE_FORK_SAFETY"] = "YES"
+
+
+# Allows progress bars with `pd.DataFrame.progress_apply`
+tqdm.pandas()
+
+
+class MuminDataset:
+    """The MuMiN misinformation dataset, from [1].
+
+    Args:
+        twitter_bearer_token (str or None, optional):
+            The Twitter bearer token. If None then the the bearer token must be stored
+            in the environment variable `TWITTER_API_KEY`, or placed in a file named
+            `.env` in the working directory, formatted as "TWITTER_API_KEY=xxxxx".
+            Defaults to None.
+        size (str, optional):
+            The size of the dataset. Can be either 'small', 'medium' or 'large'.
+            Defaults to 'small'.
+        include_replies (bool, optional):
+            Whether to include replies and quote tweets in the dataset. Defaults to
+            True.
+        include_articles (bool, optional):
+            Whether to include articles in the dataset. This will mean that compilation
+            of the dataset will take a bit longer, as these need to be downloaded and
+            parsed. Defaults to True.
+        include_tweet_images (bool, optional):
+            Whether to include images from the tweets in the dataset. This will mean
+            that compilation of the dataset will take a bit longer, as these need to be
+            downloaded and parsed. Defaults to True.
+        include_extra_images (bool, optional):
+            Whether to include images from the articles and users in the dataset. This
+            will mean that compilation of the dataset will take a bit longer, as these
+            need to be downloaded and parsed. Defaults to False.
+        include_hashtags (bool, optional):
+            Whether to include hashtags in the dataset. Defaults to True.
+        include_mentions (bool, optional):
+            Whether to include mentions in the dataset. Defaults to True.
+        include_timelines (bool, optional):
+            Whether to include timelines in the dataset. Defaults to False.
+        text_embedding_model_id (str, optional):
+            The HuggingFace Hub model ID to use when embedding texts. Defaults to
+            'xlm-roberta-base'.
+        image_embedding_model_id (str, optional):
+            The HuggingFace Hub model ID to use when embedding images. Defaults to
+            'google/vit-base-patch16-224-in21k'.
+        dataset_path (str, pathlib Path or None, optional):
+            The path to the file where the dataset should be stored. If None then the
+            dataset will be stored at './mumin-<size>.zip'. Defaults to None.
+        n_jobs (int, optional):
+            The number of jobs to use for parallel processing. Defaults to the number
+            of available CPU cores minus one.
+        chunksize (int, optional):
+            The number of articles/images to process in each job. This speeds up
+            processing time, but also increases memory load. Defaults to 10.
+        verbose (bool, optional):
+            Whether extra information should be outputted. Defaults to True.
+
+    Attributes:
+        include_replies (bool): Whether to include replies.
+        include_articles (bool): Whether to include articles.
+        include_tweet_images (bool): Whether to include tweet images.
+        include_extra_images (bool): Whether to include user/article images.
+        include_hashtags (bool): Whether to include hashtags.
+        include_mentions (bool): Whether to include mentions.
+        include_timelines (bool): Whether to include timelines.
+        size (str): The size of the dataset.
+        dataset_path (pathlib Path): The dataset file.
+        text_embedding_model_id (str): The model ID used for embedding text.
+        image_embedding_model_id (str): The model ID used for embedding images.
+        nodes (dict): The nodes of the dataset.
+        rels (dict): The relations of the dataset.
+        rehydrated (bool): Whether the tweets and/or replies have been rehydrated.
+        compiled (bool): Whether the dataset has been compiled.
+        n_jobs (int): The number of jobs to use for parallel processing.
+        chunksize (int): The number of articles/images to process in each job.
+        verbose (bool): Whether extra information should be outputted.
+        download_url (str): The URL to download the dataset from.
+
+    Raises:
+        ValueError:
+            If `twitter_bearer_token` is None and the environment variable
+            `TWITTER_API_KEY` is not set.
+
+    References:
+        - [1] Nielsen and McConville: MuMiN: A Large-Scale Multilingual Multimodal
+              Fact-Checked Misinformation Dataset with Linked Social Network Posts
+              (2021)
+    """
+
+    download_url: str = (
+        "https://data.bris.ac.uk/datasets/23yv276we2mll25f"
+        "jakkfim2ml/23yv276we2mll25fjakkfim2ml.zip"
+    )
+    _node_dump: List[str] = [
+        "claim",
+        "tweet",
+        "user",
+        "image",
+        "article",
+        "hashtag",
+        "reply",
+    ]
+    _rel_dump: List[Tuple[str, str, str]] = [
+        ("tweet", "discusses", "claim"),
+        ("tweet", "mentions", "user"),
+        ("tweet", "has_image", "image"),
+        ("tweet", "has_hashtag", "hashtag"),
+        ("tweet", "has_article", "article"),
+        ("reply", "reply_to", "tweet"),
+        ("reply", "quote_of", "tweet"),
+        ("user", "posted", "tweet"),
+        ("user", "posted", "reply"),
+        ("user", "mentions", "user"),
+        ("user", "has_hashtag", "hashtag"),
+        ("user", "has_profile_picture", "image"),
+        ("user", "retweeted", "tweet"),
+        ("user", "follows", "user"),
+        ("article", "has_top_image", "image"),
+    ]
+
+    def __init__(
+        self,
+        twitter_bearer_token: Optional[str] = None,
+        size: str = "small",
+        include_replies: bool = True,
+        include_articles: bool = True,
+        include_tweet_images: bool = True,
+        include_extra_images: bool = False,
+        include_hashtags: bool = True,
+        include_mentions: bool = True,
+        include_timelines: bool = False,
+        text_embedding_model_id: str = "xlm-roberta-base",
+        image_embedding_model_id: str = "google/vit-base-patch16-224-in21k",
+        dataset_path: Optional[Union[str, Path]] = None,
+        n_jobs: int = mp.cpu_count() - 1,
+        chunksize: int = 10,
+        verbose: bool = True,
+    ):
+        self.size = size
+        self.include_replies = include_replies
+        self.include_articles = include_articles
+        self.include_tweet_images = include_tweet_images
+        self.include_extra_images = include_extra_images
+        self.include_hashtags = include_hashtags
+        self.include_mentions = include_mentions
+        self.include_timelines = include_timelines
+        self.text_embedding_model_id = text_embedding_model_id
+        self.image_embedding_model_id = image_embedding_model_id
+        self.verbose = verbose
+
+        self.compiled: bool = False
+        self.rehydrated: bool = False
+        self.nodes: Dict[str, pd.DataFrame] = dict()
+        self.rels: Dict[Tuple[str, str, str], pd.DataFrame] = dict()
+
+        # Load the bearer token if it is not provided
+        if twitter_bearer_token is None:
+            twitter_bearer_token = os.environ.get("TWITTER_API_KEY")
+
+        # If no bearer token is available, raise a warning and set the `_twitter`
+        # attribute to None. Otherwise, set the `_twitter` attribute to a `Twitter`
+        # instance.
+        self._twitter: Twitter
+        if twitter_bearer_token is None:
+            warnings.warn(
+                "Twitter bearer token not provided, so rehydration can not be "
+                "performed. This is fine if you are using a pre-compiled MuMiN, but "
+                "if this is not the case then you will need to either specify the "
+                "`twitter_bearer_token` argument or set the environment variable "
+                "`TWITTER_API_KEY`."
+            )
+        else:
+            self._twitter = Twitter(twitter_bearer_token=twitter_bearer_token)
+
+        self._extractor = DataExtractor(
+            include_replies=include_replies,
+            include_articles=include_articles,
+            include_tweet_images=include_tweet_images,
+            include_extra_images=include_extra_images,
+            include_hashtags=include_hashtags,
+            include_mentions=include_mentions,
+            n_jobs=n_jobs,
+            chunksize=chunksize,
+        )
+        self._updator = IdUpdator()
+        self._embedder = Embedder(
+            text_embedding_model_id=text_embedding_model_id,
+            image_embedding_model_id=image_embedding_model_id,
+            include_articles=include_articles,
+            include_tweet_images=include_tweet_images,
+            include_extra_images=include_extra_images,
+        )
+
+        if dataset_path is None:
+            dataset_path = f"./mumin-{size}.zip"
+        self.dataset_path = Path(dataset_path)
+
+        # Set up logging verbosity
+        if self.verbose:
+            logger.setLevel(logging.INFO)
+        else:
+            logger.setLevel(logging.WARNING)
+
+    def compile(self, overwrite: bool = False):
+        """Compiles the dataset.
+
+        This entails downloading the dataset, rehydrating the Twitter data and
+        downloading the relevant associated data, such as articles and images.
+
+        Args:
+            overwrite (bool, optional):
+                Whether the dataset directory should be overwritten, in case it already
+                exists. Defaults to False.
+
+        Raises:
+            RuntimeError:
+                If the dataset needs to be compiled and a Twitter bearer token has not
+                been provided.
+        """
+        self._download(overwrite=overwrite)
+        self._load_dataset()
+
+        # Variable to check if dataset has been rehydrated and/or compiled
+        if "text" in self.nodes["tweet"].columns:
+            self.rehydrated = True
+        if self.rehydrated and str(self.nodes["tweet"].tweet_id.dtype) == "uint64":
+            self.compiled = True
+
+        # Only compile the dataset if it has not already been compiled
+        if not self.compiled:
+
+            # If the dataset has not already been rehydrated, rehydrate it
+            if not self.rehydrated:
+
+                # Shrink dataset to the correct size
+                self._shrink_dataset()
+
+                # If the bearer token is not available then raise an error
+                if not isinstance(self._twitter, Twitter):
+                    raise RuntimeError(
+                        "Twitter bearer token not provided. You need to either specify "
+                        "the `twitter_bearer_token` argument in the `MuminDataset` "
+                        "constructor or set the environment variable `TWITTER_API_KEY`."
+                    )
+
+                # Rehydrate the tweets
+                self._rehydrate(node_type="tweet")
+                self._rehydrate(node_type="reply")
+
+                # Update the IDs of the data that was there pre-hydration
+                self.nodes, self.rels = self._updator.update_all(
+                    nodes=self.nodes, rels=self.rels
+                )
+
+                # Save dataset
+                self._dump_dataset()
+
+                # Set the rehydrated flag to True
+                self.rehydrated = True
+
+            # Extract data from the rehydrated tweets
+            self.nodes, self.rels = self._extractor.extract_all(
+                nodes=self.nodes, rels=self.rels
+            )
+
+            # Filter the data
+            self._filter_node_features()
+            self._filter_relations()
+
+            # Set datatypes
+            self._set_datatypes()
+
+        # Remove unnecessary bits
+        self._remove_auxilliaries()
+        self._remove_islands()
+
+        # Save dataset
+        if not self.compiled:
+            self._dump_dataset()
+
+        # Mark dataset as compiled
+        self.compiled = True
+
+        return self
+
+    def _download(self, overwrite: bool = False):
+        """Downloads the dataset.
+
+        Args:
+            overwrite (bool, optional):
+                Whether the dataset directory should be overwritten, in case it already
+                exists. Defaults to False.
+        """
+        if not self.dataset_path.exists() or (self.dataset_path.exists() and overwrite):
+
+            logger.info("Downloading dataset")
+
+            # Remove existing directory if we are overwriting
+            if self.dataset_path.exists() and overwrite:
+                self.dataset_path.unlink()
+
+            # Set up download stream of dataset
+            with requests.get(self.download_url, stream=True) as response:
+
+                # If the response was unsuccessful then raise an error
+                if response.status_code != 200:
+                    raise RuntimeError(f"[{response.status_code}] {response.content!r}")
+
+                # Download dataset with progress bar
+                total = int(response.headers["Content-Length"])
+                with tqdm(
+                    total=total, unit="iB", unit_scale=True, desc="Downloading MuMiN"
+                ) as pbar:
+                    with Path(self.dataset_path).open("wb") as f:
+                        for data in response.iter_content(1024):
+                            pbar.update(len(data))
+                            f.write(data)
+
+                # The data.bris zip file contains two files: `mumin.zip` and
+                # `readme.txt`. We only want the first one, so we extract that and
+                # replace the original file with it.
+                with zipfile.ZipFile(
+                    self.dataset_path, mode="r", compression=zipfile.ZIP_DEFLATED
+                ) as zipf:
+                    zipdata = zipf.read("23yv276we2mll25fjakkfim2ml/mumin.zip")
+                with Path(self.dataset_path).open("wb") as f:
+                    f.write(zipdata)
+
+            logger.info("Converting dataset to less compressed format")
+
+            # Open the zip file containing the dataset
+            data_dict = dict()
+            with zipfile.ZipFile(
+                self.dataset_path, mode="r", compression=zipfile.ZIP_DEFLATED
+            ) as zip_file:
+
+                # Loop over all the files in the zipped file
+                for name in zip_file.namelist():
+
+                    # Extract the dataframe in the file
+                    byte_data = zip_file.read(name=name)
+                    df = pd.read_pickle(io.BytesIO(byte_data), compression="xz")
+                    data_dict[name] = df
+
+            # Overwrite the zip file in a less compressed way, to make io operations
+            # faster
+            with zipfile.ZipFile(
+                self.dataset_path, mode="w", compression=zipfile.ZIP_STORED
+            ) as zip_file:
+                for name, df in data_dict.items():
+                    buffer = io.BytesIO()
+                    df.to_pickle(buffer, protocol=4)
+                    zip_file.writestr(name, data=buffer.getvalue())
+
+        return self
+
+    def _load_dataset(self):
+        """Loads the dataset files into memory.
+
+        Raises:
+            RuntimeError:
+                If the dataset has not been downloaded yet.
+        """
+        # Raise error if the dataset has not been downloaded yet
+        if not self.dataset_path.exists():
+            raise RuntimeError("Dataset has not been downloaded yet!")
+
+        logger.info("Loading dataset")
+
+        # Reset `nodes` and `relations` to ensure a fresh start
+        self.nodes = dict()
+        self.rels = dict()
+
+        # Open the zip file containing the dataset
+        with zipfile.ZipFile(
+            self.dataset_path, mode="r", compression=zipfile.ZIP_STORED
+        ) as zip_file:
+
+            # Loop over all the files in the zipped file
+            for name in zip_file.namelist():
+
+                # Extract the dataframe in the file
+                byte_data = zip_file.read(name=name)
+                df = pd.read_pickle(io.BytesIO(byte_data))
+
+                # If there are no underscores in the filename then we assume that it
+                # contains node data
+                if "_" not in name:
+                    self.nodes[name.replace(".pickle", "")] = df.copy()
+
+                # Otherwise, with underscores in the filename then we assume it
+                # contains relation data
+                else:
+                    splits = name.replace(".pickle", "").split("_")
+                    src = splits[0]
+                    tgt = splits[-1]
+                    rel = "_".join(splits[1:-1])
+                    self.rels[(src, rel, tgt)] = df.copy()
+
+            # Ensure that claims are present in the dataset
+            if "claim" not in self.nodes.keys():
+                raise RuntimeError("No claims are present in the file!")
+
+            # Ensure that tweets are present in the dataset, and also that the tweet
+            # IDs are unique
+            if "tweet" not in self.nodes.keys():
+                raise RuntimeError("No tweets are present in the file!")
+            else:
+                tweet_df = self.nodes["tweet"]
+                duplicated = tweet_df[tweet_df.tweet_id.duplicated()].tweet_id.tolist()
+                if len(duplicated) > 0:
+                    raise RuntimeError(
+                        f"The tweet IDs {duplicated} are " f"duplicate in the dataset!"
+                    )
+
+        return self
+
+    def _shrink_dataset(self):
+        """Shrink dataset if `size` is 'small' or 'medium"""
+        logger.info("Shrinking dataset")
+
+        # Define the `relevance` threshold
+        if self.size == "small":
+            threshold = 0.80  # noqa
+        elif self.size == "medium":
+            threshold = 0.75  # noqa
+        elif self.size == "large":
+            threshold = 0.70  # noqa
+        elif self.size == "test":
+            threshold = 0.995  # noqa
+
+        # Filter nodes
+        ntypes = ["tweet", "reply", "user", "article"]
+        for ntype in ntypes:
+            self.nodes[ntype] = (
+                self.nodes[ntype]
+                .query("relevance > @threshold")
+                .drop(columns=["relevance"])
+                .reset_index(drop=True)
+            )
+
+        # Filter relations
+        etypes = [
+            ("reply", "reply_to", "tweet"),
+            ("reply", "quote_of", "tweet"),
+            ("user", "retweeted", "tweet"),
+            ("user", "follows", "user"),
+            ("tweet", "discusses", "claim"),
+            ("article", "discusses", "claim"),
+        ]
+        for etype in etypes:
+            self.rels[etype] = (
+                self.rels[etype]
+                .query("relevance > @threshold")
+                .drop(columns=["relevance"])
+                .reset_index(drop=True)
+            )
+
+        # Filter claims
+        claim_df = self.nodes["claim"]
+        discusses_rel = self.rels[("tweet", "discusses", "claim")]
+        include_claim = claim_df.id.isin(discusses_rel.tgt.tolist())
+        self.nodes["claim"] = claim_df[include_claim].reset_index(drop=True)
+
+        # Filter timeline tweets
+        if not self.include_timelines:
+            src_tweet_ids = (
+                self.rels[("tweet", "discusses", "claim")]
+                .src.astype(np.uint64)
+                .tolist()
+            )
+            is_src = self.nodes["tweet"].tweet_id.isin(src_tweet_ids)
+            self.nodes["tweet"] = self.nodes["tweet"].loc[is_src]
+
+        return self
+
+    def _rehydrate(self, node_type: str):
+        """Rehydrate the tweets and users in the dataset.
+
+        Args:
+            node_type (str): The type of node to rehydrate.
+        """
+
+        if node_type in self.nodes.keys() and (
+            node_type != "reply" or self.include_replies
+        ):
+
+            logger.info(f"Rehydrating {node_type} nodes")
+
+            # Get the tweet IDs, and if the node type is a tweet then separate these
+            # into source tweets and the rest (i.e., timeline tweets)
+            if node_type == "tweet":
+                source_tweet_ids = (
+                    self.rels[("tweet", "discusses", "claim")]
+                    .src.astype(np.uint64)
+                    .tolist()
+                )
+                tweet_ids = [
+                    tweet_id
+                    for tweet_id in self.nodes[node_type].tweet_id.astype(np.uint64)
+                    if tweet_id not in source_tweet_ids
+                ]
+            else:
+                source_tweet_ids = list()
+                tweet_ids = self.nodes[node_type].tweet_id.astype(np.uint64).tolist()
+
+            # Store any features the nodes might have had before hydration
+            prehydration_df = self.nodes[node_type].copy()
+
+            # Rehydrate the source tweets
+            if len(source_tweet_ids) > 0:
+                params = dict(tweet_ids=source_tweet_ids)
+                source_tweet_dfs = self._twitter.rehydrate_tweets(**params)
+
+                # Return error if there are no tweets were rehydrated. This is probably
+                # because the bearer token is wrong
+                if len(source_tweet_dfs) == 0:
+                    raise RuntimeError(
+                        "No tweets were rehydrated. Check if the bearer token is "
+                        "correct."
+                    )
+
+                if len(tweet_ids) == 0:
+                    tweet_dfs = {key: pd.DataFrame() for key in source_tweet_dfs.keys()}
+
+            # Rehydrate the other tweets
+            if len(tweet_ids) > 0:
+                params = dict(tweet_ids=tweet_ids)
+                tweet_dfs = self._twitter.rehydrate_tweets(**params)
+
+                # Return error if there are no tweets were rehydrated. This is
+                # probably because the bearer token is wrong
+                if len(tweet_dfs) == 0:
+                    raise RuntimeError(
+                        "No tweets were rehydrated. Check if "
+                        "the bearer token is correct."
+                    )
+
+                if len(source_tweet_ids) == 0:
+                    source_tweet_dfs = {key: pd.DataFrame() for key in tweet_dfs.keys()}
+
+            # Extract and store tweets and users
+            tweet_df = pd.concat(
+                [source_tweet_dfs["tweets"], tweet_dfs["tweets"]], ignore_index=True
+            )
+            self.nodes[node_type] = tweet_df.drop_duplicates(
+                subset="tweet_id"
+            ).reset_index(drop=True)
+            user_df = pd.concat(
+                [source_tweet_dfs["users"], tweet_dfs["users"]], ignore_index=True
+            )
+            if "user" in self.nodes.keys() and "username" in self.nodes["user"].columns:
+                user_df = (
+                    pd.concat((self.nodes["user"], user_df), axis=0)
+                    .drop_duplicates(subset="user_id")
+                    .reset_index(drop=True)
+                )
+            self.nodes["user"] = user_df
+
+            # Add prehydration tweet features back to the tweets
+            self.nodes[node_type] = (
+                self.nodes[node_type]
+                .merge(prehydration_df, on="tweet_id", how="outer")
+                .reset_index(drop=True)
+            )
+
+            # Extract and store images
+            # Note: This will store `self.nodes['image']`, but this is only to enable
+            #       extraction of URLs later on. The `self.nodes['image']` will be
+            #       overwritten later on.
+            if (
+                node_type == "tweet"
+                and self.include_tweet_images
+                and len(source_tweet_dfs["media"])
+            ):
+
+                image_df = (
+                    source_tweet_dfs["media"]
+                    .query('type == "photo"')
+                    .drop_duplicates(subset="media_key")
+                    .reset_index(drop=True)
+                )
+
+                if "image" in self.nodes.keys():
+                    image_df = (
+                        pd.concat((self.nodes["image"], image_df), axis=0)
+                        .drop_duplicates(subset="media_key")
+                        .reset_index(drop=True)
+                    )
+
+                self.nodes["image"] = image_df
+
+        return self
+
+    def add_embeddings(
+        self,
+        nodes_to_embed: List[str] = [
+            "tweet",
+            "reply",
+            "user",
+            "claim",
+            "article",
+            "image",
+        ],
+    ):
+        """Computes, stores and dumps embeddings of node features.
+
+        Args:
+            nodes_to_embed (list of str):
+                The node types which needs to be embedded. If a node type does not
+                exist in the graph it will be ignored. Defaults to ['tweet', 'reply',
+                'user', 'claim', 'article', 'image'].
+        """
+        # Compute the embeddings
+        self.nodes, embeddings_added = self._embedder.embed_all(
+            nodes=self.nodes, nodes_to_embed=nodes_to_embed
+        )
+
+        # Store dataset if any embeddings were added
+        if embeddings_added:
+            self._dump_dataset()
+
+        return self
+
+    def _filter_node_features(self):
+        """Filters the node features to avoid redundancies and noise"""
+        logger.info("Filters node features")
+
+        # Set up the node features that should be kept
+        size = "small" if self.size == "test" else self.size
+        node_feats = dict(
+            claim=[
+                "embedding",
+                "label",
+                "reviewers",
+                "date",
+                "language",
+                "keywords",
+                "cluster_keywords",
+                "cluster",
+                f"{size}_train_mask",
+                f"{size}_val_mask",
+                f"{size}_test_mask",
+            ],
+            tweet=[
+                "tweet_id",
+                "text",
+                "created_at",
+                "lang",
+                "source",
+                "public_metrics.retweet_count",
+                "public_metrics.reply_count",
+                "public_metrics.quote_count",
+                "label",
+                f"{size}_train_mask",
+                f"{size}_val_mask",
+                f"{size}_test_mask",
+            ],
+            reply=[
+                "tweet_id",
+                "text",
+                "created_at",
+                "lang",
+                "source",
+                "public_metrics.retweet_count",
+                "public_metrics.reply_count",
+                "public_metrics.quote_count",
+            ],
+            user=[
+                "user_id",
+                "verified",
+                "protected",
+                "created_at",
+                "username",
+                "description",
+                "url",
+                "name",
+                "public_metrics.followers_count",
+                "public_metrics.following_count",
+                "public_metrics.tweet_count",
+                "public_metrics.listed_count",
+                "location",
+            ],
+            image=["url", "pixels", "width", "height"],
+            article=["url", "title", "content"],
+            place=[
+                "place_id",
+                "name",
+                "full_name",
+                "country_code",
+                "country",
+                "place_type",
+                "lat",
+                "lng",
+            ],
+            hashtag=["tag"],
+            poll=[
+                "poll_id",
+                "labels",
+                "votes",
+                "end_datetime",
+                "voting_status",
+                "duration_minutes",
+            ],
+        )
+
+        # Set up renaming of node features that should be kept
+        node_feat_renaming = {
+            "public_metrics.retweet_count": "num_retweets",
+            "public_metrics.reply_count": "num_replies",
+            "public_metrics.quote_count": "num_quote_tweets",
+            "public_metrics.followers_count": "num_followers",
+            "public_metrics.following_count": "num_followees",
+            "public_metrics.tweet_count": "num_tweets",
+            "public_metrics.listed_count": "num_listed",
+            f"{size}_train_mask": "train_mask",
+            f"{size}_val_mask": "val_mask",
+            f"{size}_test_mask": "test_mask",
+        }
+
+        # Filter and rename the node features
+        for node_type, features in node_feats.items():
+            if node_type in self.nodes.keys():
+                filtered_feats = [
+                    feat for feat in features if feat in self.nodes[node_type].columns
+                ]
+                renaming_dict = {
+                    old: new
+                    for old, new in node_feat_renaming.items()
+                    if old in features
+                }
+                self.nodes[node_type] = self.nodes[node_type][filtered_feats].rename(
+                    columns=renaming_dict
+                )
+
+        return self
+
+    def _filter_relations(self):
+        """Filters the relations to only include node IDs that exist"""
+        logger.info("Filters relations")
+
+        # Remove article relations if they are not included
+        if not self.include_articles:
+            rels_to_pop = list()
+            for rel_type in self.rels.keys():
+                src, _, tgt = rel_type
+                if src == "article" or tgt == "article":
+                    rels_to_pop.append(rel_type)
+            for rel_type in rels_to_pop:
+                self.rels.pop(rel_type)
+
+        # Remove reply relations if they are not included
+        if not self.include_replies:
+            rels_to_pop = list()
+            for rel_type in self.rels.keys():
+                src, _, tgt = rel_type
+                if src == "reply" or tgt == "reply":
+                    rels_to_pop.append(rel_type)
+            for rel_type in rels_to_pop:
+                self.rels.pop(rel_type)
+
+        # Remove mention relations if they are not included
+        if not self.include_mentions:
+            rels_to_pop = list()
+            for rel_type in self.rels.keys():
+                _, rel, _ = rel_type
+                if rel == "mentions":
+                    rels_to_pop.append(rel_type)
+            for rel_type in rels_to_pop:
+                self.rels.pop(rel_type)
+
+        # Loop over the relations, extract the associated node IDs and filter the
+        # relation dataframe to only include relations between nodes that exist
+        rels_to_pop = list()
+        for rel_type, rel_df in self.rels.items():
+
+            # Pop the relation if the dataframe does not exist
+            if rel_df is None or len(rel_df) == 0:
+                rels_to_pop.append(rel_type)
+                continue
+
+            # Pop the relation if the source or target node does not exist
+            src, _, tgt = rel_type
+            if src not in self.nodes.keys() or tgt not in self.nodes.keys():
+                rels_to_pop.append(rel_type)
+
+            # Otherwise filter the relation dataframe to only include nodes that exist
+            else:
+                src_ids = self.nodes[src].index.tolist()
+                tgt_ids = self.nodes[tgt].index.tolist()
+                rel_df = rel_df[rel_df.src.isin(src_ids)]
+                rel_df = rel_df[rel_df.tgt.isin(tgt_ids)]
+                self.rels[rel_type] = rel_df
+
+        # Pop the relations that has been assigned to be popped
+        for rel_type in rels_to_pop:
+            self.rels.pop(rel_type)
+
+    def _set_datatypes(self):
+        """Set datatypes in the dataframes, to use less memory"""
+
+        # Set up all the dtypes of the columns
+        dtypes = dict(
+            tweet=dict(
+                tweet_id="uint64",
+                text="str",
+                created_at={"created_at": "datetime64[ns]"},
+                lang="category",
+                source="str",
+                num_retweets="uint64",
+                num_replies="uint64",
+                num_quote_tweets="uint64",
+            ),
+            user=dict(
+                user_id="uint64",
+                verified="bool",
+                protected="bool",
+                created_at={"created_at": "datetime64[ns]"},
+                username="str",
+                description="str",
+                url="str",
+                name="str",
+                num_followers="uint64",
+                num_followees="uint64",
+                num_tweets="uint64",
+                num_listed="uint64",
+                location="category",
+            ),
+        )
+
+        if self.include_hashtags:
+            dtypes["hashtag"] = dict(tag="str")
+
+        if self.include_replies:
+            dtypes["reply"] = dict(
+                tweet_id="uint64",
+                text="str",
+                created_at={"created_at": "datetime64[ns]"},
+                lang="category",
+                source="str",
+                num_retweets="uint64",
+                num_replies="uint64",
+                num_quote_tweets="uint64",
+            )
+
+        if self.include_tweet_images or self.include_extra_images:
+            dtypes["image"] = dict(
+                url="str", pixels="numpy:uint8", width="uint64", height="uint64"
+            )
+
+        if self.include_articles:
+            dtypes["article"] = dict(url="str", title="str", content="str")
+
+        # Create conversion function for missing values
+        def fill_na_values(dtype: Union[str, dict]):
+            if dtype == "uint64":
+                return 0
+            elif dtype == "bool":
+                return False
+            elif dtype == dict(created_at="datetime64[ns]"):
+                return np.datetime64("NaT")
+            elif dtype == "category":
+                return "NaN"
+            elif dtype == "str":
+                return ""
+            else:
+                return np.nan
+
+        # Loop over all nodes
+        for ntype, dtype_dict in dtypes.items():
+            if ntype in self.nodes.keys():
+
+                # Set the dtypes for non-numpy columns
+                dtype_dict_no_numpy = {
+                    col: dtype
+                    for col, dtype in dtype_dict.items()
+                    if not isinstance(dtype, str) or not dtype.startswith("numpy")
+                }
+                for col, dtype in dtype_dict_no_numpy.items():
+                    if col in self.nodes[ntype].columns:
+
+                        # Fill NaN values with canonical values in accordance with the
+                        # datatype
+                        self.nodes[ntype][col].fillna(
+                            fill_na_values(dtype), inplace=True
+                        )
+
+                        # Set the dtype
+                        self.nodes[ntype][col] = self.nodes[ntype][col].astype(dtype)
+
+                # For numpy columns, set the type manually
+                def numpy_fn(x, dtype: str):
+                    return np.asarray(x, dtype=dtype)
+
+                for col, dtype in dtype_dict.items():
+                    if (
+                        isinstance(dtype, str)
+                        and dtype.startswith("numpy")
+                        and col in self.nodes[ntype].columns
+                    ):
+
+                        # Fill NaN values with canonical values in accordance with the
+                        # datatype
+                        self.nodes[ntype][col].fillna(
+                            fill_na_values(dtype), inplace=True
+                        )
+
+                        # Extract the NumPy datatype
+                        numpy_dtype = dtype.split(":")[-1]
+
+                        # Tweak the numpy function to include the datatype
+                        fn = partial(numpy_fn, dtype=numpy_dtype)
+
+                        # Set the dtype
+                        self.nodes[ntype][col] = self.nodes[ntype][col].map(fn)
+
+    def _remove_auxilliaries(self):
+        """Removes node types that are not in use anymore"""
+        # Remove auxilliary node types
+        nodes_to_remove = [
+            node_type
+            for node_type in self.nodes.keys()
+            if node_type not in self._node_dump
+        ]
+        for node_type in nodes_to_remove:
+            self.nodes.pop(node_type)
+
+        # Remove auxilliary relation types
+        rels_to_remove = [
+            rel_type for rel_type in self.rels.keys() if rel_type not in self._rel_dump
+        ]
+        for rel_type in rels_to_remove:
+            self.rels.pop(rel_type)
+
+        return self
+
+    def _remove_islands(self):
+        """Removes nodes and relations that are not connected to anything"""
+
+        # Loop over all the node types
+        for node_type, node_df in self.nodes.items():
+
+            # For each node type, loop over all the relations, to see what nodes of
+            # that node type does not appear in any of the relations
+            for rel_type, rel_df in self.rels.items():
+                src, _, tgt = rel_type
+
+                # If the node is the source of the relation
+                if node_type == src:
+
+                    # Store all the nodes connected to the relation (or any of the
+                    # previously checked relations)
+                    connected = node_df.index.isin(rel_df.src.tolist())
+                    if "connected" in node_df.columns:
+                        connected = node_df.connected | connected
+                    node_df["connected"] = connected
+
+                # If the node is the source of the relation
+                if node_type == tgt:
+
+                    # Store all the nodes connected to the relation (or any of the
+                    # previously checked relations)
+                    connected = node_df.index.isin(rel_df.tgt.tolist())
+                    if "connected" in node_df.columns:
+                        connected = node_df.connected | connected
+                    node_df["connected"] = connected
+
+            # Filter the node dataframe to only keep the connected ones
+            if "connected" in node_df.columns and "index" not in node_df.columns:
+                self.nodes[node_type] = (
+                    node_df.query("connected == True")
+                    .drop(columns="connected")
+                    .reset_index()
+                )
+
+            # Update the relevant relations
+            for rel_type, rel_df in self.rels.items():
+                src, _, tgt = rel_type
+
+                # If islands have been removed from the source, then update those
+                # indices
+                if node_type == src and "index" in self.nodes[node_type]:
+                    node_df = (
+                        self.nodes[node_type]
+                        .rename(columns=dict(index="old_idx"))
+                        .reset_index()
+                    )
+
+                    rel_df = (
+                        rel_df.merge(
+                            node_df[["index", "old_idx"]],
+                            left_on="src",
+                            right_on="old_idx",
+                        )
+                        .drop(columns=["src", "old_idx"])
+                        .rename(columns=dict(index="src"))
+                    )
+                    self.rels[rel_type] = rel_df[["src", "tgt"]]
+                    self.nodes[node_type] = self.nodes[node_type]
+
+                # If islands have been removed from the target, then update those
+                # indices
+                if node_type == tgt and "index" in self.nodes[node_type]:
+                    node_df = (
+                        self.nodes[node_type]
+                        .rename(columns=dict(index="old_idx"))
+                        .reset_index()
+                    )
+                    rel_df = (
+                        rel_df.merge(
+                            node_df[["index", "old_idx"]],
+                            left_on="tgt",
+                            right_on="old_idx",
+                        )
+                        .drop(columns=["tgt", "old_idx"])
+                        .rename(columns=dict(index="tgt"))
+                    )
+                    self.rels[rel_type] = rel_df[["src", "tgt"]]
+                    self.nodes[node_type] = self.nodes[node_type]
+
+            if "index" in self.nodes[node_type]:
+                self.nodes[node_type] = self.nodes[node_type].drop(columns="index")
+
+        return self
+
+    def _dump_dataset(self):
+        """Dumps the dataset to a zip file"""
+        logger.info("Dumping dataset")
+
+        # Create a temporary pickle folder
+        temp_pickle_folder = Path("temp_pickle_folder")
+        if not temp_pickle_folder.exists():
+            temp_pickle_folder.mkdir()
+
+        # Make temporary pickle list
+        pickle_list = list()
+
+        # Create progress bar
+        total = len(self._node_dump) + len(self._rel_dump) + 1
+        pbar = tqdm(total=total)
+
+        # Store the nodes
+        for node_type in self._node_dump:
+            pbar.set_description(f"Storing {node_type} nodes")
+            if node_type in self.nodes.keys():
+                pickle_list.append(node_type)
+                pickle_path = temp_pickle_folder / f"{node_type}.pickle"
+                self.nodes[node_type].to_pickle(pickle_path, protocol=4)
+            pbar.update()
+
+        # Store the relations
+        for rel_type in self._rel_dump:
+            pbar.set_description(f"Storing {rel_type} relations")
+            if rel_type in self.rels.keys():
+                name = "_".join(rel_type)
+                pickle_list.append(name)
+                pickle_path = temp_pickle_folder / f"{name}.pickle"
+                self.rels[rel_type].to_pickle(pickle_path, protocol=4)
+            pbar.update()
+
+        # Zip the nodes and relations, and save the zip file
+        with zipfile.ZipFile(
+            self.dataset_path, mode="w", compression=zipfile.ZIP_STORED
+        ) as zip_file:
+            pbar.set_description("Dumping dataset")
+            for name in pickle_list:
+                fname = f"{name}.pickle"
+                zip_file.write(temp_pickle_folder / fname, arcname=fname)
+
+        # Remove the temporary pickle folder
+        rmtree(temp_pickle_folder)
+
+        # Final progress bar update and close it
+        pbar.update()
+        pbar.close()
+
+        return self
+
+    def to_dgl(self):
+        """Convert the dataset to a DGL dataset.
+
+        Returns:
+            DGLHeteroGraph:
+                The graph in DGL format.
+        """
+        logger.info("Outputting to DGL")
+        return build_dgl_dataset(nodes=self.nodes, relations=self.rels)
+
+    def __repr__(self) -> str:
+        """A string representation of the dataset.
+
+        Returns:
+            str: The representation of the dataset.
+        """
+        bearer_token_available = self._twitter is not None
+        if len(self.nodes) == 0 or len(self.rels) == 0:
+            return (
+                f"MuminDataset(size={self.size}, "
+                f"rehydrated={self.rehydrated}, "
+                f"compiled={self.compiled}, "
+                f"bearer_token_available={bearer_token_available})"
+            )
+        else:
+            num_nodes = sum([len(df) for df in self.nodes.values()])
+            num_rels = sum([len(df) for df in self.rels.values()])
+            return (
+                f"MuminDataset(num_nodes={num_nodes:,}, "
+                f"num_relations={num_rels:,}, "
+                f"size='{self.size}', "
+                f"rehydrated={self.rehydrated}, "
+                f"compiled={self.compiled}, "
+                f"bearer_token_available={bearer_token_available})"
+            )

src/mumin/dgl.py

@@ -0,0 +1,326 @@
+"""Functions related to exporting the dataset to the Deep Graph Library"""
+
+import json
+from pathlib import Path
+from typing import Dict, Tuple, Union
+
+import numpy as np
+import pandas as pd
+from torch import Tensor
+
+
+def build_dgl_dataset(
+    nodes: Dict[str, pd.DataFrame], relations: Dict[Tuple[str, str, str], pd.DataFrame]
+):
+    """Convert the dataset to a DGL graph.
+
+    This assumes that the dataset has been compiled and thus also dumped to a local
+    file.
+
+    Args:
+        nodes (dict):
+            The nodes of the dataset, with keys the node types and NumPy arrays as the
+            values.
+        relations (dict):
+            The relations of the dataset, with keys being triples of strings
+            (source_node_type, relation_type, target_node_type) and NumPy arrays as the
+            values.
+
+    Returns:
+        DGLHeteroGraph:
+            The graph in DGL format.
+
+    Raises:
+        ModuleNotFoundError:
+            If `dgl` has not been installed.
+    """
+    # Import the needed libraries, and raise an error if they have not yet been
+    # installed
+    try:
+        import dgl
+        import torch
+    except ModuleNotFoundError:
+        raise ModuleNotFoundError(
+            "Could not find the `dgl` library. Please install it and try again."
+        )
+
+    # Remove the claims that are only connected to deleted tweets
+    tweet_df = nodes["tweet"].dropna()
+    claim_df = nodes["claim"]
+    discusses_df = relations[("tweet", "discusses", "claim")]
+    discusses_df = discusses_df[discusses_df.src.isin(tweet_df.index.tolist())]
+    claim_df = claim_df[claim_df.index.isin(discusses_df.tgt.tolist())]
+    nodes["claim"] = claim_df
+
+    # Set up the graph as a DGL graph
+    graph_data = dict()
+    for canonical_etype, rel_arr in relations.items():
+
+        # Drop the NaN nodes, corresponding to the deleted tweets. We also reset the
+        # indices to start from 0, as DGL requires there to be no gaps in the indexing
+        src, rel, tgt = canonical_etype
+        allowed_src = (
+            nodes[src]
+            .dropna()
+            .reset_index()
+            .rename(columns=dict(index="old_idx"))
+            .old_idx
+        )
+        allowed_src = {old: new for new, old in allowed_src.iteritems()}
+        allowed_tgt = (
+            nodes[tgt]
+            .dropna()
+            .reset_index()
+            .rename(columns=dict(index="old_idx"))
+            .old_idx
+        )
+        allowed_tgt = {old: new for new, old in allowed_tgt.iteritems()}
+
+        # Get a dataframe containing the edges between allowed source and target nodes
+        # (i.e., non-deleted)
+        rel_arr = (
+            relations[canonical_etype][["src", "tgt"]]
+            .query("src in @allowed_src.keys() and " "tgt in @allowed_tgt.keys()")
+            .drop_duplicates()
+        )
+
+        # Convert the node indices in the edge dataframe to the new indices without
+        # gaps
+        rel_arr.src = [allowed_src[old_idx] for old_idx in rel_arr.src.tolist()]
+        rel_arr.tgt = [allowed_tgt[old_idx] for old_idx in rel_arr.tgt.tolist()]
+
+        # Convert the edge dataframe to a NumPy array
+        rel_arr = rel_arr.to_numpy()
+
+        # If there are edges left in the edge array, then convert these to PyTorch
+        # tensors and add them to the graph data
+        if rel_arr.size:
+            src_tensor = torch.from_numpy(rel_arr[:, 0]).long()
+            tgt_tensor = torch.from_numpy(rel_arr[:, 1]).long()
+            graph_data[canonical_etype] = (src_tensor, tgt_tensor)
+
+            # Adding inverse relations as well, to ensure that graph is bidirected
+            graph_data[(tgt, f"{rel}_inv", src)] = (tgt_tensor, src_tensor)
+
+    # Initialise a DGL heterogeneous graph from the graph data
+    dgl_graph = dgl.heterograph(graph_data)
+
+    def emb_to_tensor(df: pd.DataFrame, col_name: str) -> torch.Tensor:
+        """Convenience function converting embeddings to tensors.
+
+        Args:
+            df (pd.DataFrame):
+                The dataframe containing the embeddings.
+            col_name (str):
+                The name of the column containing the embeddings.
+
+        Returns:
+            torch.Tensor:
+                The embeddings as a PyTorch tensor.
+        """
+        if type(df[col_name].iloc[0]) == str:
+            df[col_name] = df[col_name].map(lambda x: json.loads(x))
+        np_array = np.stack(df[col_name].tolist())
+        if len(np_array.shape) == 1:
+            np_array = np.expand_dims(np_array, axis=1)
+        return torch.from_numpy(np_array)
+
+    # Initialise `tensors` variable
+    tensors: Union[Tuple[Tensor], Tuple[Tensor, Tensor], Tuple[Tensor, Tensor, Tensor]]
+
+    # Add node features to the Tweet nodes
+    allowed_tweet_df = nodes["tweet"].dropna().reset_index(drop=True)
+    cols = ["num_retweets", "num_replies", "num_quote_tweets"]
+    tweet_feats = torch.from_numpy(allowed_tweet_df[cols].astype(float).to_numpy())
+    if (
+        "text_emb" in allowed_tweet_df.columns
+        and "lang_emb" in allowed_tweet_df.columns
+    ):
+        tweet_embs = emb_to_tensor(allowed_tweet_df, "text_emb")
+        lang_embs = emb_to_tensor(allowed_tweet_df, "lang_emb")
+        tensors = (tweet_embs, lang_embs, tweet_feats)
+    else:
+        tensors = (tweet_feats,)
+    dgl_graph.nodes["tweet"].data["feat"] = torch.cat(tensors, dim=1)
+
+    # Add node features to the Reply nodes
+    if "reply" in nodes.keys() and "reply" in dgl_graph.ntypes:
+        allowed_reply_df = nodes["reply"].dropna().reset_index(drop=True)
+        cols = ["num_retweets", "num_replies", "num_quote_tweets"]
+        reply_feats = torch.from_numpy(allowed_reply_df[cols].astype(float).to_numpy())
+        if (
+            "text_emb" in allowed_reply_df.columns
+            and "lang_emb" in allowed_reply_df.columns
+        ):
+            reply_embs = emb_to_tensor(allowed_reply_df, "text_emb")
+            lang_embs = emb_to_tensor(allowed_reply_df, "lang_emb")
+            tensors = (reply_embs, lang_embs, reply_feats)
+        else:
+            tensors = (reply_feats,)
+        dgl_graph.nodes["reply"].data["feat"] = torch.cat(tensors, dim=1)
+
+    # Add node features to the User nodes
+    nodes["user"]["verified"] = nodes["user"].verified.astype(np.uint64)
+    nodes["user"]["protected"] = nodes["user"].verified.astype(np.uint64)
+    cols = [
+        "verified",
+        "protected",
+        "num_followers",
+        "num_followees",
+        "num_tweets",
+        "num_listed",
+    ]
+    user_feats = torch.from_numpy(nodes["user"][cols].astype(float).to_numpy())
+    if "description_emb" in nodes["user"].columns:
+        user_embs = emb_to_tensor(nodes["user"], "description_emb")
+        tensors = (user_embs, user_feats)
+    else:
+        tensors = (user_feats,)
+    dgl_graph.nodes["user"].data["feat"] = torch.cat(tensors, dim=1)
+
+    # Add node features to the Article nodes
+    if "article" in nodes.keys() and "article" in dgl_graph.ntypes:
+        if (
+            "title_emb" in nodes["article"].columns
+            and "content_emb" in nodes["article"].columns
+        ):
+            title_embs = emb_to_tensor(nodes["article"], "title_emb")
+            content_embs = emb_to_tensor(nodes["article"], "content_emb")
+            tensors = (title_embs, content_embs)
+            dgl_graph.nodes["article"].data["feat"] = torch.cat(tensors, dim=1)
+        else:
+            num_articles = dgl_graph.num_nodes("article")
+            ones = torch.ones(num_articles, 1)
+            dgl_graph.nodes["article"].data["feat"] = ones
+
+    # Add node features to the Image nodes
+    if "image" in nodes.keys() and "image" in dgl_graph.ntypes:
+        if "pixels_emb" in nodes["image"].columns:
+            image_embs = emb_to_tensor(nodes["image"], "pixels_emb")
+            dgl_graph.nodes["image"].data["feat"] = image_embs
+        else:
+            num_images = dgl_graph.num_nodes("image")
+            dgl_graph.nodes["image"].data["feat"] = torch.ones(num_images, 1)
+
+    # Add node features to the Hashtag nodes
+    if "hashtag" in nodes.keys() and "hashtag" in dgl_graph.ntypes:
+        num_hashtags = dgl_graph.num_nodes("hashtag")
+        dgl_graph.nodes["hashtag"].data["feat"] = torch.ones(num_hashtags, 1)
+
+    # Add node features to the Claim nodes
+    if "claim" in nodes.keys() and "claim" in dgl_graph.ntypes:
+        claim_embs = emb_to_tensor(nodes["claim"], "embedding")
+        if "reviewer_emb" in nodes["claim"].columns:
+            rev_embs = emb_to_tensor(nodes["claim"], "reviewer_emb")
+            tensors = (claim_embs, rev_embs)
+            dgl_graph.nodes["claim"].data["feat"] = torch.cat(tensors, dim=1)
+        else:
+            dgl_graph.nodes["claim"].data["feat"] = claim_embs
+
+    # Add labels
+    def numericalise_labels(label: str) -> int:
+        numericalise = dict(misinformation=0, factual=1)
+        return numericalise[label]
+
+    claim_labels = nodes["claim"][["label"]].applymap(numericalise_labels)
+    discusses = relations[("tweet", "discusses", "claim")]
+    tweet_labels = allowed_tweet_df.merge(
+        discusses.merge(claim_labels, left_on="tgt", right_index=True).drop_duplicates(
+            "src"
+        ),
+        left_index=True,
+        right_on="src",
+        how="left",
+    )
+    claim_label_tensor = torch.from_numpy(claim_labels.label.to_numpy())
+    claim_label_tensor = torch.nan_to_num(claim_label_tensor).long()
+    tweet_label_tensor = torch.from_numpy(tweet_labels.label.to_numpy())
+    tweet_label_tensor = torch.nan_to_num(tweet_label_tensor).long()
+    dgl_graph.nodes["claim"].data["label"] = claim_label_tensor
+    dgl_graph.nodes["tweet"].data["label"] = tweet_label_tensor
+
+    # Add masks
+    mask_names = ["train_mask", "val_mask", "test_mask"]
+    claim_masks = nodes["claim"][mask_names].copy()
+    merged = allowed_tweet_df.merge(
+        discusses.merge(claim_masks, left_on="tgt", right_index=True).drop_duplicates(
+            "src"
+        ),
+        left_index=True,
+        right_on="src",
+        how="left",
+    )
+    for col_name in mask_names:
+        claim_tensor = torch.from_numpy(
+            nodes["claim"][col_name].astype(float).to_numpy()
+        )
+        claim_tensor = torch.nan_to_num(claim_tensor).bool()
+        tweet_tensor = torch.from_numpy(merged[col_name].astype(float).to_numpy())
+        tweet_tensor = torch.nan_to_num(tweet_tensor).bool()
+        dgl_graph.nodes["claim"].data[col_name] = claim_tensor
+        dgl_graph.nodes["tweet"].data[col_name] = tweet_tensor
+
+    # Return DGL graph
+    return dgl_graph
+
+
+def save_dgl_graph(dgl_graph, path: Union[str, Path] = "mumin.dgl"):
+    """Save a MuMiN DGL graph.
+
+    Args:
+        dgl_graph (DGL heterogeneous graph):
+            The graph to store.
+        path (str, optional):
+            Where to store the graph. Defaults to 'mumin.dgl'.
+    """
+    # Import the needed libraries, and raise an error if they have not yet been
+    # installed
+    try:
+        import torch
+        from dgl.data.utils import save_graphs
+    except ModuleNotFoundError:
+        raise ModuleNotFoundError(
+            "Could not find the `dgl` library. Please install it and try again."
+        )
+
+    # Convert masks to unsigned 8-bit integers
+    for mask_name in ["train_mask", "val_mask", "test_mask"]:
+        for node_type in ["claim", "tweet"]:
+            t = dgl_graph.nodes[node_type].data[mask_name]
+            dgl_graph.nodes[node_type].data[mask_name] = t.type(torch.uint8)
+
+    # Save the graph
+    save_graphs(str(path), [dgl_graph])
+
+
+def load_dgl_graph(path: Union[str, Path] = "mumin.dgl"):
+    """Load a MuMiN DGL graph.
+
+    Args:
+        path (str or Path, optional):
+            Where to load the graph from. Defaults to 'mumin.dgl'.
+
+    Returns:
+        DGLHeteroGraph:
+            The MuMiN graph.
+    """
+    # Import the needed libraries, and raise an error if they have not yet been
+    # installed
+    try:
+        from dgl.data.utils import load_graphs
+    except ModuleNotFoundError:
+        raise ModuleNotFoundError(
+            "Could not find the `dgl` library. Please install it and try again."
+        )
+
+    # Load the graph
+    dgl_graph = load_graphs(str(path))[0][0]
+
+    # Convert masks back to booleans
+    for mask_name in ["train_mask", "val_mask", "test_mask"]:
+        for node_type in ["claim", "tweet"]:
+            mask_tensor = dgl_graph.nodes[node_type].data[mask_name]
+            dgl_graph.nodes[node_type].data[mask_name] = mask_tensor.bool()
+
+    # Return the graph
+    return dgl_graph

src/mumin/embedder.py

@@ -0,0 +1,405 @@
+"""Compute node embeddings for the dataset"""
+
+import json
+import warnings
+from functools import partial
+from typing import Dict, List, Tuple, Union
+
+import numpy as np
+import pandas as pd
+import torch
+from transformers import (
+    AutoFeatureExtractor,
+    AutoModel,
+    AutoModelForImageClassification,
+    AutoTokenizer,
+)
+from transformers import logging as tf_logging
+
+tf_logging.set_verbosity_error()
+
+
+class Embedder:
+    """Compute node embeddings for the dataset"""
+
+    def __init__(
+        self,
+        include_articles: bool,
+        include_tweet_images: bool,
+        include_extra_images: bool,
+        text_embedding_model_id: str,
+        image_embedding_model_id: str,
+    ):
+        self.include_articles = include_articles
+        self.include_tweet_images = include_tweet_images
+        self.include_extra_images = include_extra_images
+        self.text_embedding_model_id = text_embedding_model_id
+        self.image_embedding_model_id = image_embedding_model_id
+
+    def embed_all(
+        self, nodes: Dict[str, pd.DataFrame], nodes_to_embed: List[str]
+    ) -> Tuple[Dict[str, pd.DataFrame], bool]:
+        """Computes embeddings of node features.
+
+        Args:
+            nodes (Dict[str, pd.DataFrame]):
+                A dictionary of node dataframes.
+            nodes_to_embed (list of str):
+                The node types which needs to be embedded. If a node type does not
+                exist in the graph it will be ignored.
+
+        Returns:
+            pair of Dict[str, pd.DataFrame] and bool:
+                A dictionary of node dataframes with embeddings, and a boolean
+                indicating whether any embeddings were added.
+        """
+        # Create variable keeping track of whether any embeddings have been
+        # added
+        embeddings_added = False
+
+        # Embed tweets
+        if (
+            "tweet" in nodes_to_embed
+            and "tweet" in nodes
+            and len(nodes["tweet"]) > 0
+            and "text_emb" not in nodes["tweet"].columns
+        ):
+            nodes["tweet"] = self._embed_tweets(tweet_df=nodes["tweet"])
+            embeddings_added = True
+
+        # Embed replies
+        if (
+            "reply" in nodes_to_embed
+            and "reply" in nodes
+            and len(nodes["reply"]) > 0
+            and "text_emb" not in nodes["reply"].columns
+        ):
+            nodes["reply"] = self._embed_replies(reply_df=nodes["reply"])
+            embeddings_added = True
+
+        # Embed users
+        if (
+            "user" in nodes_to_embed
+            and "user" in nodes
+            and len(nodes["user"]) > 0
+            and "description_emb" not in nodes["user"].columns
+        ):
+            nodes["user"] = self._embed_users(user_df=nodes["user"])
+            embeddings_added = True
+
+        # Embed articles
+        if (
+            "article" in nodes_to_embed
+            and "article" in nodes
+            and len(nodes["article"]) > 0
+            and "content_emb" not in nodes["article"].columns
+        ):
+            nodes["article"] = self._embed_articles(article_df=nodes["article"])
+            embeddings_added = True
+
+        # Embed images
+        if (
+            "image" in nodes_to_embed
+            and "image" in nodes
+            and len(nodes["image"]) > 0
+            and "pixels_emb" not in nodes["image"].columns
+        ):
+            nodes["image"] = self._embed_images(image_df=nodes["image"])
+            embeddings_added = True
+
+        # Embed claims
+        if (
+            "claim" in nodes_to_embed
+            and "claim" in nodes
+            and len(nodes["claim"]) > 0
+            and "reviewer_emb" not in nodes["claim"].columns
+        ):
+            nodes["claim"] = self._embed_claims(claim_df=nodes["claim"])
+            embeddings_added = True
+
+        return nodes, embeddings_added
+
+    @staticmethod
+    def _embed_text(text: str, tokenizer, model) -> np.ndarray:
+        """Extract a text embedding.
+
+        Args:
+            text (str):
+                The text to embed.
+            tokenizer (transformers.PreTrainedTokenizer):
+                The tokenizer to use.
+            model (transformers.PreTrainedModel):
+                The model to use.
+
+        Returns:
+            np.ndarray:
+                The embedding of the text.
+        """
+        with torch.no_grad():
+            inputs = tokenizer(text, truncation=True, return_tensors="pt")
+            if torch.cuda.is_available():
+                inputs = {k: v.cuda() for k, v in inputs.items()}
+            result = model(**inputs)
+            return result.pooler_output[0].cpu().numpy()
+
+    def _embed_tweets(self, tweet_df: pd.DataFrame) -> pd.DataFrame:
+        """Embeds all the tweets in the dataset.
+
+        Args:
+            tweet_df (pd.DataFrame):
+                The tweet dataframe.
+
+        Returns:
+            pd.DataFrame:
+                The tweet dataframe with embeddings.
+        """
+        # Load text embedding model
+        model_id = self.text_embedding_model_id
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        model = AutoModel.from_pretrained(model_id)
+
+        # Move model to GPU if available
+        if torch.cuda.is_available():
+            model.cuda()
+
+        # Define embedding function
+        embed = partial(self._embed_text, tokenizer=tokenizer, model=model)
+
+        # Embed tweet text using the pretrained transformer
+        text_embs = tweet_df.text.progress_apply(embed)
+        tweet_df["text_emb"] = text_embs
+
+        # Embed tweet language using a one-hot encoding
+        languages = tweet_df.lang.tolist()
+        one_hotted = [
+            np.asarray(lst) for lst in pd.get_dummies(languages).to_numpy().tolist()
+        ]
+        tweet_df["lang_emb"] = one_hotted
+
+        return tweet_df
+
+    def _embed_replies(self, reply_df: pd.DataFrame) -> pd.DataFrame:
+        """Embeds all the replies in the dataset.
+
+        Args:
+            reply_df (pd.DataFrame): The reply dataframe.
+
+        Returns:
+            pd.DataFrame: The reply dataframe with embeddings.
+        """
+        # Load text embedding model
+        model_id = self.text_embedding_model_id
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        model = AutoModel.from_pretrained(model_id)
+
+        # Move model to GPU if available
+        if torch.cuda.is_available():
+            model.cuda()
+
+        # Define embedding function
+        embed = partial(self._embed_text, tokenizer=tokenizer, model=model)
+
+        # Embed tweet text using the pretrained transformer
+        text_embs = reply_df.text.progress_apply(embed)
+        reply_df["text_emb"] = text_embs
+
+        # Embed tweet language using a one-hot encoding
+        languages = reply_df.lang.tolist()
+        one_hotted = [
+            np.asarray(lst) for lst in pd.get_dummies(languages).to_numpy().tolist()
+        ]
+        reply_df["lang_emb"] = one_hotted
+
+        return reply_df
+
+    def _embed_users(self, user_df: pd.DataFrame) -> pd.DataFrame:
+        """Embeds all the users in the dataset.
+
+        Args:
+            user_df (pd.DataFrame):
+                The user dataframe.
+
+        Returns:
+            pd.DataFrame:
+                The user dataframe with embeddings.
+        """
+        # Load text embedding model
+        model_id = self.text_embedding_model_id
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        model = AutoModel.from_pretrained(model_id)
+
+        # Move model to GPU if available
+        if torch.cuda.is_available():
+            model.cuda()
+
+        # Define embedding function
+        def embed(text: str):
+            """Extract a text embedding"""
+            if text != text:
+                return np.zeros(model.config.hidden_size)
+            else:
+                return self._embed_text(text, tokenizer=tokenizer, model=model)
+
+        # Embed user description using the pretrained transformer
+        desc_embs = user_df.description.progress_apply(embed)
+        user_df["description_emb"] = desc_embs
+
+        return user_df
+
+    def _embed_articles(self, article_df: pd.DataFrame) -> pd.DataFrame:
+        """Embeds all the tweets in the dataset.
+
+        Args:
+            article_df (pd.DataFrame):
+                The article dataframe.
+
+        Returns:
+            pd.DataFrame:
+                The article dataframe with embeddings.
+        """
+        if self.include_articles:
+            # Load text embedding model
+            model_id = self.text_embedding_model_id
+            tokenizer = AutoTokenizer.from_pretrained(model_id)
+            model = AutoModel.from_pretrained(model_id)
+
+            # Move model to GPU if available
+            if torch.cuda.is_available():
+                model.cuda()
+
+            # Define embedding function
+            def embed(text: Union[str, List[str]]):
+                """Extract a text embedding"""
+                params = dict(tokenizer=tokenizer, model=model)
+                if isinstance(text, str):
+                    return self._embed_text(text, **params)
+                else:
+                    return np.mean(
+                        [self._embed_text(doc, **params) for doc in text], axis=0
+                    )
+
+            def split_content(doc: str) -> List[str]:
+                """Split up a string into smaller chunks"""
+                if "." in doc:
+                    return doc.split(".")
+                else:
+                    end = min(len(doc) - 1000, 0)
+                    return [doc[i : i + 1000] for i in range(0, end, 1000)] + [
+                        doc[end:-1]
+                    ]
+
+            # Embed titles using the pretrained transformer
+            title_embs = article_df.title.progress_apply(embed)
+            article_df["title_emb"] = title_embs
+
+            # Embed contents using the pretrained transformer
+            contents = article_df.content
+            content_embs = contents.map(split_content).progress_apply(embed)
+            article_df["content_emb"] = content_embs
+
+        return article_df
+
+    def _embed_images(self, image_df: pd.DataFrame) -> pd.DataFrame:
+        """Embeds all the images in the dataset.
+
+        Args:
+            image_df (pd.DataFrame):
+                The image dataframe.
+
+        Returns:
+            pd.DataFrame:
+                The image dataframe with embeddings.
+        """
+        if self.include_tweet_images or self.include_extra_images:
+            # Load image embedding model
+            model_id = self.image_embedding_model_id
+            feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)
+            model = AutoModelForImageClassification.from_pretrained(model_id)
+
+            # Move model to GPU if available
+            if torch.cuda.is_available():
+                model.cuda()
+
+            # Define embedding function
+            def embed(image):
+                """Extract the last hiden state of image model"""
+                with torch.no_grad():
+
+                    # Ensure that the input has shape (C, H, W)
+                    image = np.transpose(image, (2, 0, 1))
+
+                    # Extract the features to be used in the model
+                    inputs = feature_extractor(images=image, return_tensors="pt")
+
+                    if torch.cuda.is_available():
+                        inputs = {k: v.cuda() for k, v in inputs.items()}
+
+                    # Get the embedding
+                    outputs = model(**inputs, output_hidden_states=True)
+                    penultimate_embedding = outputs.hidden_states[-1]
+                    cls_embedding = penultimate_embedding[0, 0, :]
+
+                    # Convert to NumPy and return
+                    return cls_embedding.cpu().numpy()
+
+            # Embed pixels using the pretrained transformer
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                image_df["pixels_emb"] = image_df.pixels.progress_apply(embed).tolist()
+
+        return image_df
+
+    def _embed_claims(self, claim_df: pd.DataFrame) -> pd.DataFrame:
+        """Embeds all the claims in the dataset.
+
+        Args:
+            claim_df (pd.DataFrame):
+                The claim dataframe.
+
+        Returns:
+            pd.DataFrame:
+                The claim dataframe with embeddings.
+        """
+        # Ensure that `reviewers` is a list
+        if isinstance(claim_df.reviewers.iloc[0], str):
+
+            def string_to_list(string: str) -> list:
+                """Convert a string to a list.
+
+                Args:
+                    string: A string to be converted to a list.
+
+                Returns:
+                    list: A list of strings.
+                """
+                string = string.replace("'", '"')
+                return json.loads(string)
+
+            claim_df["reviewers"] = claim_df.reviewers.map(string_to_list)
+
+        # Set up one-hot encoding of claim reviewers
+        reviewers = claim_df.reviewers.explode().unique().tolist()
+        one_hotted = [
+            np.asarray(lst) for lst in pd.get_dummies(reviewers).to_numpy().tolist()
+        ]
+        one_hot_dict = {
+            reviewer: array for reviewer, array in zip(reviewers, one_hotted)
+        }
+
+        def embed_reviewers(revs: List[str]) -> np.ndarray:
+            """One-hot encoding of multiple reviewers.
+
+            Args:
+                revs: A list of reviewers.
+
+            Returns:
+                np.ndarray: A one-hot encoded array.
+            """
+            arrays = [one_hot_dict[rev] for rev in revs]
+            return np.stack(arrays, axis=0).sum(axis=0)
+
+        # Embed claim reviewer using a one-hot encoding
+        reviewer_emb = claim_df.reviewers.map(embed_reviewers)
+        claim_df["reviewer_emb"] = reviewer_emb
+
+        return claim_df

src/mumin/id_updator.py

@@ -0,0 +1,328 @@
+"""Class that updates the precomputed IDs"""
+
+from typing import Dict, Tuple
+
+import numpy as np
+import pandas as pd
+
+
+class IdUpdator:
+    """Class that updates the IDs of nodes and relations"""
+
+    def update_all(
+        self,
+        nodes: Dict[str, pd.DataFrame],
+        rels: Dict[Tuple[str, str, str], pd.DataFrame],
+    ) -> Tuple[dict, dict]:
+        """Extract all node and relation data.
+
+        Args:
+            nodes (Dict[str, pd.DataFrame]):
+                A dictionary of node dataframes.
+            rels (Dict[Tuple[str, str, str], pd.DataFrame]):
+                A dictionary of relation dataframes.
+
+        Returns:
+            pair of dicts:
+                A tuple of updated node and relation dictionaries.
+        """
+        rel = ("tweet", "discusses", "claim")
+        if rel in rels.keys():
+            rels[rel] = self._update_tweet_discusses_claim(
+                rel_df=rels[rel], tweet_df=nodes["tweet"], claim_df=nodes["claim"]
+            )
+
+        rel = ("article", "discusses", "claim")
+        if rel in rels.keys():
+            rels[rel] = self._update_article_discusses_claim(
+                rel_df=rels[rel], article_df=nodes["article"], claim_df=nodes["claim"]
+            )
+
+        rel = ("user", "follows", "user")
+        if rel in rels.keys():
+            rels[rel] = self._update_user_follows_user(
+                rel_df=rels[rel], user_df=nodes["user"]
+            )
+
+        rel = ("reply", "reply_to", "tweet")
+        if rel in rels.keys():
+            rels[rel] = self._update_reply_reply_to_tweet(
+                rel_df=rels[rel], reply_df=nodes["reply"], tweet_df=nodes["tweet"]
+            )
+
+        rel = ("reply", "quote_of", "tweet")
+        if rel in rels.keys():
+            rels[rel] = self._update_reply_quote_of_tweet(
+                rel_df=rels[rel], reply_df=nodes["reply"], tweet_df=nodes["tweet"]
+            )
+
+        rel = ("user", "retweeted", "tweet")
+        if rel in rels.keys():
+            rels[rel] = self._update_user_retweeted_tweet(
+                rel_df=rels[rel], user_df=nodes["user"], tweet_df=nodes["tweet"]
+            )
+
+        # Remove ID columns from the claim and article dataframes
+        nodes["claim"] = self._remove_id_column(node_df=nodes["claim"])
+        if "article" in nodes.keys():
+            nodes["article"] = self._remove_id_column(node_df=nodes["article"])
+
+        return nodes, rels
+
+    def _update_tweet_discusses_claim(
+        self, rel_df: pd.DataFrame, tweet_df: pd.DataFrame, claim_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Update the (:Tweet)-[:DISCUSSES]->(:Claim) relation.
+
+        Args:
+            rel_df (pd.DataFrame): The relation dataframe.
+            tweet_df (pd.DataFrame): The tweet dataframe.
+            claim_df (pd.DataFrame): The claim dataframe.
+
+        Returns:
+            pd.DataFrame: The updated relation dataframe.
+        """
+        if len(rel_df) > 0:
+            merged = (
+                rel_df.astype(dict(src=np.uint64, tgt=np.uint64))
+                .merge(
+                    tweet_df[["tweet_id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="tweet_idx")),
+                    left_on="src",
+                    right_on="tweet_id",
+                )
+                .merge(
+                    claim_df[["id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="claim_idx")),
+                    left_on="tgt",
+                    right_on="id",
+                )
+            )
+            if len(merged) > 0:
+                data_dict = dict(
+                    src=merged.tweet_idx.tolist(), tgt=merged.claim_idx.tolist()
+                )
+                rel_df = pd.DataFrame(data_dict)
+            else:
+                rel_df = pd.DataFrame()
+
+        return rel_df
+
+    def _update_article_discusses_claim(
+        self, rel_df: pd.DataFrame, article_df: pd.DataFrame, claim_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Update the (:Article)-[:DISCUSSES]->(:Claim) relation.
+
+        Args:
+            rel_df (pd.DataFrame): The relation dataframe.
+            article_df (pd.DataFrame): The article dataframe.
+            claim_df (pd.DataFrame): The claim dataframe.
+
+        Returns:
+            pd.DataFrame: The updated relation dataframe.
+        """
+        if len(rel_df) > 0:
+            merged = (
+                rel_df.astype(dict(src=np.uint64, tgt=np.uint64))
+                .merge(
+                    article_df[["id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="art_idx")),
+                    left_on="src",
+                    right_on="id",
+                )
+                .merge(
+                    claim_df[["id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="claim_idx")),
+                    left_on="tgt",
+                    right_on="id",
+                )
+            )
+            if len(merged) > 0:
+                data_dict = dict(
+                    src=merged.art_idx.tolist(), tgt=merged.claim_idx.tolist()
+                )
+                rel_df = pd.DataFrame(data_dict)
+            else:
+                rel_df = pd.DataFrame()
+
+        return rel_df
+
+    def _update_user_follows_user(
+        self, rel_df: pd.DataFrame, user_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Update the (:User)-[:FOLLOWS]->(:User) relation.
+
+        Args:
+            rel_df (pd.DataFrame): The relation dataframe.
+            user_df (pd.DataFrame): The user dataframe.
+
+        Returns:
+            pd.DataFrame: The updated relation dataframe.
+        """
+        if len(rel_df) > 0:
+            merged = (
+                rel_df.astype(dict(src=np.uint64, tgt=np.uint64))
+                .merge(
+                    user_df[["user_id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="user_idx1")),
+                    left_on="src",
+                    right_on="user_id",
+                )
+                .merge(
+                    user_df[["user_id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="user_idx2")),
+                    left_on="tgt",
+                    right_on="user_id",
+                )
+            )
+            if len(merged) > 0:
+                data_dict = dict(
+                    src=merged.user_idx1.tolist(), tgt=merged.user_idx2.tolist()
+                )
+                rel_df = pd.DataFrame(data_dict)
+            else:
+                rel_df = pd.DataFrame()
+
+        return rel_df
+
+    def _update_reply_reply_to_tweet(
+        self, rel_df: pd.DataFrame, reply_df: pd.DataFrame, tweet_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Update the (:Reply)-[:REPLY_TO]->(:Tweet) relation.
+
+        Args:
+            rel_df (pd.DataFrame): The relation dataframe.
+            reply_df (pd.DataFrame): The reply dataframe.
+            tweet_df (pd.DataFrame): The tweet dataframe.
+
+        Returns:
+            pd.DataFrame: The updated relation dataframe.
+        """
+        if len(rel_df) > 0:
+            merged = (
+                rel_df.astype(dict(src=np.uint64, tgt=np.uint64))
+                .merge(
+                    reply_df[["tweet_id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="reply_idx")),
+                    left_on="src",
+                    right_on="tweet_id",
+                )
+                .merge(
+                    tweet_df[["tweet_id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="tweet_idx")),
+                    left_on="tgt",
+                    right_on="tweet_id",
+                )
+            )
+            if len(merged) > 0:
+                data_dict = dict(
+                    src=merged.reply_idx.tolist(), tgt=merged.tweet_idx.tolist()
+                )
+                rel_df = pd.DataFrame(data_dict)
+            else:
+                rel_df = pd.DataFrame()
+
+        return rel_df
+
+    def _update_reply_quote_of_tweet(
+        self, rel_df: pd.DataFrame, reply_df: pd.DataFrame, tweet_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Update the (:Reply)-[:QUOTE_OF]->(:Tweet) relation.
+
+        Args:
+            rel_df (pd.DataFrame): The relation dataframe.
+            reply_df (pd.DataFrame): The reply dataframe.
+            tweet_df (pd.DataFrame): The tweet dataframe.
+
+        Returns:
+            pd.DataFrame: The updated relation dataframe.
+        """
+        if len(rel_df) > 0:
+            merged = (
+                rel_df.astype(dict(src=np.uint64, tgt=np.uint64))
+                .merge(
+                    reply_df[["tweet_id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="reply_idx")),
+                    left_on="src",
+                    right_on="tweet_id",
+                )
+                .merge(
+                    tweet_df[["tweet_id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="tweet_idx")),
+                    left_on="tgt",
+                    right_on="tweet_id",
+                )
+            )
+            if len(merged) > 0:
+                data_dict = dict(
+                    src=merged.reply_idx.tolist(), tgt=merged.tweet_idx.tolist()
+                )
+                rel_df = pd.DataFrame(data_dict)
+            else:
+                rel_df = pd.DataFrame()
+
+        return rel_df
+
+    def _update_user_retweeted_tweet(
+        self, rel_df: pd.DataFrame, user_df: pd.DataFrame, tweet_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Update the (:User)-[:RETWEETED]->(:Tweet) relation.
+
+        Args:
+            rel_df (pd.DataFrame): The relation dataframe.
+            user_df (pd.DataFrame): The user dataframe.
+            tweet_df (pd.DataFrame): The tweet dataframe.
+
+        Returns:
+            pd.DataFrame: The updated relation dataframe.
+        """
+        if len(rel_df) > 0:
+            merged = (
+                rel_df.astype(dict(src=np.uint64, tgt=np.uint64))
+                .merge(
+                    user_df[["user_id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="user_idx")),
+                    left_on="src",
+                    right_on="user_id",
+                )
+                .merge(
+                    tweet_df[["tweet_id"]]
+                    .reset_index()
+                    .rename(columns=dict(index="tweet_idx")),
+                    left_on="tgt",
+                    right_on="tweet_id",
+                )
+            )
+            if len(merged) > 0:
+                data_dict = dict(
+                    src=merged.user_idx.tolist(), tgt=merged.tweet_idx.tolist()
+                )
+                rel_df = pd.DataFrame(data_dict)
+            else:
+                rel_df = pd.DataFrame()
+
+        return rel_df
+
+    def _remove_id_column(self, node_df: pd.DataFrame) -> pd.DataFrame:
+        """Remove the id column from the node dataframe.
+
+        Args:
+            node_df (pd.DataFrame): The node dataframe.
+
+        Returns:
+            pd.DataFrame: The node dataframe without the id column.
+        """
+        if len(node_df) > 0:
+            node_df = node_df.drop(columns="id")
+        return node_df

src/mumin/image.py

@@ -0,0 +1,56 @@
+"""Functions related to processing images"""
+
+import io
+import time
+import warnings
+from typing import Union
+
+import numpy as np
+import requests
+from PIL import Image
+from wrapt_timeout_decorator.wrapt_timeout_decorator import timeout
+
+
+@timeout(10)
+def download_image_with_timeout(url: str) -> np.ndarray:
+    while True:
+        # Get the data from the URL, and try again if it fails
+        response = requests.get(url)
+        if response.status_code != 200:
+            time.sleep(1)
+            continue
+
+        # Convert the data to a NumPy array
+        byte_file = io.BytesIO(response.content)
+        image = np.asarray(Image.open(byte_file), dtype=np.uint8)
+        return image
+
+
+def process_image_url(url: str) -> Union[None, dict]:
+    """Process the URL and extract the article.
+
+    Args:
+        url (str): The URL.
+
+    Returns:
+        dict or None:
+            The processed article, or None if the URL could not be parsed.
+    """
+    # Ignore warnings while processing images
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+
+        try:
+            image = download_image_with_timeout(url)
+        except:  # noqa
+            return None
+
+        if image is None:
+            return None
+        else:
+            try:
+                return dict(
+                    url=url, pixels=image, height=image.shape[0], width=image.shape[1]
+                )
+            except IndexError:
+                return None

src/mumin/twitter.py

@@ -0,0 +1,276 @@
+"""Wrapper for the Twitter API"""
+
+import logging
+import time
+from json import JSONDecodeError
+from typing import Dict, List, Union
+
+import numpy as np
+import pandas as pd
+import requests
+from tqdm.auto import tqdm
+
+logger = logging.getLogger(__name__)
+
+
+class Twitter:
+    """A wrapper for the Twitter API.
+
+    Args:
+        twitter_bearer_token (str):
+            The bearer token from the Twitter API.
+    """
+
+    tweet_lookup_url: str = "https://api.twitter.com/2/tweets"
+
+    def __init__(self, twitter_bearer_token: str):
+        self.api_key = twitter_bearer_token
+        self.headers = dict(Authorization=f"Bearer {self.api_key}")
+        self.expansions = [
+            "attachments.poll_ids",
+            "attachments.media_keys",
+            "author_id",
+            "entities.mentions.username",
+            "geo.place_id",
+            "in_reply_to_user_id",
+            "referenced_tweets.id",
+            "referenced_tweets.id.author_id",
+        ]
+        self.tweet_fields = [
+            "attachments",
+            "author_id",
+            "conversation_id",
+            "created_at",
+            "entities",
+            "geo",
+            "id",
+            "in_reply_to_user_id",
+            "lang",
+            "public_metrics",
+            "possibly_sensitive",
+            "referenced_tweets",
+            "reply_settings",
+            "source",
+            "text",
+            "withheld",
+        ]
+        self.user_fields = [
+            "created_at",
+            "description",
+            "entities",
+            "id",
+            "location",
+            "name",
+            "pinned_tweet_id",
+            "profile_image_url",
+            "protected",
+            "public_metrics",
+            "url",
+            "username",
+            "verified",
+            "withheld",
+        ]
+        self.media_fields = [
+            "duration_ms",
+            "height",
+            "media_key",
+            "preview_image_url",
+            "type",
+            "url",
+            "width",
+            "public_metrics",
+        ]
+        self.place_fields = [
+            "contained_within",
+            "country",
+            "country_code",
+            "full_name",
+            "geo",
+            "id",
+            "name",
+            "place_type",
+        ]
+        self.poll_fields = [
+            "duration_minutes",
+            "end_datetime",
+            "id",
+            "options",
+            "voting_status",
+        ]
+
+    def rehydrate_tweets(
+        self, tweet_ids: List[Union[str, np.uint64]]
+    ) -> Dict[str, pd.DataFrame]:
+        """Rehydrates the tweets for the given tweet IDs.
+
+        Args:
+            tweet_ids (list of either str or uint64):
+                The tweet IDs to rehydrate.
+
+        Returns:
+            dict:
+                A dictionary with keys 'tweets', 'users', 'media', 'polls' and
+                'places', where the values are the associated Pandas DataFrame objects.
+        """
+        # Ensure that the tweet IDs are strings
+        tweet_ids = list(map(str, tweet_ids))
+
+        # Set up the params for the GET request
+        get_params = {
+            "expansions": ",".join(self.expansions),
+            "media.fields": ",".join(self.media_fields),
+            "place.fields": ",".join(self.place_fields),
+            "poll.fields": ",".join(self.poll_fields),
+            "tweet.fields": ",".join(self.tweet_fields),
+            "user.fields": ",".join(self.user_fields),
+        }
+
+        # Split `tweet_ids` into batches of at most 100, as this is the maximum number
+        # allowed by the API
+        num_batches = len(tweet_ids) // 100
+        if len(tweet_ids) % 100 != 0:
+            num_batches += 1
+        batches = np.array_split(tweet_ids, num_batches)
+
+        # Initialise dataframes
+        tweet_df = pd.DataFrame()
+        user_df = pd.DataFrame()
+        media_df = pd.DataFrame()
+        poll_df = pd.DataFrame()
+        place_df = pd.DataFrame()
+
+        # Initialise progress bar
+        if len(batches) > 1:
+            pbar = tqdm(total=len(tweet_ids), desc="Rehydrating")
+
+        # Loop over all the batches
+        for batch in batches:
+
+            # Add the batch tweet IDs to the batch
+            get_params["ids"] = ",".join(batch)
+
+            # Perform the GET request
+            try:
+                response = requests.get(
+                    self.tweet_lookup_url, params=get_params, headers=self.headers
+                )
+            except requests.exceptions.RequestException as e:
+                logger.error(
+                    f"[{e}] Error in rehydrating tweets.\nThe "
+                    f"parameters used were {get_params}."
+                )
+                continue
+
+            # If we have reached the API limit then wait a bit and try again
+            while response.status_code in [429, 503]:
+                logger.debug("Request limit reached. Waiting...")
+                time.sleep(1)
+                try:
+                    response = requests.get(
+                        self.tweet_lookup_url, params=get_params, headers=self.headers
+                    )
+                except requests.exceptions.RequestException as e:
+                    logger.error(
+                        f"[{e}] Error in rehydrating tweets.\nThe "
+                        f"parameters used were {get_params}."
+                    )
+                    continue
+
+            # If we are not authorised then continue to the next batch
+            if response.status_code == 401:
+                continue
+
+            # If the GET request failed then continue to the next batch
+            elif response.status_code != 200:
+                logger.error(f"[{response.status_code}] {response.content!r}")
+                continue
+
+            # Convert the response to a dict
+            try:
+                data_dict = response.json()
+            except JSONDecodeError as e:
+                logger.error(
+                    f"[{e}] Error in unpacking tweets.\nThe "
+                    f"parameters used were {get_params}."
+                )
+                continue
+
+            # If the query returned errors then continue to the next batch
+            if "data" not in data_dict and "errors" in data_dict:
+                error = data_dict["errors"][0]
+                logger.error(error["detail"])
+                continue
+
+            # Tweet dataframe
+            if "data" in data_dict:
+                df = pd.json_normalize(data_dict["data"]).rename(
+                    columns=dict(id="tweet_id")
+                )
+                tweet_df = (
+                    pd.concat((tweet_df, df))
+                    .drop_duplicates(subset="tweet_id")
+                    .astype(dict(tweet_id=np.uint64))
+                    .reset_index(drop=True)
+                )
+
+            # User dataframe
+            if "includes" in data_dict and "users" in data_dict["includes"]:
+                users = data_dict["includes"]["users"]
+                df = pd.json_normalize(users).rename(columns=dict(id="user_id"))
+                user_df = (
+                    pd.concat((user_df, df))
+                    .drop_duplicates(subset="user_id")
+                    .astype(dict(user_id=np.uint64))
+                    .reset_index(drop=True)
+                )
+
+            # Media dataframe
+            if "includes" in data_dict and "media" in data_dict["includes"]:
+                media = data_dict["includes"]["media"]
+                df = pd.json_normalize(media)
+                media_df = (
+                    pd.concat((media_df, df))
+                    .drop_duplicates(subset="media_key")
+                    .reset_index(drop=True)
+                )
+
+            # Poll dataframe
+            if "includes" in data_dict and "polls" in data_dict["includes"]:
+                polls = data_dict["includes"]["polls"]
+                df = pd.json_normalize(polls).rename(columns=dict(id="poll_id"))
+                poll_df = (
+                    pd.concat((poll_df, df))
+                    .drop_duplicates(subset="poll_id")
+                    .astype(dict(poll_id=np.uint64))
+                    .reset_index(drop=True)
+                )
+
+            # Places dataframe
+            if "includes" in data_dict and "places" in data_dict["includes"]:
+                places = data_dict["includes"]["places"]
+                df = pd.json_normalize(places).rename(columns=dict(id="place_id"))
+                place_df = (
+                    pd.concat((place_df, df))
+                    .drop_duplicates(subset="place_id")
+                    .reset_index(drop=True)
+                )
+
+            # Update the progress bar
+            if len(batches) > 1:
+                pbar.update(len(batch))
+
+        # Close the progress bar
+        if len(batches) > 1:
+            pbar.close()
+
+        # Collect all the resulting dataframes
+        all_dfs = dict(
+            tweets=tweet_df,
+            users=user_df,
+            media=media_df,
+            polls=poll_df,
+            places=place_df,
+        )
+
+        # Return the dictionary containing all the dataframes
+        return all_dfs

src/scripts/compile_mumin.py

@@ -0,0 +1,32 @@
+"""Compilation of the MuMin datasets."""
+
+import logging
+import os
+import sys
+
+from dotenv import load_dotenv
+
+from src.mumin import MuminDataset
+
+load_dotenv()
+
+
+def compile_mumin(size: str = "small") -> MuminDataset:
+    """Compile the MuMiN dataset.
+
+    Args:
+        size (str):
+            The size of the dataset to compile. Can be "small", "medium", or "large".
+    """
+    logging.info(f"Compiling {size} MuMin dataset...")
+    bearer_token = str(os.getenv("TWITTER_API_KEY"))
+    dataset = MuminDataset(twitter_bearer_token=bearer_token, size=size)
+    dataset.compile()
+    return dataset
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        dataset = compile_mumin(sys.argv[1])
+    else:
+        dataset = compile_mumin()

src/scripts/fix_dot_env_file.py

@@ -0,0 +1,68 @@
+"""Checks related to the .env file in the repository."""
+
+import subprocess
+from pathlib import Path
+
+# List of all the environment variables that are desired
+DESIRED_ENVIRONMENT_VARIABLES = dict(
+    GPG_KEY_ID="Enter GPG key ID or leave empty if you do not want to use it. Type "
+    "`gpg --list-secret-keys --keyid-format=long | grep sec | sed -E "
+    "'s/.*\/([^ ]+).*/\\1/'` to see your key ID:\n> ",  # noqa
+    GIT_NAME="Enter your full name, to be shown in Git commits:\n> ",
+    GIT_EMAIL="Enter your email, as registered on your Github account:\n> ",
+    PYPI_API_TOKEN="Enter your PyPI API token, or leave empty if you do not want "
+    "to use it:\n> ",
+)
+
+
+def fix_dot_env_file():
+    """Ensures that the .env file exists and contains all desired variables."""
+    # Create path to the .env file
+    env_file_path = Path(".env")
+
+    # Ensure that the .env file exists
+    env_file_path.touch(exist_ok=True)
+
+    # Otherwise, extract all the lines in the .env file
+    env_file_lines = env_file_path.read_text().splitlines(keepends=False)
+
+    # Extract all the environment variables in the .env file
+    env_vars = [line.split("=")[0] for line in env_file_lines]
+
+    # For each of the desired environment variables, check if it exists in the .env
+    # file
+    env_vars_missing = [
+        env_var
+        for env_var in DESIRED_ENVIRONMENT_VARIABLES.keys()
+        if env_var not in env_vars
+    ]
+
+    # Create all the missing environment variables
+    with env_file_path.open("a") as f:
+        for env_var in env_vars_missing:
+            value = ""
+            if env_var == "GPG_KEY_ID":
+                gpg = subprocess.Popen(
+                    ["gpg", "--list-secret-keys", "--keyid-format=long"],
+                    stdout=subprocess.PIPE,
+                )
+                grep = subprocess.Popen(
+                    ["grep", "sec"], stdin=gpg.stdout, stdout=subprocess.PIPE
+                )
+                value = (
+                    subprocess.check_output(
+                        ["sed", "-E", "s/.*\\/([^ ]+).*/\\1/"],
+                        stdin=grep.stdout,
+                    )
+                    .decode()
+                    .strip("\n")
+                )
+                gpg.wait()
+                grep.wait()
+            if value == "":
+                value = input(DESIRED_ENVIRONMENT_VARIABLES[env_var])
+            f.write(f'{env_var}="{value}"\n')
+
+
+if __name__ == "__main__":
+    fix_dot_env_file()

src/scripts/versioning.py

@@ -0,0 +1,134 @@
+"""Scripts related to updating of version."""
+
+import datetime as dt
+import re
+import subprocess
+from pathlib import Path
+from typing import Tuple
+
+
+def bump_major():
+    """Add one to the major version."""
+    major, _, _ = get_current_version()
+    set_new_version(major + 1, 0, 0)
+
+
+def bump_minor():
+    """Add one to the minor version."""
+    major, minor, _ = get_current_version()
+    set_new_version(major, minor + 1, 0)
+
+
+def bump_patch():
+    """Add one to the patch version."""
+    major, minor, patch = get_current_version()
+    set_new_version(major, minor, patch + 1)
+
+
+def set_new_version(major: int, minor: int, patch: int):
+    """Sets a new version.
+
+    Args:
+        major (int):
+            The major version. This only changes when the code stops being backwards
+            compatible.
+        minor (int):
+            The minor version. This changes when a backwards compatible change
+            happened.
+        patch (init):
+            The patch version. This changes when the only new changes are bug fixes.
+    """
+    version = f"{major}.{minor}.{patch}"
+
+    # Get current changelog and ensure that it has an [Unreleased] entry
+    changelog_path = Path("CHANGELOG.md")
+    changelog = changelog_path.read_text()
+    if "[Unreleased]" not in changelog:
+        raise RuntimeError("No [Unreleased] entry in CHANGELOG.md.")
+
+    # Add version to CHANGELOG
+    today = dt.date.today().strftime("%Y-%m-%d")
+    new_changelog = re.sub(r"\[Unreleased\].*", f"[v{version}] - {today}", changelog)
+    changelog_path.write_text(new_changelog)
+
+    # Update the version in the `pyproject.toml` file
+    pyproject_path = Path("pyproject.toml")
+    pyproject = pyproject_path.read_text()
+    pyproject = re.sub(
+        r'version = "[^"]+"',
+        f'version = "{version}"',
+        pyproject,
+        count=1,
+    )
+    pyproject_path.write_text(pyproject)
+
+    # Add to version control
+    subprocess.run(["git", "add", "CHANGELOG.md"])
+    subprocess.run(["git", "add", "pyproject.toml"])
+    subprocess.run(["git", "commit", "-m", f"feat: v{version}"])
+    subprocess.run(["git", "tag", f"v{version}"])
+    subprocess.run(["git", "push"])
+    subprocess.run(["git", "push", "--tags"])
+
+
+def get_current_version() -> Tuple[int, int, int]:
+    """Fetch the current version of the package.
+
+    Returns:
+        triple of ints:
+            The current version, separated into major, minor and patch versions.
+    """
+    # Get all the version candidates from pyproject.toml
+    version_candidates = re.search(
+        r'(?<=version = ")[^"]+(?=")', Path("pyproject.toml").read_text()
+    )
+
+    # If no version candidates were found, raise an error
+    if version_candidates is None:
+        raise RuntimeError("No version found in pyproject.toml.")
+
+    # Otherwise, extract the version, split it into major, minor and patch parts and
+    # return these
+    else:
+        version_str = version_candidates.group(0)
+        major, minor, patch = map(int, version_str.split("."))
+        return major, minor, patch
+
+
+if __name__ == "__main__":
+    from argparse import ArgumentParser
+
+    parser = ArgumentParser()
+    parser.add_argument(
+        "--major",
+        const=True,
+        nargs="?",
+        default=False,
+        help="Bump the major version by one.",
+    )
+    parser.add_argument(
+        "--minor",
+        const=True,
+        nargs="?",
+        default=False,
+        help="Bump the minor version by one.",
+    )
+    parser.add_argument(
+        "--patch",
+        const=True,
+        nargs="?",
+        default=False,
+        help="Bump the patch version by one.",
+    )
+    args = parser.parse_args()
+
+    if args.major + args.minor + args.patch != 1:
+        raise RuntimeError(
+            "Exactly one of --major, --minor and --patch must be selected."
+        )
+    elif args.major:
+        bump_major()
+    elif args.minor:
+        bump_minor()
+    elif args.patch:
+        bump_patch()

tests/test_article.py

@@ -0,0 +1,90 @@
+"""Unit tests for the `article` module."""
+
+import pytest
+from newspaper import Article
+
+from mumin.article import download_article_with_timeout, process_article_url
+
+WORKING_URL: str = "https://www.bbc.com/news/62261164"
+BAD_GATEWAY_URL: str = (
+    "https://www.diariodocentrodomundo.com.br/finlandia-tera-jornada-"
+    "de-trabalho-de-seis-horas-quatro-dias-por-semana"
+)
+BIG_FILE_URL: str = (
+    "https://filedn.com/lRBwPhPxgV74tO0rDoe8SpH/scholarly_data/arxiv_data.db"
+)
+
+
+@pytest.mark.parametrize(
+    argnames="url, has_html",
+    argvalues=[
+        (WORKING_URL, True),
+        (BAD_GATEWAY_URL, True),
+        (BIG_FILE_URL, False),
+    ],
+    ids=["working_url", "bad_gateway_url", "big_file_url"],
+)
+def test_download_article(url, has_html):
+    article = Article(url)
+    assert article.html == ""
+    article = download_article_with_timeout(article)
+    assert isinstance(article, Article)
+    if has_html:
+        assert article.html != ""
+    else:
+        assert article.html == ""
+
+
+def test_process_article_url_bad_url():
+    assert process_article_url(BIG_FILE_URL) is None
+
+
+@pytest.mark.parametrize(
+    argnames="article_config",
+    argvalues=[
+        dict(
+            url=WORKING_URL,
+            title="Capitol riot: Trump ignored pleas to condemn attack, hearing told",
+            authors=[],
+            publish_date=None,
+            top_image_url="https://ichef.bbci.co.uk/news/1024/branded_news/11A62/"
+            "production/_126009227_capitol_riot_2_getty.jpg",
+        ),
+        dict(
+            url=BAD_GATEWAY_URL,
+            title="Finlândia terá jornada de trabalho de seis horas, quatro "
+            "dias por semana",
+            authors=["Diario Do Centro Do Mundo", "Publicado Por"],
+            publish_date="2020-01-06",
+            top_image_url="https://www.diariodocentrodomundo.com.br/wp-content/"
+            "uploads/2019/12/premie.jpg",
+        ),
+    ],
+    ids=[
+        "working_url",
+        "bad_gateway_url",
+    ],
+    scope="class",
+)
+class TestProcessArticleUrl:
+    @pytest.fixture(scope="class")
+    def processed_article(self, article_config):
+        yield process_article_url(article_config["url"])
+
+    def test_is_dict(self, processed_article, article_config):
+        assert isinstance(processed_article, dict)
+
+    def test_url(self, processed_article, article_config):
+        assert processed_article["url"] == article_config["url"]
+
+    def test_title(self, processed_article, article_config):
+        assert processed_article["title"] == article_config["title"]
+
+    def test_authors(self, processed_article, article_config):
+        assert processed_article["authors"] == article_config["authors"]
+
+    def test_publish_date(self, processed_article, article_config):
+        assert processed_article["publish_date"] == article_config["publish_date"]
+
+    def test_top_image_url(self, processed_article, article_config):
+        assert processed_article["top_image_url"] == article_config["top_image_url"]

tests/test_data_extractor.py

@@ -0,0 +1 @@
+"""Unit tests for the `data_extractor` module."""

tests/test_dataset.py

@@ -0,0 +1,132 @@
+"""Unit tests for the `dataset` module."""
+
+import os
+import warnings
+from copy import deepcopy
+from pathlib import Path
+
+import pytest
+from dotenv import load_dotenv
+
+from mumin import MuminDataset, load_dgl_graph, save_dgl_graph
+
+load_dotenv()
+
+
+class TestMuminDataset:
+    @pytest.fixture(scope="class")
+    def dataset(self):
+        yield MuminDataset(str(os.getenv("TWITTER_API_KEY")), size="test", verbose=True)
+
+    @pytest.fixture(scope="class")
+    def compiled_dataset(self, dataset):
+        yield dataset.compile(overwrite=True)
+
+    @pytest.fixture(scope="class")
+    def dataset_with_embeddings(self, compiled_dataset):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", category=DeprecationWarning)
+            copied_dataset = deepcopy(compiled_dataset)
+            copied_dataset.add_embeddings()
+            yield copied_dataset
+
+    @pytest.fixture(scope="class")
+    def dgl_graph(self, compiled_dataset):
+        yield compiled_dataset.to_dgl()
+
+    @pytest.fixture(scope="class")
+    def dgl_graph_path(self):
+        yield Path("data/mumin-test.dgl")
+
+    def test_nodes_and_rels_are_empty_dicts(self, dataset):
+        assert dataset.nodes == dict()
+        assert dataset.rels == dict()
+
+    def test_initialize_dataset_without_bearer_token(self, dataset):
+        new_dataset = MuminDataset(size="test")
+        assert dataset._twitter.api_key == new_dataset._twitter.api_key
+
+    @pytest.mark.parametrize(
+        argnames="node_type",
+        argvalues=["claim", "tweet", "reply", "user", "article", "image", "hashtag"],
+        ids=["claim", "tweet", "reply", "user", "article", "image", "hashtag"],
+    )
+    def test_compiled_dataset_contains_node_type(self, compiled_dataset, node_type):
+        assert node_type in compiled_dataset.nodes.keys()
+        assert len(compiled_dataset.nodes[node_type]) > 0
+
+    @pytest.mark.parametrize(
+        argnames="rel_type",
+        argvalues=[
+            ("tweet", "discusses", "claim"),
+            ("tweet", "has_hashtag", "hashtag"),
+            ("tweet", "has_article", "article"),
+            ("reply", "reply_to", "tweet"),
+            ("reply", "quote_of", "tweet"),
+            ("user", "posted", "tweet"),
+            ("user", "posted", "reply"),
+            ("user", "mentions", "user"),
+            ("tweet", "has_image", "image"),
+        ],
+        ids=[
+            "tweet_discusses_claim",
+            "tweet_has_hashtag_hashtag",
+            "tweet_has_article_article",
+            "reply_reply_to_tweet",
+            "reply_quote_of_tweet",
+            "user_posted_tweet",
+            "user_posted_reply",
+            "user_mentions_user",
+            "tweet_has_image_image",
+        ],
+    )
+    def test_compiled_dataset_contains_rel_type(self, compiled_dataset, rel_type):
+        assert rel_type in compiled_dataset.rels.keys()
+        assert len(compiled_dataset.rels[rel_type]) > 0
+
+    @pytest.mark.skip(reason="DGL not available")
+    def test_to_dgl(self, dgl_graph):
+        from dgl import DGLHeteroGraph
+
+        assert isinstance(dgl_graph, DGLHeteroGraph)
+
+    @pytest.mark.skip(reason="DGL not available")
+    def test_save_dgl(self, dgl_graph, dgl_graph_path):
+        if dgl_graph_path.exists():
+            dgl_graph_path.unlink()
+        save_dgl_graph(dgl_graph, dgl_graph_path)
+        assert dgl_graph_path.exists()
+
+    @pytest.mark.skip(reason="DGL not available")
+    def test_load_dgl(self, dgl_graph_path):
+        from dgl import DGLHeteroGraph
+
+        if dgl_graph_path.exists():
+            dgl_graph = load_dgl_graph(dgl_graph_path)
+            assert isinstance(dgl_graph, DGLHeteroGraph)
+            dgl_graph_path.unlink()
+
+    @pytest.mark.parametrize(
+        argnames="node_type, embedding_name",
+        argvalues=[
+            ("tweet", "text_emb"),
+            ("reply", "text_emb"),
+            ("user", "description_emb"),
+            ("article", "content_emb"),
+            ("image", "pixels_emb"),
+            ("claim", "reviewer_emb"),
+        ],
+        ids=[
+            "tweet",
+            "reply",
+            "user",
+            "article",
+            "image",
+            "claim",
+        ],
+    )
+    def test_embed(self, dataset_with_embeddings, node_type, embedding_name):
+        assert (
+            len(dataset_with_embeddings.nodes[node_type]) == 0
+            or embedding_name in dataset_with_embeddings.nodes[node_type].columns
+        )

tests/test_dgl.py

@@ -0,0 +1 @@
+"""Unit tests for the `dgl` module."""

tests/test_embedder.py

@@ -0,0 +1 @@
+"""Unit tests for the `embedder` module."""

tests/test_id_updator.py

@@ -0,0 +1 @@
+"""Unit tests for the `id_updator` module."""

tests/test_image.py

@@ -0,0 +1 @@
+"""Unit tests for the `image` module."""

tests/test_twitter.py

@@ -0,0 +1 @@
+"""Unit tests for the `twitter` module."""