From: Sarah Hoffmann Date: Mon, 5 Dec 2022 15:16:18 +0000 (+0100) Subject: fix liniting issues and add type annotations X-Git-Tag: v4.3.0~118^2~11 X-Git-Url: https://git.openstreetmap.org./nominatim.git/commitdiff_plain/d7bc846c3cd3e21cf28fed583676e400d3a9d7be fix liniting issues and add type annotations --- diff --git a/.mypy.ini b/.mypy.ini index ee7a9ad1..ef2057d4 100644 --- a/.mypy.ini +++ b/.mypy.ini @@ -12,3 +12,6 @@ ignore_missing_imports = True [mypy-dotenv.*] ignore_missing_imports = True + +[mypy-falcon.*] +ignore_missing_imports = True diff --git a/.pylintrc b/.pylintrc index e62371c6..881c1e76 100644 --- a/.pylintrc +++ b/.pylintrc @@ -1,6 +1,6 @@ [MASTER] -extension-pkg-whitelist=osmium +extension-pkg-whitelist=osmium,falcon ignored-modules=icu,datrie [MESSAGES CONTROL] diff --git a/nominatim/api.py b/nominatim/api.py index 60165d33..f5e942d1 100644 --- a/nominatim/api.py +++ b/nominatim/api.py @@ -7,15 +7,13 @@ """ Implementation of classes for API access via libraries. """ -from typing import Mapping, Optional, TypeVar, Callable, Any -import functools +from typing import Mapping, Optional import asyncio from pathlib import Path from sqlalchemy.engine.url import URL from sqlalchemy.ext.asyncio import create_async_engine -from nominatim.typing import StrPath from nominatim.config import Configuration from nominatim.apicmd.status import get_status, StatusResult @@ -56,4 +54,6 @@ class NominatimAPI: def status(self) -> StatusResult: + """ Return the status of the database. + """ return asyncio.get_event_loop().run_until_complete(self.async_api.status()) diff --git a/nominatim/cli.py b/nominatim/cli.py index 7143b7d6..e6214af8 100644 --- a/nominatim/cli.py +++ b/nominatim/cli.py @@ -9,6 +9,7 @@ Command-line interface to the Nominatim functions for import, update, database administration and querying. """ from typing import Optional, Any, List, Union +import importlib import logging import os import sys @@ -232,17 +233,17 @@ class AdminServe: port = 8088 if args.engine == 'sanic': - import nominatim.server.sanic.server + server_module = importlib.import_module('nominatim.server.sanic.server') - app = nominatim.server.sanic.server.get_application(args.project_dir) + app = server_module.get_application(args.project_dir) app.run(host=host, port=port, debug=True) else: - import uvicorn + import uvicorn # pylint: disable=import-outside-toplevel if args.engine == 'falcon': - import nominatim.server.falcon.server as server_module + server_module = importlib.import_module('nominatim.server.falcon.server') elif args.engine == 'starlette': - import nominatim.server.starlette.server as server_module + server_module = importlib.import_module('nominatim.server.starlette.server') app = server_module.get_application(args.project_dir) uvicorn.run(app, host=host, port=port) diff --git a/nominatim/server/falcon/server.py b/nominatim/server/falcon/server.py index a1ae9c6d..ccb0164c 100644 --- a/nominatim/server/falcon/server.py +++ b/nominatim/server/falcon/server.py @@ -7,8 +7,10 @@ """ Server implementation using the falcon webserver framework. """ +from typing import Type, Any from pathlib import Path +import falcon import falcon.asgi from nominatim.api import NominatimAPIAsync @@ -21,15 +23,22 @@ CONTENT_TYPE = { } class NominatimV1: + """ Implementation of V1 version of the Nominatim API. + """ - def __init__(self, project_dir: Path): + def __init__(self, project_dir: Path) -> None: self.api = NominatimAPIAsync(project_dir) self.formatters = {} for rtype in (StatusResult, ): self.formatters[rtype] = formatting.create(rtype) - def parse_format(self, req, rtype, default): + + def parse_format(self, req: falcon.asgi.Request, rtype: Type[Any], default: str) -> None: + """ Get and check the 'format' parameter and prepare the formatter. + `rtype` describes the expected return type and `default` the + format value to assume when no parameter is present. + """ req.context.format = req.get_param('format', default=default) req.context.formatter = self.formatters[rtype] @@ -39,12 +48,18 @@ class NominatimV1: ', '.join(req.context.formatter.list_formats())) - def format_response(self, req, resp, result): + def format_response(self, req: falcon.asgi.Request, resp: falcon.asgi.Response, + result: Any) -> None: + """ Render response into a string according to the formatter + set in `parse_format()`. + """ resp.text = req.context.formatter.format(result, req.context.format) resp.content_type = CONTENT_TYPE.get(req.context.format, falcon.MEDIA_JSON) - async def on_get_status(self, req, resp): + async def on_get_status(self, req: falcon.asgi.Request, resp: falcon.asgi.Response) -> None: + """ Implementation of status endpoint. + """ self.parse_format(req, StatusResult, 'text') result = await self.api.status() @@ -53,6 +68,8 @@ class NominatimV1: def get_application(project_dir: Path) -> falcon.asgi.App: + """ Create a Nominatim falcon ASGI application. + """ app = falcon.asgi.App() api = NominatimV1(project_dir) diff --git a/nominatim/server/sanic/server.py b/nominatim/server/sanic/server.py index 9c75327e..8329950d 100644 --- a/nominatim/server/sanic/server.py +++ b/nominatim/server/sanic/server.py @@ -7,6 +7,7 @@ """ Server implementation using the sanic webserver framework. """ +from typing import Any, Optional from pathlib import Path import sanic @@ -22,18 +23,30 @@ CONTENT_TYPE = { 'xml': 'text/xml; charset=utf-8' } -def usage_error(msg): +def usage_error(msg: str) -> sanic.HTTPResponse: + """ Format the response for an error with the query parameters. + """ return sanic.response.text(msg, status=400) -def api_response(request, result): +def api_response(request: sanic.Request, result: Any) -> sanic.HTTPResponse: + """ Render a response from the query results using the configured + formatter. + """ body = request.ctx.formatter.format(result, request.ctx.format) return sanic.response.text(body, - content_type=CONTENT_TYPE.get(request.ctx.format, 'application/json')) - - -@api.on_request -async def extract_format(request): + content_type=CONTENT_TYPE.get(request.ctx.format, + 'application/json')) + + +@api.on_request # type: ignore[misc] +async def extract_format(request: sanic.Request) -> Optional[sanic.HTTPResponse]: + """ Get and check the 'format' parameter and prepare the formatter. + `ctx.result_type` describes the expected return type and + `ctx.default_format` the format value to assume when no parameter + is present. + """ + assert request.route is not None request.ctx.formatter = request.app.ctx.formatters[request.route.ctx.result_type] request.ctx.format = request.args.get('format', request.route.ctx.default_format) @@ -41,13 +54,19 @@ async def extract_format(request): return usage_error("Parameter 'format' must be one of: " + ', '.join(request.ctx.formatter.list_formats())) + return None + @api.get('/status', ctx_result_type=StatusResult, ctx_default_format='text') -async def status(request): +async def status(request: sanic.Request) -> sanic.HTTPResponse: + """ Implementation of status endpoint. + """ return api_response(request,await request.app.ctx.api.status()) def get_application(project_dir: Path) -> sanic.Sanic: + """ Create a Nominatim sanic ASGI application. + """ app = sanic.Sanic("NominatimInstance") app.ctx.api = NominatimAPIAsync(project_dir) @@ -58,5 +77,3 @@ def get_application(project_dir: Path) -> sanic.Sanic: app.blueprint(api) return app - - diff --git a/nominatim/server/starlette/server.py b/nominatim/server/starlette/server.py index bfc552f2..38eac8dc 100644 --- a/nominatim/server/starlette/server.py +++ b/nominatim/server/starlette/server.py @@ -7,12 +7,14 @@ """ Server implementation using the starlette webserver framework. """ +from typing import Any, Type from pathlib import Path from starlette.applications import Starlette from starlette.routing import Route from starlette.exceptions import HTTPException from starlette.responses import Response +from starlette.requests import Request from nominatim.api import NominatimAPIAsync from nominatim.apicmd.status import StatusResult @@ -28,7 +30,11 @@ FORMATTERS = { } -def parse_format(request, rtype, default): +def parse_format(request: Request, rtype: Type[Any], default: str) -> None: + """ Get and check the 'format' parameter and prepare the formatter. + `rtype` describes the expected return type and `default` the + format value to assume when no parameter is present. + """ fmt = request.query_params.get('format', default=default) fmtter = FORMATTERS[rtype] @@ -40,13 +46,18 @@ def parse_format(request, rtype, default): request.state.formatter = fmtter -def format_response(request, result): +def format_response(request: Request, result: Any) -> Response: + """ Render response into a string according to the formatter + set in `parse_format()`. + """ fmt = request.state.format return Response(request.state.formatter.format(result, fmt), media_type=CONTENT_TYPE.get(fmt, 'application/json')) -async def on_status(request): +async def on_status(request: Request) -> Response: + """ Implementation of status endpoint. + """ parse_format(request, StatusResult, 'text') result = await request.app.state.API.status() return format_response(request, result) @@ -57,6 +68,8 @@ V1_ROUTES = [ ] def get_application(project_dir: Path) -> Starlette: + """ Create a Nominatim falcon ASGI application. + """ app = Starlette(debug=True, routes=V1_ROUTES) app.state.API = NominatimAPIAsync(project_dir)