add typing

Author: SamR1

Makefile

@@ -2,9 +2,10 @@ include Makefile.config
 -include Makefile.custom.config
 .SILENT:
 
-check: lint test
+check: type-check lint test
 
 clean:
+	rm -rf .mypy_cache
 	rm -rf .pytest_cache
 
 clean-all: clean
@@ -47,3 +48,7 @@ venv:
 
 test:
 	$(PYTEST) $(FLASK_APP) --cov $(FLASK_APP) --cov-report term-missing $(PYTEST_ARGS)
+
+type-check:
+	echo 'Running mypy...'
+	$(MYPY) $(FLASK_APP)

Makefile.config

@@ -18,6 +18,7 @@ FLASK = $(VENV)/bin/flask
 PYTEST = $(VENV)/bin/py.test
 GUNICORN = $(VENV)/bin/gunicorn
 BLACK = $(VENV)/bin/black
+MYPY = $(VENV)/bin/mypy
 
 #Sphinx Docs
 SPHINXOPTS    ?=

mypy.ini

@@ -0,0 +1,9 @@
+# Global options:
+
+[mypy]
+python_version = 3.10
+disallow_untyped_defs = True
+ignore_missing_imports = True
+
+
+# Per-module options:

setup.cfg

@@ -38,18 +38,24 @@ install_requires =
   PyYAML==6.0.0
   tweepy==4.10.0
 tests_require =
+  mypy
   pytest-cov
   pytest-flake8
   pytest-isort
   pytest-black
+  types-pytz
+  types-PyYAML
 include_package_data = True
 
 [options.extras_require]
 test =
+  mypy
   pytest-cov
   pytest-flake8
   pytest-isort
   pytest-black
+  types-pytz
+  types-PyYAML
 doc =
   sphinx
   sphinx_rtd_theme

twootfeed/__init__.py

@@ -26,7 +26,7 @@
 mastodon_api = get_mastodon_api(param, app_log)
 
 
-def create_app():
+def create_app() -> Flask:
     app = Flask(__name__)
     app_log.setLevel(logging.DEBUG if app.debug else logging.INFO)
 
@@ -37,7 +37,7 @@ def create_app():
     app.register_blueprint(twitter_bp)
 
     @app.route('/')
-    def index_page():
+    def index_page() -> str:
         message = (
             'The RSS feeds are available on these urls : \r\n'
             'for Twitter : http://localhost:5000/_keywords_ or '

twootfeed/__main__.py

@@ -1,19 +1,21 @@
 # source: http://docs.gunicorn.org/en/stable/custom.html
-from __future__ import unicode_literals
-
 import multiprocessing
+from typing import Dict, Optional
 
 import gunicorn.app.base
+from flask import Flask
 from twootfeed import create_app, param
 
 
 class StandaloneApplication(gunicorn.app.base.BaseApplication):
-    def __init__(self, current_app, options=None):
+    def __init__(
+        self, current_app: Flask, options: Optional[Dict] = None
+    ) -> None:
         self.options = options or {}
         self.application = current_app
         super().__init__()
 
-    def load_config(self):
+    def load_config(self) -> None:
         config = {
             key: value
             for key, value in self.options.items()
@@ -22,15 +24,15 @@ def load_config(self):
         for key, value in config.items():
             self.cfg.set(key.lower(), value)
 
-    def load(self):
+    def load(self) -> Flask:
         return self.application
 
 
-def number_of_workers():
+def number_of_workers() -> int:
     return (multiprocessing.cpu_count() * 2) + 1
 
 
-def main():
+def main() -> None:
     app = create_app()
     options = {
         'bind': f"{param['app']['host']}:{param['app']['port']}",

twootfeed/mastodon/generate_toots_feed.py

@@ -1,11 +1,13 @@
 from html import unescape
+from typing import Dict, List, Optional, Tuple
 
 import pytz
 from bs4 import BeautifulSoup
+from mastodon import Mastodon
 from twootfeed.utils.feed_generation import generate_feed
 
 
-def format_toot(toot, text_length_limit):
+def format_toot(toot: Dict, text_length_limit: int) -> Dict:
     rss_toot = {
         'display_name': toot['account']['display_name'],
         'screen_name': toot['account']['username'],
@@ -25,7 +27,7 @@ def format_toot(toot, text_length_limit):
     if source:
         rss_toot['htmltext'] += '<i>Source: {}</i>'.format(source.get('name'))
 
-    medialist = toot.get('media_attachments')
+    medialist = toot.get('media_attachments', [])
     if len(medialist) > 0:
         rss_toot['htmltext'] += '<br>'
     for media in medialist:
@@ -53,8 +55,12 @@ def format_toot(toot, text_length_limit):
 
 
 def generate_mastodon_feed(
-    result, param, feed_title, feed_link, feed_desc=None
-):
+    result: List[Dict],
+    param: Dict,
+    feed_title: str,
+    feed_link: str,
+    feed_desc: Optional[str] = None,
+) -> str:
     text_length_limit = int(param['feed'].get('text_length_limit', 100))
     f = generate_feed(feed_title, feed_link, param, feed_desc)
 
@@ -86,7 +92,9 @@ def generate_mastodon_feed(
     return xml
 
 
-def get_next_toots(api, first_toots, max_items):
+def get_next_toots(
+    api: Mastodon, first_toots: List[Dict], max_items: int
+) -> List[Dict]:
     if len(first_toots) == 0:
         return first_toots
     result = first_toots
@@ -104,7 +112,12 @@ def get_next_toots(api, first_toots, max_items):
     return result
 
 
-def generate_xml(api, param, query_feed=None, favorites=False):
+def generate_xml(
+    api: Mastodon,
+    param: Dict,
+    query_feed: Optional[Dict] = None,
+    favorites: bool = False,
+) -> Tuple[str, int]:
     if api:
         max_items = param['feed']['max_items']
         if query_feed:

twootfeed/mastodon/get_api.py

@@ -1,10 +1,12 @@
 import os
+from logging import Logger
+from typing import Dict
 
 from mastodon import Mastodon
 from twootfeed.utils.config import default_directory
 
 
-def get_mastodon_api(param, app_log):
+def get_mastodon_api(param: Dict, app_log: Logger) -> Mastodon:
     mastodon_api = None
 
     try:

twootfeed/mastodon/routes.py

@@ -1,3 +1,5 @@
+from typing import Tuple
+
 from flask import Blueprint
 from twootfeed import mastodon_api, param as mastodon_param
 from twootfeed.mastodon.generate_toots_feed import generate_xml
@@ -6,26 +8,26 @@
 
 
 @mastodon_bp.route('/toots/<hashtag>', methods=['GET'])
-def tootfeed_hashtag(hashtag):
+def tootfeed_hashtag(hashtag: str) -> Tuple[str, int]:
     """generate a rss feed from parsed mastodon search"""
     return generate_xml(mastodon_api, mastodon_param, {'hashtag': hashtag})
 
 
 @mastodon_bp.route('/toots/search/<query_feed>', methods=['GET'])
 @mastodon_bp.route('/toot_search/<query_feed>', methods=['GET'])
-def tootfeed(query_feed):
+def tootfeed(query_feed: str) -> Tuple[str, int]:
     """generate a rss feed from parsed mastodon search"""
     return generate_xml(mastodon_api, mastodon_param, {'query': query_feed})
 
 
 @mastodon_bp.route('/toots/favorites', methods=['GET'])
 @mastodon_bp.route('/toot_favorites', methods=['GET'])
-def toot_favorites_feed():
+def toot_favorites_feed() -> Tuple[str, int]:
     """generate an rss feed authenticated user's favorites"""
     return generate_xml(mastodon_api, mastodon_param, favorites=True)
 
 
 @mastodon_bp.route('/toots/bookmarks', methods=['GET'])
-def toot_bookmarks_feed():
+def toot_bookmarks_feed() -> Tuple[str, int]:
     """generate an rss feed authenticated user's bookmarks"""
     return generate_xml(mastodon_api, mastodon_param)

twootfeed/tests/conftest.py

@@ -1,20 +1,22 @@
+from typing import Any, Dict, List
 from unittest.mock import Mock
 
 import pytest
+from flask import Flask
 
 from .. import create_app
 from .data import retweet, tweet_1, tweet_no_full_text
 from .utils import Tweepy
 
 
-def mock_api(tweets):
+def mock_api(tweets: List[Dict]) -> Mock:
     mock_response = Mock()
     mock_response.return_value = Tweepy(tweets)
     return mock_response
 
 
 @pytest.fixture
-def app(monkeypatch, tmpdir):
+def app(monkeypatch: pytest.MonkeyPatch, tmpdir: Any) -> Flask:
     test_dir = str(tmpdir)
     monkeypatch.setenv('TWOOTFEED_CONFIG', test_dir)
     monkeypatch.setenv('TWOOTFEED_CONFIG_FILE', test_dir + '/config.yml')
@@ -23,32 +25,32 @@ def app(monkeypatch, tmpdir):
 
 
 @pytest.fixture()
-def fake_tweepy_ok():
+def fake_tweepy_ok() -> Mock:
     return mock_api(tweets=[tweet_1])
 
 
 @pytest.fixture()
-def fake_tweepy_retweet():
+def fake_tweepy_retweet() -> Mock:
     return mock_api(tweets=[retweet])
 
 
 @pytest.fixture()
-def fake_tweepy_no_full_text():
+def fake_tweepy_no_full_text() -> Mock:
     return mock_api(tweets=[tweet_no_full_text])
 
 
 @pytest.fixture()
-def fake_tweepy_no_tweets():
+def fake_tweepy_no_tweets() -> Mock:
     return mock_api(tweets=[])
 
 
 @pytest.fixture()
-def fake_tweepy_200_ok():
+def fake_tweepy_200_ok() -> Mock:
     return mock_api(tweets=[tweet_1] * 200)
 
 
 @pytest.fixture()
-def fake_tweepy_220_ok():
+def fake_tweepy_220_ok() -> Mock:
     return mock_api(
         tweets=[tweet_1] * 200 + [tweet_no_full_text] * 10 + [retweet] * 10
     )

twootfeed/tests/data.py

@@ -1,5 +1,6 @@
 from copy import deepcopy
 from datetime import datetime
+from typing import Dict
 
 import pytz
 
@@ -32,11 +33,11 @@
     'app': {'host': '0.0.0.0', 'port': '8080'},
 }
 
-invalid_param = deepcopy(init_param)
+invalid_param: Dict = deepcopy(init_param)
 invalid_param['mastodon']['client_id_file'] = 'tootrss_clientcred_invalid.txt'
 invalid_param['mastodon']['access_token_file'] = 'tootrss_usercred_invalid.txt'
 
-invalid_param_api = deepcopy(invalid_param)
+invalid_param_api: Dict = deepcopy(invalid_param)
 invalid_param_api['twitter'] = None
 invalid_param_api['mastodon'] = None
 

twootfeed/tests/test_default_route.py

@@ -1,4 +1,7 @@
-def test_default_route(app):
+from flask import Flask
+
+
+def test_default_route(app: Flask) -> None:
     client = app.test_client()
     response = client.get('/')
     assert response.status_code == 200