DeepMoji xVASynth Plugin

app.py

@@ -115,7 +115,6 @@ def run_xvaserver():
 
 	# load default model
 	load_model(voice_models[0])
-	current_voice_model = voice_models[0]
 
 	# Wait for the process to exit
 	xvaserver.wait()
@@ -145,6 +144,8 @@ def load_model(voice_model_name):
 	return
 
 def predict(input_text, pacing, voice, lang):
+	# grab only the first 1000 characters
+	input_text = input_text[:1000]
 
 	# load voice model if not the current model
 	if (current_voice_model != voice):

resources/app/plugins.txt

@@ -0,0 +1 @@
+*deepmoji_plugin

resources/app/plugins/deepmoji_plugin/DeepMoji/.gitignore

@@ -0,0 +1,108 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+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
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# IPython Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# dotenv
+.env
+
+# virtualenv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+
+# Rope project settings
+.ropeproject
+
+# Local data
+/data/local
+
+# Vim swapfiles
+*.swp
+*.swo
+
+# nosetests
+.noseids
+
+# pyTorch model
+pytorch_model.bin
+
+# VSCODE
+.vscode/*
+
+# data
+*.csv

resources/app/plugins/deepmoji_plugin/DeepMoji/.travis.yml

@@ -0,0 +1,27 @@
+group: travis_latest
+language: python
+cache: pip
+python:
+    - 2.7
+    - 3.6
+    #- nightly
+    #- pypy
+    #- pypy3
+matrix:
+    allow_failures:
+        - python: nightly
+        - python: pypy
+        - python: pypy3
+install:
+    #- pip install -r requirements.txt
+    - pip install flake8  # pytest  # add another testing frameworks later
+before_script:
+    # stop the build if there are Python syntax errors or undefined names
+    - flake8 . --count --select=E901,E999,F821,F822,F823 --show-source --statistics
+    # exit-zero treats all errors as warnings.  The GitHub editor is 127 chars wide
+    - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+script:
+    - true  # pytest --capture=sys  # add other tests here
+notifications:
+    on_success: change
+    on_failure: change  # `always` will be the setting once code changes slow down

resources/app/plugins/deepmoji_plugin/DeepMoji/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Bjarke Felbo, Han Thi Nguyen, Thomas Wolf
+
+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.

resources/app/plugins/deepmoji_plugin/DeepMoji/README.md

@@ -0,0 +1,90 @@
+### ------ Update September 2018 ------
+It's been a year since TorchMoji and DeepMoji were released. We're trying to understand how it's being used such that we can make improvements and design better models in the future. 
+
+You can help us achieve this by answering this [4-question Google Form](https://docs.google.com/forms/d/e/1FAIpQLSe1h4NSQD30YM8dsbJQEnki-02_9KVQD34qgP9to0bwAHBvBA/viewform "DeepMoji Google Form"). Thanks for your support!
+
+# 😇 TorchMoji
+
+> **Read our blog post about the implementation process [here](https://medium.com/huggingface/understanding-emotions-from-keras-to-pytorch-3ccb61d5a983).**
+
+TorchMoji is a [pyTorch](http://pytorch.org/) implementation of the [DeepMoji](https://github.com/bfelbo/DeepMoji) model developped by Bjarke Felbo, Alan Mislove, Anders Søgaard, Iyad Rahwan and Sune Lehmann.
+
+This model trained on 1.2 billion tweets with emojis to understand how language is used to express emotions. Through transfer learning the model can obtain state-of-the-art performance on many emotion-related text modeling tasks.
+
+Try the online demo of DeepMoji [http://deepmoji.mit.edu](http://deepmoji.mit.edu/)! See the [paper](https://arxiv.org/abs/1708.00524), [blog post](https://medium.com/@bjarkefelbo/what-can-we-learn-from-emojis-6beb165a5ea0) or [FAQ](https://www.media.mit.edu/projects/deepmoji/overview/) for more details.
+
+## Overview
+* [torchmoji/](torchmoji) contains all the underlying code needed to convert a dataset to the vocabulary and use the model.
+* [examples/](examples) contains short code snippets showing how to convert a dataset to the vocabulary, load up the model and run it on that dataset.
+* [scripts/](scripts) contains code for processing and analysing datasets to reproduce results in the paper.
+* [model/](model) contains the pretrained model and vocabulary.
+* [data/](data) contains raw and processed datasets that we include in this repository for testing.
+* [tests/](tests) contains unit tests for the codebase.
+
+To start out with, have a look inside the [examples/](examples) directory. See [score_texts_emojis.py](examples/score_texts_emojis.py) for how to use DeepMoji to extract emoji predictions, [encode_texts.py](examples/encode_texts.py) for how to convert text into 2304-dimensional emotional feature vectors or [finetune_youtube_last.py](examples/finetune_youtube_last.py) for how to use the model for transfer learning on a new dataset.
+
+Please consider citing the [paper](https://arxiv.org/abs/1708.00524) of DeepMoji if you use the model or code (see below for citation).
+
+## Installation
+
+Assuming you have [Conda](https://conda.io) installed, run:
+
+```bash
+conda create -n torchMoji -f environment.yml
+conda activate torchMoji
+pip install -e .
+```
+
+This will install the following dependencies:
+
+* [PyTorch](https://pytorch.org)
+* [scikit-learn](https://github.com/scikit-learn/scikit-learn)
+* [text-unidecode](https://github.com/kmike/text-unidecode)
+* [emoji](https://github.com/carpedm20/emoji)
+
+If you do not want to use Conda, please install `torch==1.3.1` from PIP and then run `pip install -e .` from the root directory (don't forget to set up a virtual environment).
+
+At the present stage the model can't make efficient use of CUDA. See details in the [Hugging Face blog post](https://medium.com/huggingface/understanding-emotions-from-keras-to-pytorch-3ccb61d5a983).
+
+Then, run the download script to downloads the pretrained torchMoji weights (~85MB) from [here](https://www.dropbox.com/s/q8lax9ary32c7t9/pytorch_model.bin?dl=0) and put them in the model/ directory:
+
+```bash
+python scripts/download_weights.py
+```
+
+## Testing
+To run the tests, install [nose](http://nose.readthedocs.io/en/latest/). After installing, navigate to the [tests/](tests) directory and run:
+
+```bash
+cd tests
+nosetests -v
+```
+
+By default, this will also run finetuning tests. These tests train the model for one epoch and then check the resulting accuracy, which may take several minutes to finish. If you'd prefer to exclude those, run the following instead:
+
+```bash
+cd tests
+nosetests -v -a '!slow'
+```
+
+## Disclaimer
+This code has been tested to work with Python 2.7 and 3.5 on Ubuntu 16.04 and macOS Sierra machines. It has not been optimized for efficiency, but should be fast enough for most purposes. We do not give any guarantees that there are no bugs - use the code on your own responsibility!
+
+## Contributions
+We welcome pull requests if you feel like something could be improved. You can also greatly help us by telling us how you felt when writing your most recent tweets. Just click [here](http://deepmoji.mit.edu/contribute/) to contribute.
+
+## License
+This code and the pretrained model is licensed under the MIT license.
+
+## Benchmark datasets
+The benchmark datasets are uploaded to this repository for convenience purposes only. They were not released by us and we do not claim any rights on them. Use the datasets at your responsibility and make sure you fulfill the licenses that they were released with. If you use any of the benchmark datasets please consider citing the original authors.
+
+## Citation
+```
+@inproceedings{felbo2017,
+  title={Using millions of emoji occurrences to learn any-domain representations for detecting sentiment, emotion and sarcasm},
+  author={Felbo, Bjarke and Mislove, Alan and S{\o}gaard, Anders and Rahwan, Iyad and Lehmann, Sune},
+  booktitle={Conference on Empirical Methods in Natural Language Processing (EMNLP)},
+  year={2017}
+}
+```

resources/app/plugins/deepmoji_plugin/DeepMoji/data/.gitkeep

@@ -0,0 +1 @@
+ 

resources/app/plugins/deepmoji_plugin/DeepMoji/data/emoji_codes.json

@@ -0,0 +1,67 @@
+{
+  "0": ":joy:",
+  "1": ":unamused:",
+  "2": ":weary:",
+  "3": ":sob:",
+  "4": ":heart_eyes:",
+  "5": ":pensive:",
+  "6": ":ok_hand:",
+  "7": ":blush:",
+  "8": ":heart:",
+  "9": ":smirk:",
+  "10":":grin:",
+  "11":":notes:",
+  "12":":flushed:",
+  "13":":100:",
+  "14":":sleeping:",
+  "15":":relieved:",
+  "16":":relaxed:",
+  "17":":raised_hands:",
+  "18":":two_hearts:",
+  "19":":expressionless:",
+  "20":":sweat_smile:",
+  "21":":pray:",
+  "22":":confused:",
+  "23":":kissing_heart:",
+  "24":":hearts:",
+  "25":":neutral_face:",
+  "26":":information_desk_person:",
+  "27":":disappointed:",
+  "28":":see_no_evil:",
+  "29":":tired_face:",
+  "30":":v:",
+  "31":":sunglasses:",
+  "32":":rage:",
+  "33":":thumbsup:",
+  "34":":cry:",
+  "35":":sleepy:",
+  "36":":stuck_out_tongue_winking_eye:",
+  "37":":triumph:",
+  "38":":raised_hand:",
+  "39":":mask:",
+  "40":":clap:",
+  "41":":eyes:",
+  "42":":gun:",
+  "43":":persevere:",
+  "44":":imp:",
+  "45":":sweat:",
+  "46":":broken_heart:",
+  "47":":blue_heart:",
+  "48":":headphones:",
+  "49":":speak_no_evil:",
+  "50":":wink:",
+  "51":":skull:",
+  "52":":confounded:",
+  "53":":smile:",
+  "54":":stuck_out_tongue_winking_eye:",
+  "55":":angry:",
+  "56":":no_good:",
+  "57":":muscle:",
+  "58":":punch:",
+  "59":":purple_heart:",
+  "60":":sparkling_heart:",
+  "61":":blue_heart:",
+  "62":":grimacing:",
+  "63":":sparkles:"
+}
+

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji-2.8.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji-2.8.0.dist-info/LICENSE.txt

@@ -0,0 +1,28 @@
+New BSD License
+
+Copyright (c) 2014-2023, Taehoon Kim, Kevin Wurster
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* The names of its contributors may not be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji-2.8.0.dist-info/METADATA

@@ -0,0 +1,182 @@
+Metadata-Version: 2.1
+Name: emoji
+Version: 2.8.0
+Summary: Emoji for Python
+Home-page: https://github.com/carpedm20/emoji/
+Author: Taehoon Kim, Kevin Wurster
+Author-email: [email protected]
+License: New BSD
+Keywords: emoji
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Multimedia :: Graphics :: Presentation
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
+License-File: LICENSE.txt
+Provides-Extra: dev
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: coverage ; extra == 'dev'
+Requires-Dist: coveralls ; extra == 'dev'
+
+Emoji
+=====
+
+Emoji for Python.  This project was inspired by `kyokomi <https://github.com/kyokomi/emoji>`__.
+
+
+Example
+-------
+
+The entire set of Emoji codes as defined by the `Unicode consortium <https://unicode.org/emoji/charts/full-emoji-list.html>`__
+is supported in addition to a bunch of `aliases <https://www.webfx.com/tools/emoji-cheat-sheet/>`__.  By
+default, only the official list is enabled but doing ``emoji.emojize(language='alias')`` enables
+both the full list and aliases.
+
+.. code-block:: python
+
+    >>> import emoji
+    >>> print(emoji.emojize('Python is :thumbs_up:'))
+    Python is 👍
+    >>> print(emoji.emojize('Python is :thumbsup:', language='alias'))
+    Python is 👍
+    >>> print(emoji.demojize('Python is 👍'))
+    Python is :thumbs_up:
+    >>> print(emoji.emojize("Python is fun :red_heart:"))
+    Python is fun ❤
+    >>> print(emoji.emojize("Python is fun :red_heart:", variant="emoji_type"))
+    Python is fun ❤️ #red heart, not black heart
+    >>> print(emoji.is_emoji("👍"))
+    True
+
+..
+
+By default, the language is English (``language='en'``) but also supported languages are:
+
+* Spanish (``'es'``)
+* Portuguese (``'pt'``)
+* Italian (``'it'``)
+* French (``'fr'``)
+* German (``'de'``)
+* Farsi/Persian (``'fa'``)
+* Indonesian (``'id'``)
+* Simplified Chinese (``'zh'``)
+* Japanese (``'ja'``)
+* Korean (``'ko'``)
+
+
+.. code-block:: python
+
+    >>> print(emoji.emojize('Python es :pulgar_hacia_arriba:', language='es'))
+    Python es 👍
+    >>> print(emoji.demojize('Python es 👍', language='es'))
+    Python es :pulgar_hacia_arriba:
+    >>> print(emoji.emojize("Python é :polegar_para_cima:", language='pt'))
+    Python é 👍
+    >>> print(emoji.demojize("Python é 👍", language='pt'))
+    Python é :polegar_para_cima:️
+
+..
+
+Installation
+------------
+
+Via pip:
+
+.. code-block:: console
+
+    $ python -m pip install emoji --upgrade
+
+From master branch:
+
+.. code-block:: console
+
+    $ git clone https://github.com/carpedm20/emoji.git
+    $ cd emoji
+    $ python -m pip install .
+
+
+Developing
+----------
+
+.. code-block:: console
+
+    $ git clone https://github.com/carpedm20/emoji.git
+    $ cd emoji
+    $ python -m pip install -e .\[dev\]
+    $ pytest
+    $ coverage run -m pytest
+    $ coverage report
+
+The ``utils/get_codes_from_unicode_emoji_data_files.py`` is used to generate
+``unicode_codes/data_dict.py``. Generally speaking it scrapes a table on the
+`Unicode Consortium's website <https://www.unicode.org/reports/tr51/#emoji_data>`__
+with `BeautifulSoup <http://www.crummy.com/software/BeautifulSoup/>`__
+and prints the contents to ``stdout`` as a Python dictionary. For more
+information take a look in the `utils/README.md <utils/README.md>`__ file.
+
+
+Links
+-----
+
+**Documentation**
+
+`https://carpedm20.github.io/emoji/docs/ <https://carpedm20.github.io/emoji/docs/>`__
+
+**Overview of all emoji:**
+
+`https://carpedm20.github.io/emoji/ <https://carpedm20.github.io/emoji/>`__
+
+(auto-generated list of the emoji that are supported by the current version of this package)
+
+**For English:**
+
+`Emoji Cheat Sheet <https://www.webfx.com/tools/emoji-cheat-sheet/>`__
+
+`Official Unicode list <http://www.unicode.org/emoji/charts/full-emoji-list.html>`__
+
+**For Spanish:**
+
+`Unicode list <https://emojiterra.com/es/lista-es/>`__
+
+**For Portuguese:**
+
+`Unicode list <https://emojiterra.com/pt/lista/>`__
+
+**For Italian:**
+
+`Unicode list <https://emojiterra.com/it/lista-it/>`__
+
+**For French:**
+
+`Unicode list <https://emojiterra.com/fr/liste-fr/>`__
+
+**For German:**
+
+`Unicode list <https://emojiterra.com/de/liste/>`__
+
+
+Authors
+-------
+
+Taehoon Kim / `@carpedm20 <http://carpedm20.github.io/about/>`__
+
+Kevin Wurster / `@geowurster <http://twitter.com/geowurster/>`__
+
+Maintainer
+----------
+Tahir Jalilov / `@TahirJalilov <https://github.com/TahirJalilov>`__

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji-2.8.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+emoji-2.8.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+emoji-2.8.0.dist-info/LICENSE.txt,sha256=4MY4T6OKBxBrTgAP-CcWXbBrXfB0AbsWoYWJIcg4B8w,1483
+emoji-2.8.0.dist-info/METADATA,sha256=KN7KUqGmtWikpf_Y_xyy1_QKQjnm848vLMZvHAno5S4,5279
+emoji-2.8.0.dist-info/RECORD,,
+emoji-2.8.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+emoji-2.8.0.dist-info/WHEEL,sha256=m9WAupmBd2JGDsXWQGJgMGXIWbQY3F5c2xBJbBhq0nY,110
+emoji-2.8.0.dist-info/top_level.txt,sha256=UxKwtYLYBTA8ldfisbxvrXDgSz3eVBOq51i2h2ewato,6
+emoji-2.8.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+emoji/__init__.py,sha256=oTfIYyWbRTIasfAY9smrDjojv4-B1IZ9Iyvb3byY2-Q,2358
+emoji/__init__.pyi,sha256=1cDfESqCdRhx5WZoqibhao3maHpYXzE6hnfVV3PM4RY,929
+emoji/__pycache__/__init__.cpython-311.pyc,,
+emoji/__pycache__/core.cpython-311.pyc,,
+emoji/__pycache__/tokenizer.cpython-311.pyc,,
+emoji/core.py,sha256=W82lTuBGprXACnB4DEr3Lm8gbA5gV4JCgLnzPCxyBSk,13856
+emoji/core.pyi,sha256=c_Zl07Rk9sVK_ZI3LMzPMgYfYHtGWn2JIftyCzzf9a4,1310
+emoji/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+emoji/tokenizer.py,sha256=AXEgXpxdL_RYmRCl_Xl8m5jDQlN3hyXi6QN2fV6m104,11876
+emoji/tokenizer.pyi,sha256=s76ejAXHxd9lNs4h4ey7MCBHLfeJyxoJRrDSKUwb6UQ,1201
+emoji/unicode_codes/__init__.py,sha256=DOEFYlvT-18AjU4P8G9F8H1Bcjpj0mHiwjFh0JZoaiA,1291
+emoji/unicode_codes/__init__.pyi,sha256=hH9q27ed2a45IHQ1tKPdMymb6l2IWL3BTJlL8bx8rY4,243
+emoji/unicode_codes/__pycache__/__init__.cpython-311.pyc,,
+emoji/unicode_codes/__pycache__/data_dict.cpython-311.pyc,,
+emoji/unicode_codes/data_dict.py,sha256=IQAIkhb7TQqIdxulG4AJxII4BiGFDI3Ns67S49x0SP8,3135614
+emoji/unicode_codes/data_dict.pyi,sha256=HiU_YbtX-SphSyD4ZZ2_veRbZ2OP9i08TAjiESdE8ng,155
+emoji/unicode_codes/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji-2.8.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji-2.8.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+emoji

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji-2.8.0.dist-info/zip-safe

@@ -0,0 +1 @@
+

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji/__init__.py

@@ -0,0 +1,62 @@
+"""
+emoji for Python
+~~~~~~~~~~~~~~~~
+
+emoji terminal output for Python.
+
+    >>> import emoji
+    >>> print(emoji.emojize('Python is :thumbsup:', language='alias'))
+    Python is 👍
+    >>> print(emoji.emojize('Python is :thumbs_up:'))
+    Python is 👍
+"""
+
+
+from emoji.core import *
+from emoji.unicode_codes import *
+
+__all__ = [
+    # emoji.core
+    'emojize', 'demojize', 'analyze', 'config',
+    'emoji_list', 'distinct_emoji_list', 'emoji_count',
+    'replace_emoji', 'is_emoji', 'purely_emoji', 'version',
+    'Token', 'EmojiMatch', 'EmojiMatchZWJ', 'EmojiMatchZWJNonRGI',
+    # emoji.unicode_codes
+    'EMOJI_DATA', 'STATUS', 'LANGUAGES',
+]
+
+__version__ = '2.8.0'
+__author__ = 'Taehoon Kim, Kevin Wurster'
+__email__ = '[email protected]'
+# and [email protected], [email protected]
+__source__ = 'https://github.com/carpedm20/emoji/'
+__license__ = '''
+New BSD License
+
+Copyright (c) 2014-2023, Taehoon Kim, Kevin Wurster
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* The names of its contributors may not be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+'''

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji/__init__.pyi

@@ -0,0 +1,37 @@
+from .core import (
+    demojize as demojize,
+    distinct_emoji_list as distinct_emoji_list,
+    emoji_count as emoji_count,
+    emoji_list as emoji_list,
+    emojize as emojize,
+    is_emoji as is_emoji,
+    replace_emoji as replace_emoji,
+    version as version,
+    analyze as analyze,
+    config as config,
+)
+from .tokenizer import (
+    Token as Token,
+    EmojiMatch as EmojiMatch,
+    EmojiMatchZWJ as EmojiMatchZWJ,
+    EmojiMatchZWJNonRGI as EmojiMatchZWJNonRGI,
+)
+
+
+from .unicode_codes import EMOJI_DATA, LANGUAGES, STATUS
+
+__all__ = [
+    # emoji.core
+    'emojize', 'demojize', 'analyze', 'config',
+    'emoji_list', 'distinct_emoji_list', 'emoji_count',
+    'replace_emoji', 'is_emoji', 'version',
+    'Token', 'EmojiMatch', 'EmojiMatchZWJ', 'EmojiMatchZWJNonRGI',
+    # emoji.unicode_codes
+    'EMOJI_DATA', 'STATUS', 'LANGUAGES',
+]
+
+__version__: str
+__author__: str
+__email__: str
+__source__: str
+__license__: str

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji/core.py

@@ -0,0 +1,372 @@
+"""
+emoji.core
+~~~~~~~~~~
+
+Core components for emoji.
+
+"""
+
+import re
+import unicodedata
+from typing import Iterator
+
+from emoji import unicode_codes
+from emoji.tokenizer import Token, EmojiMatch, EmojiMatchZWJ, EmojiMatchZWJNonRGI, tokenize, filter_tokens
+
+__all__ = [
+    'emojize', 'demojize', 'analyze', 'config',
+    'emoji_list', 'distinct_emoji_list', 'emoji_count',
+    'replace_emoji', 'is_emoji', 'purely_emoji', 'version',
+    'Token', 'EmojiMatch', 'EmojiMatchZWJ', 'EmojiMatchZWJNonRGI',
+]
+
+_DEFAULT_DELIMITER = ':'
+_EMOJI_NAME_PATTERN = '\\w\\-&.’”“()!#*+,/«»\u0300\u0301\u0302\u0303\u0308\u030a\u0327\u064b\u064e\u064f\u0650\u0653\u0654\u3099\u30fb\u309a'
+
+
+class config():
+    """Module-wide configuration"""
+
+    demojize_keep_zwj = True
+    """Change the behavior of :func:`emoji.demojize()` regarding
+    zero-width-joiners (ZWJ/``\\u200D``) in emoji that are not
+    "recommended for general interchange" (non-RGI).
+    It has no effect on RGI emoji.
+
+    For example this family emoji with different skin tones "👨‍👩🏿‍👧🏻‍👦🏾" contains four
+    person emoji that are joined together by three ZWJ characters:
+    ``👨\\u200D👩🏿\\u200D👧🏻\\u200D👦🏾``
+
+    If ``True``, the zero-width-joiners will be kept and :func:`emoji.emojize()` can
+    reverse the :func:`emoji.demojize()` operation:
+    ``emoji.emojize(emoji.demojize(s)) == s``
+
+    The example emoji would be converted to
+    ``:man:\\u200d:woman_dark_skin_tone:\\u200d:girl_light_skin_tone:\\u200d:boy_medium-dark_skin_tone:``
+
+    If ``False``, the zero-width-joiners will be removed and :func:`emoji.emojize()`
+    can only reverse the individual emoji: ``emoji.emojize(emoji.demojize(s)) != s``
+
+    The example emoji would be converted to
+    ``:man::woman_dark_skin_tone::girl_light_skin_tone::boy_medium-dark_skin_tone:``
+    """
+
+    replace_emoji_keep_zwj = False
+    """Change the behavior of :func:`emoji.replace_emoji()` regarding
+    zero-width-joiners (ZWJ/``\\u200D``) in emoji that are not
+    "recommended for general interchange" (non-RGI).
+    It has no effect on RGI emoji.
+
+    See :attr:`config.demojize_keep_zwj` for more information.
+    """
+
+
+def emojize(
+        string,
+        delimiters=(_DEFAULT_DELIMITER, _DEFAULT_DELIMITER),
+        variant=None,
+        language='en',
+        version=None,
+        handle_version=None
+):
+    """
+    Replace emoji names in a string with Unicode codes.
+        >>> import emoji
+        >>> print(emoji.emojize("Python is fun :thumbsup:", language='alias'))
+        Python is fun 👍
+        >>> print(emoji.emojize("Python is fun :thumbs_up:"))
+        Python is fun 👍
+        >>> print(emoji.emojize("Python is fun {thumbs_up}", delimiters = ("{", "}")))
+        Python is fun 👍
+        >>> print(emoji.emojize("Python is fun :red_heart:", variant="text_type"))
+        Python is fun ❤
+        >>> print(emoji.emojize("Python is fun :red_heart:", variant="emoji_type"))
+        Python is fun ❤️ # red heart, not black heart
+
+    :param string: String contains emoji names.
+    :param delimiters: (optional) Use delimiters other than _DEFAULT_DELIMITER. Each delimiter
+        should contain at least one character that is not part of a-zA-Z0-9 and ``_-&.()!?#*+,``.
+        See ``emoji.core._EMOJI_NAME_PATTERN`` for the regular expression of unsafe characters.
+    :param variant: (optional) Choose variation selector between "base"(None), VS-15 ("text_type") and VS-16 ("emoji_type")
+    :param language: Choose language of emoji name: language code 'es', 'de', etc. or 'alias'
+        to use English aliases
+    :param version: (optional) Max version. If set to an Emoji Version,
+        all emoji above this version will be ignored.
+    :param handle_version: (optional) Replace the emoji above ``version``
+        instead of ignoring it. handle_version can be either a string or a
+        callable; If it is a callable, it's passed the Unicode emoji and the
+        data dict from :data:`EMOJI_DATA` and must return a replacement string
+        to be used::
+
+            handle_version('\\U0001F6EB', {
+                'en' : ':airplane_departure:',
+                'status' : fully_qualified,
+                'E' : 1,
+                'alias' : [':flight_departure:'],
+                'de': ':abflug:',
+                'es': ':avión_despegando:',
+                ...
+            })
+
+    :raises ValueError: if ``variant`` is neither None, 'text_type' or 'emoji_type'
+
+    """
+
+    if language == 'alias':
+        language_pack = unicode_codes.get_aliases_unicode_dict()
+    else:
+        language_pack = unicode_codes.get_emoji_unicode_dict(language)
+
+    pattern = re.compile('(%s[%s]+%s)' %
+                         (re.escape(delimiters[0]), _EMOJI_NAME_PATTERN, re.escape(delimiters[1])))
+
+    def replace(match):
+        name = match.group(1)[len(delimiters[0]):-len(delimiters[1])]
+        emj = language_pack.get(
+            _DEFAULT_DELIMITER +
+            unicodedata.normalize('NFKC', name) +
+            _DEFAULT_DELIMITER)
+        if emj is None:
+            return match.group(1)
+
+        if version is not None and unicode_codes.EMOJI_DATA[emj]['E'] > version:
+            if callable(handle_version):
+                emj_data = unicode_codes.EMOJI_DATA[emj].copy()
+                emj_data['match_start'] = match.start()
+                emj_data['match_end'] = match.end()
+                return handle_version(emj, emj_data)
+
+            elif handle_version is not None:
+                return str(handle_version)
+            else:
+                return ''
+
+        if variant is None or 'variant' not in unicode_codes.EMOJI_DATA[emj]:
+            return emj
+
+        if emj[-1] == '\uFE0E' or emj[-1] == '\uFE0F':
+            # Remove an existing variant
+            emj = emj[0:-1]
+        if variant == "text_type":
+            return emj + '\uFE0E'
+        elif variant == "emoji_type":
+            return emj + '\uFE0F'
+        else:
+            raise ValueError(
+                "Parameter 'variant' must be either None, 'text_type' or 'emoji_type'")
+
+    return pattern.sub(replace, string)
+
+
+def analyze(string: str, non_emoji: bool = False, join_emoji: bool = True) -> Iterator[Token]:
+    """
+    Find unicode emoji in a string. Yield each emoji as a named tuple
+    :class:`Token` ``(chars, EmojiMatch)`` or `:class:`Token` ``(chars, EmojiMatchZWJNonRGI)``.
+    If ``non_emoji`` is True, also yield all other characters as
+    :class:`Token` ``(char, char)`` .
+
+    :param string: String to analyze
+    :param non_emoji: If True also yield all non-emoji characters as Token(char, char)
+    :param join_emoji: If True, multiple EmojiMatch are merged into a single
+        EmojiMatchZWJNonRGI if they are separated only by a ZWJ.
+    """
+
+    return filter_tokens(
+        tokenize(string, keep_zwj=True), emoji_only=not non_emoji, join_emoji=join_emoji)
+
+
+def demojize(
+        string,
+        delimiters=(_DEFAULT_DELIMITER, _DEFAULT_DELIMITER),
+        language='en',
+        version=None,
+        handle_version=None
+):
+    """
+    Replace Unicode emoji in a string with emoji shortcodes. Useful for storage.
+        >>> import emoji
+        >>> print(emoji.emojize("Python is fun :thumbs_up:"))
+        Python is fun 👍
+        >>> print(emoji.demojize("Python is fun 👍"))
+        Python is fun :thumbs_up:
+        >>> print(emoji.demojize("icode is tricky 😯", delimiters=("__", "__")))
+        Unicode is tricky __hushed_face__
+
+    :param string: String contains Unicode characters. MUST BE UNICODE.
+    :param delimiters: (optional) User delimiters other than ``_DEFAULT_DELIMITER``
+    :param language: Choose language of emoji name: language code 'es', 'de', etc. or 'alias'
+        to use English aliases
+    :param version: (optional) Max version. If set to an Emoji Version,
+        all emoji above this version will be removed.
+    :param handle_version: (optional) Replace the emoji above ``version``
+        instead of removing it. handle_version can be either a string or a
+        callable ``handle_version(emj: str, data: dict) -> str``; If it is
+        a callable, it's passed the Unicode emoji and the data dict from
+        :data:`EMOJI_DATA` and must return a replacement string  to be used.
+        The passed data is in the form of::
+
+            handle_version('\\U0001F6EB', {
+                'en' : ':airplane_departure:',
+                'status' : fully_qualified,
+                'E' : 1,
+                'alias' : [':flight_departure:'],
+                'de': ':abflug:',
+                'es': ':avión_despegando:',
+                ...
+            })
+
+    """
+
+    if language == 'alias':
+        language = 'en'
+        _use_aliases = True
+    else:
+        _use_aliases = False
+
+    def handle(emoji_match):
+        if version is not None and emoji_match.data['E'] > version:
+            if callable(handle_version):
+                return handle_version(emoji_match.emoji, emoji_match.data_copy())
+            elif handle_version is not None:
+                return handle_version
+            else:
+                return ''
+        elif language in emoji_match.data:
+            if _use_aliases and 'alias' in emoji_match.data:
+                return delimiters[0] + emoji_match.data['alias'][0][1:-1] + delimiters[1]
+            else:
+                return delimiters[0] + emoji_match.data[language][1:-1] + delimiters[1]
+        else:
+            # The emoji exists, but it is not translated, so we keep the emoji
+            return emoji_match.emoji
+
+    matches = tokenize(string, keep_zwj=config.demojize_keep_zwj)
+    return "".join(str(handle(token.value)) if isinstance(
+        token.value, EmojiMatch) else token.value for token in matches)
+
+
+def replace_emoji(string, replace='', version=-1):
+    """
+    Replace Unicode emoji in a customizable string.
+
+    :param string: String contains Unicode characters. MUST BE UNICODE.
+    :param replace: (optional) replace can be either a string or a callable;
+        If it is a callable, it's passed the Unicode emoji and the data dict from
+        :data:`EMOJI_DATA` and must return a replacement string to be used.
+        replace(str, dict) -> str
+    :param version: (optional) Max version. If set to an Emoji Version,
+        only emoji above this version will be replaced.
+    """
+
+    def handle(emoji_match):
+        if version > -1:
+            if emoji_match.data['E'] > version:
+                if callable(replace):
+                    return replace(emoji_match.emoji, emoji_match.data_copy())
+                else:
+                    return str(replace)
+        elif callable(replace):
+            return replace(emoji_match.emoji, emoji_match.data_copy())
+        elif replace is not None:
+            return replace
+        return emoji_match.emoji
+
+    matches = tokenize(string, keep_zwj=config.replace_emoji_keep_zwj)
+    if config.replace_emoji_keep_zwj:
+        matches = filter_tokens(
+            matches, emoji_only=False, join_emoji=True)
+    return "".join(str(handle(m.value)) if isinstance(
+        m.value, EmojiMatch) else m.value for m in matches)
+
+
+def emoji_list(string):
+    """
+    Returns the location and emoji in list of dict format.
+        >>> emoji.emoji_list("Hi, I am fine. 😁")
+        [{'match_start': 15, 'match_end': 16, 'emoji': '😁'}]
+    """
+
+    return [{
+        'match_start': m.value.start,
+        'match_end': m.value.end,
+        'emoji': m.value.emoji,
+    } for m in tokenize(string, keep_zwj=False) if isinstance(m.value, EmojiMatch)]
+
+
+def distinct_emoji_list(string):
+    """Returns distinct list of emojis from the string."""
+    distinct_list = list(
+        {e['emoji'] for e in emoji_list(string)}
+    )
+    return distinct_list
+
+
+def emoji_count(string, unique=False):
+    """
+    Returns the count of emojis in a string.
+
+    :param unique: (optional) True if count only unique emojis
+    """
+    if unique:
+        return len(distinct_emoji_list(string))
+    return len(emoji_list(string))
+
+
+def is_emoji(string):
+    """
+    Returns True if the string is a single emoji, and it is "recommended for
+    general interchange" by Unicode.org.
+    """
+    return string in unicode_codes.EMOJI_DATA
+
+
+def purely_emoji(string: str) -> bool:
+    """
+    Returns True if the string contains only emojis.
+    This might not imply that `is_emoji` for all the characters, for example,
+    if the string contains variation selectors.
+    """
+    return all(isinstance(m.value, EmojiMatch) for m in analyze(string, non_emoji=True))
+
+
+def version(string):
+    """
+    Returns the Emoji Version of the emoji.
+
+    See https://www.unicode.org/reports/tr51/#Versioning for more information.
+        >>> emoji.version("😁")
+        0.6
+        >>> emoji.version(":butterfly:")
+        3
+
+    :param string: An emoji or a text containing an emoji
+    :raises ValueError: if ``string`` does not contain an emoji
+    """
+    # Try dictionary lookup
+    if string in unicode_codes.EMOJI_DATA:
+        return unicode_codes.EMOJI_DATA[string]['E']
+
+    language_pack = unicode_codes.get_emoji_unicode_dict('en')
+    if string in language_pack:
+        emj_code = language_pack[string]
+        if emj_code in unicode_codes.EMOJI_DATA:
+            return unicode_codes.EMOJI_DATA[emj_code]['E']
+
+    # Try to find first emoji in string
+    version = []
+
+    def f(e, emoji_data):
+        version.append(emoji_data['E'])
+        return ''
+    replace_emoji(string, replace=f, version=-1)
+    if version:
+        return version[0]
+    emojize(string, language='alias', version=-1, handle_version=f)
+    if version:
+        return version[0]
+    for lang_code in unicode_codes._EMOJI_UNICODE:
+        emojize(string, language=lang_code, version=-1, handle_version=f)
+        if version:
+            return version[0]
+
+    raise ValueError("No emoji found in string")

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji/core.pyi

@@ -0,0 +1,47 @@
+from collections.abc import Callable
+from typing_extensions import Literal, TypedDict
+from typing import Iterator
+from .tokenizer import Token
+
+
+class config:
+    demojize_keep_zwj: bool
+    replace_emoji_keep_zwj: bool
+
+
+class _EmojiListReturn(TypedDict):
+    emoji: str
+    match_start: int
+    match_end: int
+
+
+def emojize(
+    string: str,
+    delimiters: tuple[str, str] = ...,
+    variant: Literal["text_type", "emoji_type", None] = ...,
+    language: str = ...,
+    version: float | None = ...,
+    handle_version: str | Callable[[str, dict[str, str]], str] | None = ...,
+) -> str: ...
+
+
+def demojize(
+    string: str,
+    delimiters: tuple[str, str] = ...,
+    language: str = ...,
+    version: float | None = ...,
+    handle_version: str | Callable[[str, dict[str, str]], str] | None = ...,
+) -> str: ...
+
+
+def analyze(string: str, non_emoji: bool,
+            join_emoji: bool) -> Iterator[Token]: ...
+def replace_emoji(string: str, replace: str | Callable[[
+                  str, dict[str, str]], str] = ..., version: float = ...) -> str: ...
+
+
+def emoji_list(string: str) -> list[_EmojiListReturn]: ...
+def distinct_emoji_list(string: str) -> list[str]: ...
+def emoji_count(string: str, unique: bool = ...) -> int: ...
+def version(string: str) -> float: ...
+def is_emoji(string: str) -> bool: ...

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji/tokenizer.py

@@ -0,0 +1,361 @@
+"""
+emoji.tokenizer
+~~~~~~~~~~~~~~~
+
+Components for detecting and tokenizing emoji in strings.
+
+"""
+from typing import NamedTuple, Dict, Union, Iterator, Any
+from emoji import unicode_codes
+
+
+__all__ = [
+    'EmojiMatch', 'EmojiMatchZWJ', 'EmojiMatchZWJNonRGI', 'Token',
+    'tokenize', 'filter_tokens',
+]
+
+_ZWJ = '\u200D'
+_SEARCH_TREE = None
+
+
+class EmojiMatch:
+    """
+    Represents a match of a "recommended for general interchange" (RGI)
+    emoji in a string.
+    """
+
+    __slots__ = ('emoji', 'start', 'end', 'data')
+
+    def __init__(self, emoji: str, start: int,
+                 end: int, data: Union[dict, None]):
+
+        self.emoji = emoji
+        """The emoji substring"""
+
+        self.start = start
+        """The start index of the match in the string"""
+
+        self.end = end
+        """The end index of the match in the string"""
+
+        self.data = data
+        """The entry from :data:`EMOJI_DATA` for this emoji or ``None`` if the emoji is non-RGI"""
+
+    def data_copy(self) -> Dict[str, Any]:
+        """
+        Returns a copy of the data from :data:`EMOJI_DATA` for this match
+        with the additional keys ``match_start`` and ``match_end``.
+        """
+        if self.data:
+            emj_data = self.data.copy()
+            emj_data['match_start'] = self.start
+            emj_data['match_end'] = self.end
+            return emj_data
+        else:
+            return {
+                'match_start': self.start,
+                'match_end': self.end
+            }
+
+    def is_zwj(self) -> bool:
+        """
+        Checks if this is a ZWJ-emoji.
+
+        :returns: True if this is a ZWJ-emoji, False otherwise
+        """
+
+        return _ZWJ in self.emoji
+
+    def split(self) -> Union['EmojiMatchZWJ', 'EmojiMatch']:
+        """
+        Splits a ZWJ-emoji into its constituents.
+
+        :returns: An :class:`EmojiMatchZWJ` containing the "sub-emoji" if this is a ZWJ-emoji, otherwise self
+        """
+
+        if self.is_zwj():
+            return EmojiMatchZWJ(self)
+        else:
+            return self
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.emoji}, {self.start}:{self.end})'
+
+
+class EmojiMatchZWJ(EmojiMatch):
+    """
+    Represents a match of multiple emoji in a string that were joined by
+    zero-width-joiners (ZWJ/``\\u200D``)."""
+
+    __slots__ = ('emojis', )
+
+    def __init__(self, match: EmojiMatch):
+        super().__init__(match.emoji, match.start, match.end, match.data)
+
+        self.emojis = []
+        """List of sub emoji as EmojiMatch objects"""
+
+        i = match.start
+        for e in match.emoji.split(_ZWJ):
+            m = EmojiMatch(
+                e, i, i+len(e), unicode_codes.EMOJI_DATA.get(e, None))
+            self.emojis.append(m)
+            i += len(e) + 1
+
+    def join(self) -> str:
+        """
+        Joins a ZWJ-emoji into a string
+        """
+
+        return _ZWJ.join(e.emoji for e in self.emojis)
+
+    def is_zwj(self) -> bool:
+        return True
+
+    def split(self) -> 'EmojiMatchZWJ':
+        return self
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.join()}, {self.start}:{self.end})'
+
+
+class EmojiMatchZWJNonRGI(EmojiMatchZWJ):
+    """
+    Represents a match of multiple emoji in a string that were joined by
+    zero-width-joiners (ZWJ/``\\u200D``). This class is only used for emoji
+    that are not "recommended for general interchange" (non-RGI) by Unicode.org.
+    The data property of this class is always None.
+    """
+
+    def __init__(self, first_emoji_match: EmojiMatch,
+                 second_emoji_match: EmojiMatch):
+
+        self.emojis = [first_emoji_match, second_emoji_match]
+        """List of sub emoji as EmojiMatch objects"""
+
+        self._update()
+
+    def _update(self):
+        self.emoji = _ZWJ.join(e.emoji for e in self.emojis)
+        self.start = self.emojis[0].start
+        self.end = self.emojis[-1].end
+        self.data = None
+
+    def _add(self, next_emoji_match: EmojiMatch):
+        self.emojis.append(next_emoji_match)
+        self._update()
+
+
+class Token(NamedTuple):
+    """
+    A named tuple containing the matched string and its :class:`EmojiMatch` object if it is an emoji
+    or a single character that is not a unicode emoji.
+    """
+    chars: str
+    value: Union[str, EmojiMatch]
+
+
+def tokenize(string, keep_zwj: bool) -> Iterator[Token]:
+    """
+    Finds unicode emoji in a string. Yields all normal characters as a named
+    tuple :class:`Token` ``(char, char)`` and all emoji as :class:`Token` ``(chars, EmojiMatch)``.
+
+    :param string: String contains unicode characters. MUST BE UNICODE.
+    :param keep_zwj: Should ZWJ-characters (``\\u200D``) that join non-RGI emoji be
+        skipped or should be yielded as normal characters
+    :return: An iterable of tuples :class:`Token` ``(char, char)`` or :class:`Token` ``(chars, EmojiMatch)``
+    """
+
+    tree = get_search_tree()
+    EMOJI_DATA = unicode_codes.EMOJI_DATA
+    # result: [ Token(oldsubstring0, EmojiMatch), Token(char1, char1), ... ]
+    result = []
+    i = 0
+    length = len(string)
+    ignore = []  # index of chars in string that are skipped, i.e. the ZWJ-char in non-RGI-ZWJ-sequences
+    while i < length:
+        consumed = False
+        char = string[i]
+        if i in ignore:
+            i += 1
+            if char == _ZWJ and keep_zwj:
+                result.append(Token(char, char))
+            continue
+
+        elif char in tree:
+            j = i + 1
+            sub_tree = tree[char]
+            while j < length and string[j] in sub_tree:
+                if j in ignore:
+                    break
+                sub_tree = sub_tree[string[j]]
+                j += 1
+            if 'data' in sub_tree:
+                emj_data = sub_tree['data']
+                code_points = string[i:j]
+
+                # We cannot yield the result here, we need to defer
+                # the call until we are sure that the emoji is finished
+                # i.e. we're not inside an ongoing ZWJ-sequence
+                match_obj = EmojiMatch(code_points, i, j, emj_data)
+
+                i = j - 1
+                consumed = True
+                result.append(Token(code_points, match_obj))
+
+        elif char == _ZWJ and result and result[-1].chars in EMOJI_DATA and i > 0 and string[i - 1] in tree:
+            # the current char is ZWJ and the last match was an emoji
+            ignore.append(i)
+            if EMOJI_DATA[result[-1].chars]["status"] == unicode_codes.STATUS["component"]:
+                # last match was a component, it could be ZWJ+EMOJI+COMPONENT
+                # or ZWJ+COMPONENT
+                i = i - sum(len(t.chars) for t in result[-2:])
+                if string[i] == _ZWJ:
+                    # It's ZWJ+COMPONENT, move one back
+                    i += 1
+                    del result[-1]
+                else:
+                    # It's ZWJ+EMOJI+COMPONENT, move two back
+                    del result[-2:]
+            else:
+                # last match result[-1] was a normal emoji, move cursor
+                # before the emoji
+                i = i - len(result[-1].chars)
+                del result[-1]
+            continue
+
+        elif result:
+            yield from result
+            result = []
+
+        if not consumed and char != '\uFE0E' and char != '\uFE0F':
+            result.append(Token(char, char))
+        i += 1
+
+    yield from result
+
+
+def filter_tokens(matches: Iterator[Token], emoji_only: bool, join_emoji: bool) -> Iterator[Token]:
+    """
+    Filters the output of `tokenize()`
+
+    :param matches: An iterable of tuples of the form ``(match_str, result)``
+        where ``result`` is either an EmojiMatch or a string.
+    :param emoji_only: If True, only EmojiMatch are returned in the output.
+        If False all characters are returned
+    :param join_emoji: If True, multiple EmojiMatch are merged into
+        a single :class:`EmojiMatchZWJNonRGI` if they are separated only by a ZWJ.
+
+    :return: An iterable of tuples :class:`Token` ``(char, char)``,
+        :class:`Token` ``(chars, EmojiMatch)`` or :class:`Token` ``(chars, EmojiMatchZWJNonRGI)``
+    """
+
+    if not join_emoji and not emoji_only:
+        yield from matches
+        return
+
+    if not join_emoji:
+        for token in matches:
+            if token.chars != _ZWJ:
+                yield token
+        return
+
+    # Combine multiple EmojiMatch that are separated by ZWJs into
+    # a single EmojiMatchZWJNonRGI
+    previous_is_emoji = False
+    previous_is_zwj = False
+    pre_previous_is_emoji = False
+    accumulator = []
+    for token in matches:
+        pre_previous_is_emoji = previous_is_emoji
+        if previous_is_emoji and token.value == _ZWJ:
+            previous_is_zwj = True
+        elif isinstance(token.value, EmojiMatch):
+            if pre_previous_is_emoji and previous_is_zwj:
+                if isinstance(accumulator[-1].value, EmojiMatchZWJNonRGI):
+                    accumulator[-1].value._add(token.value)
+                    accumulator[-1] = Token(accumulator[-1].chars +
+                                            _ZWJ + token.chars, accumulator[-1].value)
+                else:
+                    prev = accumulator.pop()
+                    accumulator.append(
+                        Token(prev.chars + _ZWJ + token.chars,
+                              EmojiMatchZWJNonRGI(
+                                  prev.value,
+                                  token.value)))
+            else:
+                accumulator.append(token)
+            previous_is_emoji = True
+            previous_is_zwj = False
+        else:
+            # Other character, not an emoji
+            previous_is_emoji = False
+            previous_is_zwj = False
+            yield from accumulator
+            if not emoji_only:
+                yield token
+            accumulator = []
+    yield from accumulator
+
+
+def get_search_tree() -> Dict[str, Any]:
+    """
+    Generate a search tree for demojize().
+    Example of a search tree::
+
+        EMOJI_DATA =
+        {'a': {'en': ':Apple:'},
+        'b': {'en': ':Bus:'},
+        'ba': {'en': ':Bat:'},
+        'band': {'en': ':Beatles:'},
+        'bandit': {'en': ':Outlaw:'},
+        'bank': {'en': ':BankOfEngland:'},
+        'bb': {'en': ':BB-gun:'},
+        'c': {'en': ':Car:'}}
+
+        _SEARCH_TREE =
+        {'a': {'data': {'en': ':Apple:'}},
+        'b': {'a': {'data': {'en': ':Bat:'},
+                    'n': {'d': {'data': {'en': ':Beatles:'},
+                                'i': {'t': {'data': {'en': ':Outlaw:'}}}},
+                        'k': {'data': {'en': ':BankOfEngland:'}}}},
+            'b': {'data': {'en': ':BB-gun:'}},
+            'data': {'en': ':Bus:'}},
+        'c': {'data': {'en': ':Car:'}}}
+
+                   _SEARCH_TREE
+                 /     |        ⧵
+               /       |          ⧵
+            a          b             c
+            |        / |  ⧵          |
+            |       /  |    ⧵        |
+        :Apple:   ba  :Bus:  bb     :Car:
+                 /  ⧵         |
+                /    ⧵        |
+              :Bat:    ban     :BB-gun:
+                     /     ⧵
+                    /       ⧵
+                 band       bank
+                /   ⧵         |
+               /     ⧵        |
+            bandi :Beatles:  :BankOfEngland:
+               |
+            bandit
+               |
+           :Outlaw:
+
+
+    """
+    global _SEARCH_TREE
+    if _SEARCH_TREE is None:
+        _SEARCH_TREE = {}
+        for emj in unicode_codes.EMOJI_DATA:
+            sub_tree = _SEARCH_TREE
+            lastidx = len(emj) - 1
+            for i, char in enumerate(emj):
+                if char not in sub_tree:
+                    sub_tree[char] = {}
+                sub_tree = sub_tree[char]
+                if i == lastidx:
+                    sub_tree['data'] = unicode_codes.EMOJI_DATA[emj]
+    return _SEARCH_TREE

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji/tokenizer.pyi

@@ -0,0 +1,47 @@
+from typing import NamedTuple, Union, Dict, Iterator, Any
+
+_SearchTree = Dict[str, Union['_SearchTree', dict[str, dict[str, Any]]]]
+
+_SEARCH_TREE: _SearchTree
+
+
+class EmojiMatch:
+    emoji: str
+    start: int
+    end: int
+    data: dict[str, Any] | None
+    def __init__(self, emoji: str, start: int,
+                 end: int, data: dict | None): ...
+
+    def data_copy(self) -> Dict[str, Any]: ...
+    def is_zwj(self) -> bool: ...
+    def split(self) -> EmojiMatchZWJ | EmojiMatch: ...
+    def __repr__(self) -> str: ...
+
+
+class EmojiMatchZWJ(EmojiMatch):
+    def __init__(self, match: EmojiMatch): ...
+    def join(self) -> str: ...
+    def is_zwj(self) -> bool: ...
+    def split(self) -> EmojiMatchZWJ: ...
+    def __repr__(self) -> str: ...
+
+
+class EmojiMatchZWJNonRGI(EmojiMatchZWJ):
+    def __init__(self, first_emoji_match: EmojiMatch,
+                 second_emoji_match: EmojiMatch): ...
+
+
+class Token(NamedTuple):
+    chars: str
+    value: str | EmojiMatch
+
+
+def tokenize(string, keep_zwj: bool) -> Iterator[Token]: ...
+
+
+def filter_tokens(matches: Iterator[Token], emoji_only: bool,
+                  join_emoji: bool) -> Iterator[Token]: ...
+
+
+def get_search_tree() -> _SearchTree: ...

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji/unicode_codes/__init__.py

@@ -0,0 +1,36 @@
+from emoji.unicode_codes.data_dict import *
+
+__all__ = [
+    'get_emoji_unicode_dict', 'get_aliases_unicode_dict',
+    'EMOJI_DATA', 'STATUS', 'LANGUAGES'
+]
+
+
+_EMOJI_UNICODE = {lang: None for lang in LANGUAGES}  # Cache for the language dicts
+
+_ALIASES_UNICODE = {}  # Cache for the aliases dict
+
+
+def get_emoji_unicode_dict(lang):
+    """Generate dict containing all fully-qualified and component emoji name for a language
+    The dict is only generated once per language and then cached in _EMOJI_UNICODE[lang]"""
+
+    if _EMOJI_UNICODE[lang] is None:
+        _EMOJI_UNICODE[lang] = {data[lang]: emj for emj, data in EMOJI_DATA.items()
+                                if lang in data and data['status'] <= STATUS['fully_qualified']}
+
+    return _EMOJI_UNICODE[lang]
+
+
+def get_aliases_unicode_dict():
+    """Generate dict containing all fully-qualified and component aliases
+    The dict is only generated once and then cached in _ALIASES_UNICODE"""
+
+    if not _ALIASES_UNICODE:
+        _ALIASES_UNICODE.update(get_emoji_unicode_dict('en'))
+        for emj, data in EMOJI_DATA.items():
+            if 'alias' in data and data['status'] <= STATUS['fully_qualified']:
+                for alias in data['alias']:
+                    _ALIASES_UNICODE[alias] = emj
+
+    return _ALIASES_UNICODE

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji/unicode_codes/__init__.pyi

@@ -0,0 +1,6 @@
+from .data_dict import *
+
+__all__ = ["get_emoji_unicode_dict", "get_aliases_unicode_dict", "EMOJI_DATA", "STATUS", "LANGUAGES"]
+
+def get_emoji_unicode_dict(lang: str) -> dict[str, str]: ...
+def get_aliases_unicode_dict() -> dict[str, str]: ...

resources/app/plugins/deepmoji_plugin/DeepMoji/emoji/unicode_codes/data_dict.pyi

@@ -0,0 +1,7 @@
+from typing import Any
+
+__all__ = ["EMOJI_DATA", "STATUS", "LANGUAGES"]
+
+STATUS: dict[str, int]
+LANGUAGES: list[str]
+EMOJI_DATA: dict[str, dict[str, Any]]

resources/app/plugins/deepmoji_plugin/DeepMoji/examples/.gitkeep

@@ -0,0 +1 @@
+ 

resources/app/plugins/deepmoji_plugin/DeepMoji/examples/README.md

@@ -0,0 +1,39 @@
+# torchMoji examples
+
+## Initialization
+[create_twitter_vocab.py](create_twitter_vocab.py)
+Create a new vocabulary from a tsv file.
+
+[tokenize_dataset.py](tokenize_dataset.py)
+Tokenize a given dataset using the prebuilt vocabulary.
+
+[vocab_extension.py](vocab_extension.py)
+Extend the given vocabulary using dataset-specific words.
+
+[dataset_split.py](dataset_split.py)
+Split a given dataset into training, validation and testing.
+
+## Use pretrained model/architecture
+[score_texts_emojis.py](score_texts_emojis.py)
+Use torchMoji to score texts for emoji distribution.
+
+[text_emojize.py](text_emojize.py)
+Use torchMoji to output emoji visualization from a single text input (mapped from `emoji_overview.png`)
+
+```sh
+python examples/text_emojize.py --text "I love mom's cooking\!"
+# => I love mom's cooking! 😋 😍 💓 💛 ❤
+```
+
+[encode_texts.py](encode_texts.py)
+Use torchMoji to encode the text into 2304-dimensional feature vectors for further modeling/analysis.
+
+## Transfer learning
+[finetune_youtube_last.py](finetune_youtube_last.py)
+Finetune the model on the SS-Youtube dataset using the 'last' method.
+
+[finetune_insults_chain-thaw.py](finetune_insults_chain-thaw.py)
+Finetune the model on the Kaggle insults dataset (from blog post) using the 'chain-thaw' method.
+
+[finetune_semeval_class-avg_f1.py](finetune_semeval_class-avg_f1.py)
+Finetune the model on the SemeEval emotion dataset using the 'full' method and evaluate using the class average F1 metric.

resources/app/plugins/deepmoji_plugin/DeepMoji/examples/create_twitter_vocab.py

@@ -0,0 +1,13 @@
+""" Creates a vocabulary from a tsv file.
+"""
+
+import codecs
+import example_helper
+from torchmoji.create_vocab import VocabBuilder
+from torchmoji.word_generator import TweetWordGenerator
+
+with codecs.open('../../twitterdata/tweets.2016-09-01', 'rU', 'utf-8') as stream:
+    wg = TweetWordGenerator(stream)
+    vb = VocabBuilder(wg)
+    vb.count_all_words()
+    vb.save_vocab()

resources/app/plugins/deepmoji_plugin/DeepMoji/examples/dataset_split.py

@@ -0,0 +1,59 @@
+'''
+Split a given dataset into three different datasets: training, validation and
+testing.
+
+This is achieved by splitting the given list of sentences into three separate
+lists according to either a given ratio (e.g. [0.7, 0.1, 0.2]) or by an
+explicit enumeration. The sentences are also tokenised using the given
+vocabulary.
+
+Also splits a given list of dictionaries containing information about
+each sentence.
+
+An additional parameter can be set 'extend_with', which will extend the given
+vocabulary with up to 'extend_with' tokens, taken from the training dataset.
+'''
+from __future__ import print_function, unicode_literals
+import example_helper
+import json
+
+from torchmoji.sentence_tokenizer import SentenceTokenizer
+
+DATASET = [
+    'I am sentence 0',
+    'I am sentence 1',
+    'I am sentence 2',
+    'I am sentence 3',
+    'I am sentence 4',
+    'I am sentence 5',
+    'I am sentence 6',
+    'I am sentence 7',
+    'I am sentence 8',
+    'I am sentence 9 newword',
+    ]
+
+INFO_DICTS = [
+    {'label': 'sentence 0'},
+    {'label': 'sentence 1'},
+    {'label': 'sentence 2'},
+    {'label': 'sentence 3'},
+    {'label': 'sentence 4'},
+    {'label': 'sentence 5'},
+    {'label': 'sentence 6'},
+    {'label': 'sentence 7'},
+    {'label': 'sentence 8'},
+    {'label': 'sentence 9'},
+    ]
+
+with open('../model/vocabulary.json', 'r') as f:
+    vocab = json.load(f)
+st = SentenceTokenizer(vocab, 30)
+
+# Split using the default split ratio
+print(st.split_train_val_test(DATASET, INFO_DICTS))
+
+# Split explicitly
+print(st.split_train_val_test(DATASET,
+                              INFO_DICTS,
+                              [[0, 1, 2, 4, 9], [5, 6], [7, 8, 3]],
+                              extend_with=1))

resources/app/plugins/deepmoji_plugin/DeepMoji/examples/encode_texts.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+""" Use torchMoji to encode texts into emotional feature vectors.
+"""
+from __future__ import print_function, division, unicode_literals
+import json
+
+from torchmoji.sentence_tokenizer import SentenceTokenizer
+from torchmoji.model_def import torchmoji_feature_encoding
+from torchmoji.global_variables import PRETRAINED_PATH, VOCAB_PATH
+
+TEST_SENTENCES = ['I love mom\'s cooking',
+                  'I love how you never reply back..',
+                  'I love cruising with my homies',
+                  'I love messing with yo mind!!',
+                  'I love you and now you\'re just gone..',
+                  'This is shit',
+                  'This is the shit']
+
+maxlen = 30
+batch_size = 32
+
+print('Tokenizing using dictionary from {}'.format(VOCAB_PATH))
+with open(VOCAB_PATH, 'r') as f:
+    vocabulary = json.load(f)
+st = SentenceTokenizer(vocabulary, maxlen)
+tokenized, _, _ = st.tokenize_sentences(TEST_SENTENCES)
+
+print('Loading model from {}.'.format(PRETRAINED_PATH))
+model = torchmoji_feature_encoding(PRETRAINED_PATH)
+print(model)
+
+print('Encoding texts..')
+encoding = model(tokenized)
+
+print('First 5 dimensions for sentence: {}'.format(TEST_SENTENCES[0]))
+print(encoding[0,:5])
+
+# Now you could visualize the encodings to see differences,
+# run a logistic regression classifier on top,
+# or basically anything you'd like to do.

resources/app/plugins/deepmoji_plugin/DeepMoji/examples/example_helper.py

@@ -0,0 +1,6 @@
+""" Module import helper.
+Modifies PATH in order to allow us to import the torchmoji directory.
+"""
+import sys
+from os.path import abspath, dirname
+sys.path.insert(0, dirname(dirname(abspath(__file__))))

resources/app/plugins/deepmoji_plugin/DeepMoji/examples/finetune_insults_chain-thaw.py

@@ -0,0 +1,44 @@
+"""Finetuning example.
+
+Trains the torchMoji model on the kaggle insults dataset, using the 'chain-thaw'
+finetuning method and the accuracy metric. See the blog post at
+https://medium.com/@bjarkefelbo/what-can-we-learn-from-emojis-6beb165a5ea0
+for more information. Note that results may differ a bit due to slight
+changes in preprocessing and train/val/test split.
+
+The 'chain-thaw' method does the following:
+0) Load all weights except for the softmax layer. Extend the embedding layer if
+   necessary, initialising the new weights with random values.
+1) Freeze every layer except the last (softmax) layer and train it.
+2) Freeze every layer except the first layer and train it.
+3) Freeze every layer except the second etc., until the second last layer.
+4) Unfreeze all layers and train entire model.
+"""
+
+from __future__ import print_function
+import example_helper
+import json
+from torchmoji.model_def import torchmoji_transfer
+from torchmoji.global_variables import PRETRAINED_PATH
+from torchmoji.finetuning import (
+     load_benchmark,
+     finetune)
+
+
+DATASET_PATH = '../data/kaggle-insults/raw.pickle'
+nb_classes = 2
+
+with open('../model/vocabulary.json', 'r') as f:
+    vocab = json.load(f)
+
+# Load dataset. Extend the existing vocabulary with up to 10000 tokens from
+# the training dataset.
+data = load_benchmark(DATASET_PATH, vocab, extend_with=10000)
+
+# Set up model and finetune. Note that we have to extend the embedding layer
+# with the number of tokens added to the vocabulary.
+model = torchmoji_transfer(nb_classes, PRETRAINED_PATH, extend_embedding=data['added'])
+print(model)
+model, acc = finetune(model, data['texts'], data['labels'], nb_classes,
+                      data['batch_size'], method='chain-thaw')
+print('Acc: {}'.format(acc))

resources/app/plugins/deepmoji_plugin/DeepMoji/examples/finetune_semeval_class-avg_f1.py

@@ -0,0 +1,50 @@
+"""Finetuning example.
+
+Trains the torchMoji model on the SemEval emotion dataset, using the 'last'
+finetuning method and the class average F1 metric.
+
+The 'last' method does the following:
+0) Load all weights except for the softmax layer. Do not add tokens to the
+   vocabulary and do not extend the embedding layer.
+1) Freeze all layers except for the softmax layer.
+2) Train.
+
+The class average F1 metric does the following:
+1) For each class, relabel the dataset into binary classification
+   (belongs to/does not belong to this class).
+2) Calculate F1 score for each class.
+3) Compute the average of all F1 scores.
+"""
+
+from __future__ import print_function
+import example_helper
+import json
+from torchmoji.finetuning import load_benchmark
+from torchmoji.class_avg_finetuning import class_avg_finetune
+from torchmoji.model_def import torchmoji_transfer
+from torchmoji.global_variables import PRETRAINED_PATH
+
+DATASET_PATH = '../data/SE0714/raw.pickle'
+nb_classes = 3
+
+with open('../model/vocabulary.json', 'r') as f:
+    vocab = json.load(f)
+
+
+# Load dataset. Extend the existing vocabulary with up to 10000 tokens from
+# the training dataset.
+data = load_benchmark(DATASET_PATH, vocab, extend_with=10000)
+
+# Set up model and finetune. Note that we have to extend the embedding layer
+# with the number of tokens added to the vocabulary.
+#
+# Also note that when using class average F1 to evaluate, the model has to be
+# defined with two classes, since the model will be trained for each class
+# separately.
+model = torchmoji_transfer(2, PRETRAINED_PATH, extend_embedding=data['added'])
+print(model)
+
+# For finetuning however, pass in the actual number of classes.
+model, f1 = class_avg_finetune(model, data['texts'], data['labels'],
+                                nb_classes, data['batch_size'], method='last')
+print('F1: {}'.format(f1))

resources/app/plugins/deepmoji_plugin/DeepMoji/examples/finetune_youtube_last.py

@@ -0,0 +1,35 @@
+"""Finetuning example.
+
+Trains the torchMoji model on the SS-Youtube dataset, using the 'last'
+finetuning method and the accuracy metric.
+
+The 'last' method does the following:
+0) Load all weights except for the softmax layer. Do not add tokens to the
+   vocabulary and do not extend the embedding layer.
+1) Freeze all layers except for the softmax layer.
+2) Train.
+"""
+
+from __future__ import print_function
+import example_helper
+import json
+from torchmoji.model_def import torchmoji_transfer
+from torchmoji.global_variables import PRETRAINED_PATH, VOCAB_PATH, ROOT_PATH
+from torchmoji.finetuning import (
+     load_benchmark,
+     finetune)
+
+DATASET_PATH = '{}/data/SS-Youtube/raw.pickle'.format(ROOT_PATH)
+nb_classes = 2
+
+with open(VOCAB_PATH, 'r') as f:
+    vocab = json.load(f)
+
+# Load dataset.
+data = load_benchmark(DATASET_PATH, vocab)
+
+# Set up model and finetune
+model = torchmoji_transfer(nb_classes, PRETRAINED_PATH)
+print(model)
+model, acc = finetune(model, data['texts'], data['labels'], nb_classes, data['batch_size'], method='last')
+print('Acc: {}'.format(acc))

resources/app/plugins/deepmoji_plugin/DeepMoji/examples/score_texts_emojis.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+
+""" Use torchMoji to score texts for emoji distribution.
+
+The resulting emoji ids (0-63) correspond to the mapping
+in emoji_overview.png file at the root of the torchMoji repo.
+
+Writes the result to a csv file.
+"""
+
+from __future__ import print_function, division, unicode_literals
+
+import sys
+from os.path import abspath, dirname
+
+import json
+import csv
+import numpy as np
+
+from torchmoji.sentence_tokenizer import SentenceTokenizer
+from torchmoji.model_def import torchmoji_emojis
+from torchmoji.global_variables import PRETRAINED_PATH, VOCAB_PATH
+
+sys.path.insert(0, dirname(dirname(abspath(__file__))))
+
+OUTPUT_PATH = 'test_sentences.csv'
+
+TEST_SENTENCES = ['I love mom\'s cooking',
+                  'I love how you never reply back..',
+                  'I love cruising with my homies',
+                  'I love messing with yo mind!!',
+                  'I love you and now you\'re just gone..',
+                  'This is shit',
+                  'This is the shit']
+
+
+def top_elements(array, k):
+    ind = np.argpartition(array, -k)[-k:]
+    return ind[np.argsort(array[ind])][::-1]
+
+maxlen = 30
+
+print('Tokenizing using dictionary from {}'.format(VOCAB_PATH))
+with open(VOCAB_PATH, 'r') as f:
+    vocabulary = json.load(f)
+
+st = SentenceTokenizer(vocabulary, maxlen)
+
+print('Loading model from {}.'.format(PRETRAINED_PATH))
+model = torchmoji_emojis(PRETRAINED_PATH)
+print(model)
+
+def doImportableFunction():
+    print('Running predictions.')
+    tokenized, _, _ = st.tokenize_sentences(TEST_SENTENCES)
+    prob = model(tokenized)
+
+    for prob in [prob]:
+        # Find top emojis for each sentence. Emoji ids (0-63)
+        # correspond to the mapping in emoji_overview.png
+        # at the root of the torchMoji repo.
+        print('Writing results to {}'.format(OUTPUT_PATH))
+        scores = []
+        for i, t in enumerate(TEST_SENTENCES):
+            t_tokens = tokenized[i]
+            t_score = [t]
+            t_prob = prob[i]
+            ind_top = top_elements(t_prob, 5)
+            t_score.append(sum(t_prob[ind_top]))
+            t_score.extend(ind_top)
+            t_score.extend([t_prob[ind] for ind in ind_top])
+            scores.append(t_score)
+            print(t_score)
+
+        with open(OUTPUT_PATH, 'w') as csvfile:
+            writer = csv.writer(csvfile, delimiter=str(','), lineterminator='\n')
+            writer.writerow(['Text', 'Top5%',
+                            'Emoji_1', 'Emoji_2', 'Emoji_3', 'Emoji_4', 'Emoji_5',
+                            'Pct_1', 'Pct_2', 'Pct_3', 'Pct_4', 'Pct_5'])
+            for i, row in enumerate(scores):
+                try:
+                    writer.writerow(row)
+                except:
+                    print("Exception at row {}!".format(i))
+    return

resources/app/plugins/deepmoji_plugin/DeepMoji/examples/text_emojize.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+
+""" Use torchMoji to predict emojis from a single text input
+"""
+
+from __future__ import print_function, division, unicode_literals
+import example_helper
+import json
+import csv
+import argparse
+
+import numpy as np
+import emoji
+
+from torchmoji.sentence_tokenizer import SentenceTokenizer
+from torchmoji.model_def import torchmoji_emojis
+from torchmoji.global_variables import PRETRAINED_PATH, VOCAB_PATH
+
+# Emoji map in emoji_overview.png
+EMOJIS = ":joy: :unamused: :weary: :sob: :heart_eyes: \
+:pensive: :ok_hand: :blush: :heart: :smirk: \
+:grin: :notes: :flushed: :100: :sleeping: \
+:relieved: :relaxed: :raised_hands: :two_hearts: :expressionless: \
+:sweat_smile: :pray: :confused: :kissing_heart: :heartbeat: \
+:neutral_face: :information_desk_person: :disappointed: :see_no_evil: :tired_face: \
+:v: :sunglasses: :rage: :thumbsup: :cry: \
+:sleepy: :yum: :triumph: :hand: :mask: \
+:clap: :eyes: :gun: :persevere: :smiling_imp: \
+:sweat: :broken_heart: :yellow_heart: :musical_note: :speak_no_evil: \
+:wink: :skull: :confounded: :smile: :stuck_out_tongue_winking_eye: \
+:angry: :no_good: :muscle: :facepunch: :purple_heart: \
+:sparkling_heart: :blue_heart: :grimacing: :sparkles:".split(' ')
+
+def top_elements(array, k):
+    ind = np.argpartition(array, -k)[-k:]
+    return ind[np.argsort(array[ind])][::-1]
+
+if __name__ == "__main__":
+    argparser = argparse.ArgumentParser()
+    argparser.add_argument('--text', type=str, required=True, help="Input text to emojize")
+    argparser.add_argument('--maxlen', type=int, default=30, help="Max length of input text")
+    args = argparser.parse_args()
+
+    # Tokenizing using dictionary
+    with open(VOCAB_PATH, 'r') as f:
+        vocabulary = json.load(f)
+
+    st = SentenceTokenizer(vocabulary, args.maxlen)
+
+    # Loading model
+    model = torchmoji_emojis(PRETRAINED_PATH)
+    # Running predictions
+    tokenized, _, _ = st.tokenize_sentences([args.text])
+    # Get sentence probability
+    prob = model(tokenized)[0]
+
+    # Top emoji id
+    emoji_ids = top_elements(prob, 5)
+
+    # map to emojis
+    emojis = map(lambda x: EMOJIS[x], emoji_ids)
+
+    print(emoji.emojize("{} {}".format(args.text,' '.join(emojis)), use_aliases=True))

resources/app/plugins/deepmoji_plugin/DeepMoji/examples/tokenize_dataset.py

@@ -0,0 +1,26 @@
+"""
+Take a given list of sentences and turn it into a numpy array, where each
+number corresponds to a word. Padding is used (number 0) to ensure fixed length
+of sentences.
+"""
+
+from __future__ import print_function, unicode_literals
+import example_helper
+import json
+from torchmoji.sentence_tokenizer import SentenceTokenizer
+
+with open('../model/vocabulary.json', 'r') as f:
+    vocabulary = json.load(f)
+
+st = SentenceTokenizer(vocabulary, 30)
+test_sentences = [
+    '\u2014 -- \u203c !!\U0001F602',
+    'Hello world!',
+    'This is a sample tweet #example',
+    ]
+
+tokens, infos, stats = st.tokenize_sentences(test_sentences)
+
+print(tokens)
+print(infos)
+print(stats)

resources/app/plugins/deepmoji_plugin/DeepMoji/examples/vocab_extension.py

@@ -0,0 +1,30 @@
+"""
+Extend the given vocabulary using dataset-specific words.
+
+1. First create a vocabulary for the specific dataset.
+2. Find all words not in our vocabulary, but in the dataset vocabulary.
+3. Take top X (default=1000) of these words and add them to the vocabulary.
+4. Save this combined vocabulary and embedding matrix, which can now be used.
+"""
+
+from __future__ import print_function, unicode_literals
+import example_helper
+import json
+from torchmoji.create_vocab import extend_vocab, VocabBuilder
+from torchmoji.word_generator import WordGenerator
+
+new_words = ['#zzzzaaazzz', 'newword', 'newword']
+word_gen = WordGenerator(new_words)
+vb = VocabBuilder(word_gen)
+vb.count_all_words()
+
+with open('../model/vocabulary.json') as f:
+    vocab = json.load(f)
+
+print(len(vocab))
+print(vb.word_counts)
+extend_vocab(vocab, vb, max_tokens=1)
+
+# 'newword' should be added because it's more frequent in the given vocab
+print(vocab['newword'])
+print(len(vocab))

resources/app/plugins/deepmoji_plugin/DeepMoji/scripts/analyze_all_results.py

@@ -0,0 +1,40 @@
+from __future__ import print_function
+
+# allow us to import the codebase directory
+import sys
+import glob
+import numpy as np
+from os.path import dirname, abspath
+sys.path.insert(0, dirname(dirname(abspath(__file__))))
+
+DATASETS = ['SE0714', 'Olympic', 'PsychExp', 'SS-Twitter', 'SS-Youtube',
+            'SCv1', 'SV2-GEN'] # 'SE1604' excluded due to Twitter's ToS
+
+def get_results(dset):
+    METHOD = 'last'
+    RESULTS_DIR = 'results/'
+    RESULT_PATHS = glob.glob('{}/{}_{}_*_results.txt'.format(RESULTS_DIR, dset, METHOD))
+    assert len(RESULT_PATHS)
+
+    scores = []
+    for path in RESULT_PATHS:
+        with open(path) as f:
+            score = f.readline().split(':')[1]
+        scores.append(float(score))
+
+    average = np.mean(scores)
+    maximum = max(scores)
+    minimum = min(scores)
+    std = np.std(scores)
+
+    print('Dataset: {}'.format(dset))
+    print('Method:  {}'.format(METHOD))
+    print('Number of results: {}'.format(len(scores)))
+    print('--------------------------')
+    print('Average: {}'.format(average))
+    print('Maximum: {}'.format(maximum))
+    print('Minimum: {}'.format(minimum))
+    print('Standard deviaton: {}'.format(std))
+
+for dset in DATASETS:
+    get_results(dset)

resources/app/plugins/deepmoji_plugin/DeepMoji/scripts/analyze_results.py

@@ -0,0 +1,39 @@
+from __future__ import print_function
+
+import sys
+import glob
+import numpy as np
+
+DATASET = 'SS-Twitter' # 'SE1604' excluded due to Twitter's ToS
+METHOD = 'new'
+
+# Optional usage: analyze_results.py <dataset> <method>
+if len(sys.argv) == 3:
+    DATASET = sys.argv[1]
+    METHOD = sys.argv[2]
+
+RESULTS_DIR = 'results/'
+RESULT_PATHS = glob.glob('{}/{}_{}_*_results.txt'.format(RESULTS_DIR, DATASET, METHOD))
+
+if not RESULT_PATHS:
+    print('Could not find results for \'{}\' using \'{}\' in directory \'{}\'.'.format(DATASET, METHOD, RESULTS_DIR))
+else:
+    scores = []
+    for path in RESULT_PATHS:
+        with open(path) as f:
+            score = f.readline().split(':')[1]
+        scores.append(float(score))
+
+    average = np.mean(scores)
+    maximum = max(scores)
+    minimum = min(scores)
+    std = np.std(scores)
+
+    print('Dataset: {}'.format(DATASET))
+    print('Method:  {}'.format(METHOD))
+    print('Number of results: {}'.format(len(scores)))
+    print('--------------------------')
+    print('Average: {}'.format(average))
+    print('Maximum: {}'.format(maximum))
+    print('Minimum: {}'.format(minimum))
+    print('Standard deviaton: {}'.format(std))

resources/app/plugins/deepmoji_plugin/DeepMoji/scripts/calculate_coverages.py

@@ -0,0 +1,90 @@
+from __future__ import print_function
+import pickle
+import json
+import csv
+import sys
+from io import open
+
+# Allow us to import the torchmoji directory
+from os.path import dirname, abspath
+sys.path.insert(0, dirname(dirname(abspath(__file__))))
+
+from torchmoji.sentence_tokenizer import SentenceTokenizer, coverage
+
+try:
+    unicode        # Python 2
+except NameError:
+    unicode = str  # Python 3
+
+IS_PYTHON2 = int(sys.version[0]) == 2
+
+OUTPUT_PATH = 'coverage.csv'
+DATASET_PATHS = [
+    '../data/Olympic/raw.pickle',
+    '../data/PsychExp/raw.pickle',
+    '../data/SCv1/raw.pickle',
+    '../data/SCv2-GEN/raw.pickle',
+    '../data/SE0714/raw.pickle',
+    #'../data/SE1604/raw.pickle', # Excluded due to Twitter's ToS
+    '../data/SS-Twitter/raw.pickle',
+    '../data/SS-Youtube/raw.pickle',
+    ]
+
+with open('../model/vocabulary.json', 'r') as f:
+    vocab = json.load(f)
+
+results = []
+for p in DATASET_PATHS:
+    coverage_result = [p]
+    print('Calculating coverage for {}'.format(p))
+    with open(p, 'rb') as f:
+        if IS_PYTHON2:
+            s = pickle.load(f)
+        else:
+            s = pickle.load(f, fix_imports=True)
+
+    # Decode data
+    try:
+        s['texts'] = [unicode(x) for x in s['texts']]
+    except UnicodeDecodeError:
+        s['texts'] = [x.decode('utf-8') for x in s['texts']]
+
+    # Own
+    st = SentenceTokenizer({}, 30)
+    tests, dicts, _ = st.split_train_val_test(s['texts'], s['info'],
+                                              [s['train_ind'],
+                                               s['val_ind'],
+                                               s['test_ind']],
+                                              extend_with=10000)
+    coverage_result.append(coverage(tests[2]))
+
+    # Last
+    st = SentenceTokenizer(vocab, 30)
+    tests, dicts, _ = st.split_train_val_test(s['texts'], s['info'],
+                                              [s['train_ind'],
+                                               s['val_ind'],
+                                               s['test_ind']],
+                                              extend_with=0)
+    coverage_result.append(coverage(tests[2]))
+
+    # Full
+    st = SentenceTokenizer(vocab, 30)
+    tests, dicts, _ = st.split_train_val_test(s['texts'], s['info'],
+                                              [s['train_ind'],
+                                               s['val_ind'],
+                                               s['test_ind']],
+                                              extend_with=10000)
+    coverage_result.append(coverage(tests[2]))
+
+    results.append(coverage_result)
+
+with open(OUTPUT_PATH, 'wb') as csvfile:
+    writer = csv.writer(csvfile, delimiter='\t', lineterminator='\n')
+    writer.writerow(['Dataset', 'Own', 'Last', 'Full'])
+    for i, row in enumerate(results):
+        try:
+            writer.writerow(row)
+        except:
+            print("Exception at row {}!".format(i))
+
+print('Saved to {}'.format(OUTPUT_PATH))

resources/app/plugins/deepmoji_plugin/DeepMoji/scripts/convert_all_datasets.py

@@ -0,0 +1,110 @@
+from __future__ import print_function
+
+import json
+import math
+import pickle
+import sys
+from io import open
+import numpy as np
+from os.path import abspath, dirname
+sys.path.insert(0, dirname(dirname(abspath(__file__))))
+
+from torchmoji.word_generator import WordGenerator
+from torchmoji.create_vocab import VocabBuilder
+from torchmoji.sentence_tokenizer import SentenceTokenizer, extend_vocab, coverage
+from torchmoji.tokenizer import tokenize
+
+try:
+    unicode        # Python 2
+except NameError:
+    unicode = str  # Python 3
+
+IS_PYTHON2 = int(sys.version[0]) == 2
+
+DATASETS = [
+    'Olympic',
+    'PsychExp',
+    'SCv1',
+    'SCv2-GEN',
+    'SE0714',
+    #'SE1604', # Excluded due to Twitter's ToS
+    'SS-Twitter',
+    'SS-Youtube',
+    ]
+
+DIR = '../data'
+FILENAME_RAW = 'raw.pickle'
+FILENAME_OWN = 'own_vocab.pickle'
+FILENAME_OUR = 'twitter_vocab.pickle'
+FILENAME_COMBINED = 'combined_vocab.pickle'
+
+
+def roundup(x):
+    return int(math.ceil(x / 10.0)) * 10
+
+
+def format_pickle(dset, train_texts, val_texts, test_texts, train_labels, val_labels, test_labels):
+    return {'dataset': dset,
+            'train_texts': train_texts,
+            'val_texts': val_texts,
+            'test_texts': test_texts,
+            'train_labels': train_labels,
+            'val_labels': val_labels,
+            'test_labels': test_labels}
+
+def convert_dataset(filepath, extend_with, vocab):
+    print('-- Generating {} '.format(filepath))
+    sys.stdout.flush()
+    st = SentenceTokenizer(vocab, maxlen)
+    tokenized, dicts, _ = st.split_train_val_test(texts,
+                                                  labels,
+                                                  [data['train_ind'],
+                                                   data['val_ind'],
+                                                   data['test_ind']],
+                                                  extend_with=extend_with)
+    pick = format_pickle(dset, tokenized[0], tokenized[1], tokenized[2],
+                        dicts[0], dicts[1], dicts[2])
+    with open(filepath, 'w') as f:
+        pickle.dump(pick, f)
+    cover = coverage(tokenized[2])
+
+    print('     done. Coverage: {}'.format(cover))
+
+with open('../model/vocabulary.json', 'r') as f:
+    vocab = json.load(f)
+
+for dset in DATASETS:
+    print('Converting {}'.format(dset))
+
+    PATH_RAW = '{}/{}/{}'.format(DIR, dset, FILENAME_RAW)
+    PATH_OWN = '{}/{}/{}'.format(DIR, dset, FILENAME_OWN)
+    PATH_OUR = '{}/{}/{}'.format(DIR, dset, FILENAME_OUR)
+    PATH_COMBINED = '{}/{}/{}'.format(DIR, dset, FILENAME_COMBINED)
+
+    with open(PATH_RAW, 'rb') as dataset:
+        if IS_PYTHON2:
+            data = pickle.load(dataset)
+        else:
+            data = pickle.load(dataset, fix_imports=True)
+
+    # Decode data
+    try:
+        texts = [unicode(x) for x in data['texts']]
+    except UnicodeDecodeError:
+        texts = [x.decode('utf-8') for x in data['texts']]
+
+    wg = WordGenerator(texts)
+    vb = VocabBuilder(wg)
+    vb.count_all_words()
+
+    # Calculate max length of sequences considered
+    # Adjust batch_size accordingly to prevent GPU overflow
+    lengths = [len(tokenize(t)) for t in texts]
+    maxlen = roundup(np.percentile(lengths, 80.0))
+
+    # Extract labels
+    labels = [x['label'] for x in data['info']]
+
+    convert_dataset(PATH_OWN, 50000, {})
+    convert_dataset(PATH_OUR, 0, vocab)
+    convert_dataset(PATH_COMBINED, 10000, vocab)

resources/app/plugins/deepmoji_plugin/DeepMoji/scripts/download_weights.py

@@ -0,0 +1,65 @@
+from __future__ import print_function
+import os
+from subprocess import call
+from builtins import input
+
+curr_folder = os.path.basename(os.path.normpath(os.getcwd()))
+
+weights_filename = 'pytorch_model.bin'
+weights_folder = 'model'
+weights_path = '{}/{}'.format(weights_folder, weights_filename)
+if curr_folder == 'scripts':
+    weights_path = '../' + weights_path
+weights_download_link = 'https://www.dropbox.com/s/q8lax9ary32c7t9/pytorch_model.bin?dl=0#'
+
+
+MB_FACTOR = float(1<<20)
+
+def prompt():
+    while True:
+        valid = {
+            'y': True,
+            'ye': True,
+            'yes': True,
+            'n': False,
+            'no': False,
+        }
+        choice = input().lower()
+        if choice in valid:
+            return valid[choice]
+        else:
+            print('Please respond with \'y\' or \'n\' (or \'yes\' or \'no\')')
+
+download = True
+if os.path.exists(weights_path):
+    print('Weight file already exists at {}. Would you like to redownload it anyway? [y/n]'.format(weights_path))
+    download = prompt()
+    already_exists = True
+else:
+    already_exists = False
+
+if download:
+    print('About to download the pretrained weights file from {}'.format(weights_download_link))
+    if already_exists == False:
+        print('The size of the file is roughly 85MB. Continue? [y/n]')
+    else:
+        os.unlink(weights_path)
+
+    if already_exists or prompt():
+        print('Downloading...')
+
+        #urllib.urlretrieve(weights_download_link, weights_path)
+        #with open(weights_path,'wb') as f:
+        #    f.write(requests.get(weights_download_link).content)
+
+        # downloading using wget due to issues with urlretrieve and requests
+        sys_call = 'wget {} -O {}'.format(weights_download_link, os.path.abspath(weights_path))
+        print("Running system call: {}".format(sys_call))
+        call(sys_call, shell=True)
+
+        if os.path.getsize(weights_path) / MB_FACTOR < 80:
+            raise ValueError("Download finished, but the resulting file is too small! " +
+                             "It\'s only {} bytes.".format(os.path.getsize(weights_path)))
+        print('Downloaded weights to {}'.format(weights_path))
+else:
+    print('Exiting.')

resources/app/plugins/deepmoji_plugin/DeepMoji/scripts/finetune_dataset.py

@@ -0,0 +1,109 @@
+""" Finetuning example.
+"""
+from __future__ import print_function
+import sys
+import numpy as np
+from os.path import abspath, dirname
+sys.path.insert(0, dirname(dirname(abspath(__file__))))
+
+import json
+import math
+from torchmoji.model_def import torchmoji_transfer
+from torchmoji.global_variables import PRETRAINED_PATH, VOCAB_PATH
+from torchmoji.finetuning import (
+     load_benchmark,
+     finetune)
+from torchmoji.class_avg_finetuning import class_avg_finetune
+
+def roundup(x):
+    return int(math.ceil(x / 10.0)) * 10
+
+
+# Format: (dataset_name,
+#          path_to_dataset,
+#          nb_classes,
+#          use_f1_score)
+DATASETS = [
+     #('SE0714', '../data/SE0714/raw.pickle', 3, True),
+     #('Olympic', '../data/Olympic/raw.pickle', 4, True),
+     #('PsychExp', '../data/PsychExp/raw.pickle', 7, True),
+     #('SS-Twitter', '../data/SS-Twitter/raw.pickle', 2, False),
+     ('SS-Youtube', '../data/SS-Youtube/raw.pickle', 2, False),
+     #('SE1604', '../data/SE1604/raw.pickle', 3, False), # Excluded due to Twitter's ToS
+     #('SCv1', '../data/SCv1/raw.pickle', 2, True),
+     #('SCv2-GEN', '../data/SCv2-GEN/raw.pickle', 2, True)
+      ]
+
+RESULTS_DIR = 'results'
+
+# 'new' | 'last' | 'full' | 'chain-thaw'
+FINETUNE_METHOD = 'last'
+VERBOSE = 1
+
+nb_tokens = 50000
+nb_epochs = 1000
+epoch_size = 1000
+
+with open(VOCAB_PATH, 'r') as f:
+    vocab = json.load(f)
+
+for rerun_iter in range(5):
+    for p in DATASETS:
+
+        # debugging
+        assert len(vocab) == nb_tokens
+
+        dset = p[0]
+        path = p[1]
+        nb_classes = p[2]
+        use_f1_score = p[3]
+
+        if FINETUNE_METHOD == 'last':
+            extend_with = 0
+        elif FINETUNE_METHOD in ['new', 'full', 'chain-thaw']:
+            extend_with = 10000
+        else:
+            raise ValueError('Finetuning method not recognised!')
+
+        # Load dataset.
+        data = load_benchmark(path, vocab, extend_with=extend_with)
+
+        (X_train, y_train) = (data['texts'][0], data['labels'][0])
+        (X_val, y_val) = (data['texts'][1], data['labels'][1])
+        (X_test, y_test) = (data['texts'][2], data['labels'][2])
+
+        weight_path = PRETRAINED_PATH if FINETUNE_METHOD != 'new' else None
+        nb_model_classes = 2 if use_f1_score else nb_classes
+        model = torchmoji_transfer(
+                    nb_model_classes,
+                    weight_path,
+                    extend_embedding=data['added'])
+        print(model)
+
+        # Training
+        print('Training: {}'.format(path))
+        if use_f1_score:
+            model, result = class_avg_finetune(model, data['texts'],
+                                               data['labels'],
+                                               nb_classes, data['batch_size'],
+                                               FINETUNE_METHOD,
+                                               verbose=VERBOSE)
+        else:
+            model, result = finetune(model, data['texts'], data['labels'],
+                                     nb_classes, data['batch_size'],
+                                     FINETUNE_METHOD, metric='acc',
+                                     verbose=VERBOSE)
+
+        # Write results
+        if use_f1_score:
+            print('Overall F1 score (dset = {}): {}'.format(dset, result))
+            with open('{}/{}_{}_{}_results.txt'.
+                      format(RESULTS_DIR, dset, FINETUNE_METHOD, rerun_iter),
+                      "w") as f:
+                f.write("F1: {}\n".format(result))
+        else:
+            print('Test accuracy (dset = {}): {}'.format(dset, result))
+            with open('{}/{}_{}_{}_results.txt'.
+                      format(RESULTS_DIR, dset, FINETUNE_METHOD, rerun_iter),
+                      "w") as f:
+                f.write("Acc: {}\n".format(result))

resources/app/plugins/deepmoji_plugin/DeepMoji/scripts/results/.gitkeep

@@ -0,0 +1 @@
+ 

resources/app/plugins/deepmoji_plugin/DeepMoji/setup.py

@@ -0,0 +1,16 @@
+from setuptools import setup
+
+setup(
+    name='torchmoji',
+    version='1.0',
+    packages=['torchmoji'],
+    description='torchMoji',
+    include_package_data=True,
+    install_requires=[
+        'emoji==0.4.5',
+        'numpy==1.13.1',
+        'scipy==0.19.1',
+        'scikit-learn==0.19.0',
+        'text-unidecode==1.0',
+    ],
+)