Enable all Pylint errors

.github/workflows/code-quality.yml

@@ -8,9 +8,9 @@ jobs:
     - uses: actions/checkout@v2
     - uses: actions/setup-python@v2
       with:
-        python-version: 3.x
+        python-version: 3.8
     - run: pip install --upgrade pip
-    - run: pip install "black<23" pylint==v3.0.0a3 mypy==v0.971 types-setuptools "returns<1"
-    - run: black --diff --check $(git ls-files -- '*.py' ':!:tests/*' ':!:docs/*' ':!:examples/*')
-    - run: pylint --disable=all --enable=unused-import $(git ls-files -- '*.py' ':!:tests/*' ':!:docs/*' ':!:examples/*')
-    - run: mypy --strict $(git ls-files -- '*.py' ':!:tests/*' ':!:docs/*' ':!:examples/*')
+    - run: pip install types-setuptools "black<23" "pylint<3" "mypy<1" "jsonschema<5" pytest "returns<1" "aiohttp<4" "aiozmq<1" "django<5" "fastapi<1" "flask<3" "flask-socketio<5.3.1" "pyzmq" "sanic" "tornado<7" "uvicorn<1" "websockets<11"
+    - run: black --diff --check $(git ls-files -- '*.py' ':!:docs/*')
+    - run: pylint $(git ls-files -- '*.py' ':!:docs/*')
+    - run: mypy --strict $(git ls-files -- '*.py' ':!:docs/*')

.pre-commit-config.yaml

@@ -1,3 +1,6 @@
+default_language_version:
+  python: python3.8
+exclude: (^docs)
 fail_fast: true
 repos:
   - repo: https://github.com/ambv/black
@@ -6,16 +9,44 @@ repos:
       - id: black
         args: [--diff, --check]
 
-  - repo: https://github.com/pre-commit/mirrors-pylint
-    rev: v3.0.0a5
+  - repo: https://github.com/PyCQA/pylint
+    rev: v2.15.3
     hooks:
       - id: pylint
-        args: [--disable=all, --enable=unused-import]
+        args: [--ignored-modules=returns]
+        additional_dependencies:
+          - returns<1
+          - aiohttp<4
+          - aiozmq<1
+          - django<5
+          - fastapi<1
+          - flask<3
+          - flask-socketio<5.3.1
+          - jsonschema<5
+          - pytest
+          - pyzmq
+          - sanic
+          - tornado<7
+          - uvicorn<1
+          - websockets<11
 
   - repo: https://github.com/pre-commit/mirrors-mypy
     rev: v0.971
     hooks:
       - id: mypy
-        exclude: (^tests|^examples|^docs)
         args: [--strict]
-        additional_dependencies: ['types-setuptools', 'returns']
+        additional_dependencies:
+          - returns<1
+          - aiohttp<4
+          - aiozmq<1
+          - django<5
+          - fastapi<1
+          - flask<3
+          - flask-socketio<5.3.1
+          - pytest
+          - pyzmq
+          - sanic
+          - tornado<7
+          - types-setuptools
+          - uvicorn<1
+          - websockets<11

examples/aiohttp_server.py

@@ -1,13 +1,16 @@
+"""AioHTTP server"""
 from aiohttp import web
 from jsonrpcserver import async_dispatch, async_method, Ok, Result
 
 
 @async_method
 async def ping() -> Result:
+    """JSON-RPC method"""
     return Ok("pong")
 
 
-async def handle(request):
+async def handle(request: web.Request) -> web.Response:
+    """Handle aiohttp request"""
     return web.Response(
         text=await async_dispatch(await request.text()), content_type="application/json"
     )

examples/aiozmq_server.py

@@ -1,15 +1,19 @@
-from jsonrpcserver import async_dispatch, async_method, Ok, Result
-import aiozmq
+"""AioZMQ server"""
 import asyncio
+
+import aiozmq  # type: ignore
 import zmq
+from jsonrpcserver import async_dispatch, async_method, Ok, Result
 
 
 @async_method
 async def ping() -> Result:
+    """JSON-RPC method"""
     return Ok("pong")
 
 
-async def main():
+async def main() -> None:
+    """Handle AioZMQ request"""
     rep = await aiozmq.create_zmq_stream(zmq.REP, bind="tcp://*:5000")
     while True:
         request = (await rep.read())[0].decode()

examples/asyncio_server.py

@@ -1,4 +1,4 @@
-"""Demonstrates processing a batch of 100 requests asynchronously"""
+"""Demonstrates processing a batch of 100 requests asynchronously with asyncio."""
 import asyncio
 import json
 
@@ -7,12 +7,14 @@
 
 @async_method
 async def sleep_() -> Result:
+    """JSON-RPC method"""
     await asyncio.sleep(1)
     return Ok()
 
 
-async def handle(request: str) -> None:
-    print(await async_dispatch(request))
+async def handle(req: str) -> None:
+    """Handle asyncio event"""
+    print(await async_dispatch(req))
 
 
 if __name__ == "__main__":

examples/django_server.py

@@ -1,15 +1,18 @@
-from django.http import HttpResponse
-from django.views.decorators.csrf import csrf_exempt
+"""Django server"""
+from django.http import HttpRequest, HttpResponse  # type: ignore
+from django.views.decorators.csrf import csrf_exempt  # type: ignore
 from jsonrpcserver import dispatch, method, Ok, Result
 
 
 @method
 def ping() -> Result:
+    """JSON-RPC method"""
     return Ok("pong")
 
 
-@csrf_exempt
-def jsonrpc(request):
+@csrf_exempt  # type: ignore
+def jsonrpc(request: HttpRequest) -> HttpResponse:
+    """Handle Django request"""
     return HttpResponse(
         dispatch(request.body.decode()), content_type="application/json"
     )

examples/fastapi_server.py

@@ -1,17 +1,20 @@
+"""FastAPI server"""
 from fastapi import FastAPI, Request, Response
 from jsonrpcserver import dispatch, method, Ok, Result
-import uvicorn
+import uvicorn  # type: ignore
 
 app = FastAPI()
 
 
 @method
 def ping() -> Result:
+    """JSON-RPC method"""
     return Ok("pong")
 
 
 @app.post("/")
-async def index(request: Request):
+async def index(request: Request) -> Response:
+    """Handle FastAPI request"""
     return Response(dispatch(await request.body()))
 
 

examples/flask_server.py

@@ -1,3 +1,4 @@
+"""Flask server"""
 from flask import Flask, Response, request
 from jsonrpcserver import dispatch, method, Ok, Result
 
@@ -6,11 +7,13 @@
 
 @method
 def ping() -> Result:
+    """JSON-RPC method"""
     return Ok("pong")
 
 
 @app.route("/", methods=["POST"])
-def index():
+def index() -> Response:
+    """Handle Flask request"""
     return Response(
         dispatch(request.get_data().decode()), content_type="application/json"
     )

examples/http_server.py

@@ -1,15 +1,23 @@
+"""HTTPServer server
+
+Demonstrates using Python's builtin http.server module to serve JSON-RPC.
+"""
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
 from jsonrpcserver import dispatch, method, Ok, Result
 
 
 @method
 def ping() -> Result:
+    """JSON-RPC method"""
     return Ok("pong")
 
 
 class TestHttpServer(BaseHTTPRequestHandler):
-    def do_POST(self):
+    """HTTPServer request handler"""
+
+    def do_POST(self) -> None:  # pylint: disable=invalid-name
+        """POST handler"""
         # Process request
         request = self.rfile.read(int(self.headers["Content-Length"])).decode()
         response = dispatch(request)

examples/jsonrpcserver_server.py

@@ -1,8 +1,13 @@
+"""Jsonrpcserver server.
+
+Uses jsonrpcserver's built-in "serve" function.
+"""
 from jsonrpcserver import method, serve, Ok, Result
 
 
 @method
 def ping() -> Result:
+    """JSON-RPC method"""
     return Ok("pong")
 
 

examples/sanic_server.py

@@ -1,18 +1,21 @@
+"""Sanic server"""
 from sanic import Sanic
 from sanic.request import Request
-from sanic.response import json
+from sanic.response import HTTPResponse, json
 from jsonrpcserver import dispatch_to_serializable, method, Ok, Result
 
 app = Sanic("JSON-RPC app")
 
 
 @method
 def ping() -> Result:
+    """JSON-RPC method"""
     return Ok("pong")
 
 
 @app.route("/", methods=["POST"])
-async def test(request: Request):
+async def test(request: Request) -> HTTPResponse:
+    """Handle Sanic request"""
     return json(dispatch_to_serializable(request.body))
 
 

examples/socketio_server.py

@@ -1,5 +1,6 @@
-from flask import Flask
-from flask_socketio import SocketIO, send
+"""SocketIO server"""
+from flask import Flask, Request
+from flask_socketio import SocketIO, send  # type: ignore
 from jsonrpcserver import dispatch, method, Ok, Result
 
 app = Flask(__name__)
@@ -8,11 +9,13 @@
 
 @method
 def ping() -> Result:
+    """JSON-RPC method"""
     return Ok("pong")
 
 
-@socketio.on("message")
-def handle_message(request):
+@socketio.on("message")  # type: ignore
+def handle_message(request: Request) -> None:
+    """Handle SocketIO request"""
     if response := dispatch(request):
         send(response, json=True)
 

examples/tornado_server.py

@@ -1,18 +1,29 @@
-from jsonrpcserver import async_dispatch, async_method, Ok, Result
+"""Tornado server"""
+from typing import Awaitable, Optional
+
 from tornado import ioloop, web
+from jsonrpcserver import async_dispatch, async_method, Ok, Result
 
 
 @async_method
 async def ping() -> Result:
+    """JSON-RPC method"""
     return Ok("pong")
 
 
 class MainHandler(web.RequestHandler):
+    """Handle Tornado request"""
+
     async def post(self) -> None:
+        """Post"""
         request = self.request.body.decode()
-        if response := await async_dispatch(request):
+        response = await async_dispatch(request)
+        if response:
             self.write(response)
 
+    def data_received(self, chunk: bytes) -> Optional[Awaitable[None]]:
+        pass
+
 
 app = web.Application([(r"/", MainHandler)])
 

examples/websockets_server.py

@@ -1,19 +1,22 @@
+"""Websockets server"""
 import asyncio
 
+from websockets.server import WebSocketServerProtocol, serve
 from jsonrpcserver import async_dispatch, async_method, Ok, Result
-import websockets
 
 
 @async_method
 async def ping() -> Result:
+    """JSON-RPC method"""
     return Ok("pong")
 
 
-async def main(websocket, path):
+async def main(websocket: WebSocketServerProtocol, _: str) -> None:
+    """Handle Websocket message"""
     if response := await async_dispatch(await websocket.recv()):
         await websocket.send(response)
 
 
-start_server = websockets.serve(main, "localhost", 5000)
+start_server = serve(main, "localhost", 5000)
 asyncio.get_event_loop().run_until_complete(start_server)
 asyncio.get_event_loop().run_forever()

examples/werkzeug_server.py

@@ -1,18 +1,19 @@
-from jsonrpcserver import method, Result, Ok, dispatch
+"""Werkzeug server"""
 from werkzeug.serving import run_simple
 from werkzeug.wrappers import Request, Response
+from jsonrpcserver import method, Result, Ok, dispatch
 
 
 @method
 def ping() -> Result:
+    """JSON-RPC method"""
     return Ok("pong")
 
 
 @Request.application
-def application(request):
-    return Response(
-        dispatch(request.get_data().decode()), 200, mimetype="application/json"
-    )
+def application(request: Request) -> Response:
+    """Handle Werkzeug request"""
+    return Response(dispatch(request.data.decode()), 200, mimetype="application/json")
 
 
 if __name__ == "__main__":

examples/zeromq_server.py

@@ -1,11 +1,13 @@
-from jsonrpcserver import dispatch, method, Ok, Result
+"""ZeroMQ server"""
 import zmq
+from jsonrpcserver import dispatch, method, Ok, Result
 
 socket = zmq.Context().socket(zmq.REP)
 
 
 @method
 def ping() -> Result:
+    """JSON-RPC method"""
     return Ok("pong")