Merge branch 'add-typing' into dev

Author: SamR1

.gitlab-ci.yml

@@ -1,4 +1,4 @@
-image: python:3.9
+image: python:3.10
 
 stages:
   - lint
@@ -17,11 +17,6 @@ lint:
   script:
     - pytest --flake8 --isort --black -m "flake8 or isort or black" twootfeed
 
-python-3.6:
-  stage: tests
-  extends: .python
-  image: python:3.6
-
 python-3.7:
   stage: tests
   extends: .python
@@ -33,6 +28,11 @@ python-3.8:
   image: python:3.8
 
 python-3.9:
+  stage: tests
+  extends: .python
+  image: python:3.9
+
+python-3.10:
   stage: tests
   before_script:
     - pip install -e .[test]

Makefile

@@ -2,13 +2,19 @@ include Makefile.config
 -include Makefile.custom.config
 .SILENT:
 
+check: type-check lint test
+
 clean:
+	rm -rf .mypy_cache
+	rm -rf .pytest_cache
+
+clean-all: clean
 	rm -fr $(VENV)
 	rm -fr *.egg-info
 	rm -fr .eggs
-	rm -rf .pytest_cache
 	rm -fr build
 	rm -rf dist
+	rm -rf *.log
 
 create-mastodon-cli:
 	$(PYTHON) $(FLASK_APP)/utils/create_mastodon_client.py
@@ -42,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

@@ -16,10 +16,10 @@ classifiers =
   License :: OSI Approved :: MIT License
   Operating System :: POSIX :: Linux
   Programming Language :: Python :: 3
-  Programming Language :: Python :: 3.6
   Programming Language :: Python :: 3.7
   Programming Language :: Python :: 3.8
   Programming Language :: Python :: 3.9
+  Programming Language :: Python :: 3.10
   Topic :: Internet :: WWW/HTTP
 project_urls =
   Documentation = https://samr1.github.io/python-twootfeed
@@ -29,27 +29,33 @@ packages = find:
 zip_safe = false
 setup_requires = pytest-runner
 install_requires =
-  beautifulsoup4==4.10.0
+  beautifulsoup4==4.11.1
   feedgenerator==2.0.0
-  Flask==2.0.2
+  Flask==2.1.3
   gunicorn==20.1.0
   Mastodon.py==1.5.1
-  pytz==2021.3
-  PyYAML==5.4.1
-  tweepy==4.0.1
+  pytz==2022.1
+  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)