X-Git-Url: https://git.openstreetmap.org./nominatim.git/blobdiff_plain/5226cd2a0bc2baa06d32752f29d4e1f3c632dd13..6e81596609518d9202a00bd457af0a75648d30d9:/nominatim/api/core.py?ds=sidebyside diff --git a/nominatim/api/core.py b/nominatim/api/core.py index ae5bb5d8..29325b08 100644 --- a/nominatim/api/core.py +++ b/nominatim/api/core.py @@ -7,7 +7,7 @@ """ Implementation of classes for API access via libraries. """ -from typing import Mapping, Optional, Any, AsyncIterator +from typing import Mapping, Optional, Any, AsyncIterator, Dict, Sequence import asyncio import contextlib from pathlib import Path @@ -18,8 +18,13 @@ import asyncpg from nominatim.db.sqlalchemy_schema import SearchTables from nominatim.config import Configuration -from nominatim.api.status import get_status, StatusResult from nominatim.api.connection import SearchConnection +from nominatim.api.status import get_status, StatusResult +from nominatim.api.lookup import get_detailed_place, get_simple_place +from nominatim.api.reverse import ReverseGeocoder +from nominatim.api.types import PlaceRef, LookupDetails, AnyPoint, DataLayer +from nominatim.api.results import DetailedResult, ReverseResult, SearchResults + class NominatimAPIAsync: """ API loader asynchornous version. @@ -32,6 +37,7 @@ class NominatimAPIAsync: self._engine_lock = asyncio.Lock() self._engine: Optional[sa_asyncio.AsyncEngine] = None self._tables: Optional[SearchTables] = None + self._property_cache: Dict[str, Any] = {'DB:server_version': 0} async def setup_database(self) -> None: @@ -47,13 +53,16 @@ class NominatimAPIAsync: dsn = self.config.get_database_params() + query = {k: v for k, v in dsn.items() + if k not in ('user', 'password', 'dbname', 'host', 'port')} + query['prepared_statement_cache_size'] = '0' + dburl = sa.engine.URL.create( 'postgresql+asyncpg', database=dsn.get('dbname'), username=dsn.get('user'), password=dsn.get('password'), host=dsn.get('host'), port=int(dsn['port']) if 'port' in dsn else None, - query={k: v for k, v in dsn.items() - if k not in ('user', 'password', 'dbname', 'host', 'port')}) + query=query) engine = sa_asyncio.create_async_engine( dburl, future=True, connect_args={'server_settings': { @@ -64,18 +73,20 @@ class NominatimAPIAsync: try: async with engine.begin() as conn: result = await conn.scalar(sa.text('SHOW server_version_num')) - self.server_version = int(result) + server_version = int(result) except asyncpg.PostgresError: - self.server_version = 0 + server_version = 0 - if self.server_version >= 110000: - @sa.event.listens_for(engine.sync_engine, "connect") # type: ignore[misc] + if server_version >= 110000: + @sa.event.listens_for(engine.sync_engine, "connect") def _on_connect(dbapi_con: Any, _: Any) -> None: cursor = dbapi_con.cursor() cursor.execute("SET jit_above_cost TO '-1'") # Make sure that all connections get the new settings await self.close() + self._property_cache['DB:server_version'] = server_version + self._tables = SearchTables(sa.MetaData(), engine.name) # pylint: disable=no-member self._engine = engine @@ -104,7 +115,7 @@ class NominatimAPIAsync: assert self._tables is not None async with self._engine.begin() as conn: - yield SearchConnection(conn, self._tables) + yield SearchConnection(conn, self._tables, self._property_cache) async def status(self) -> StatusResult: @@ -119,6 +130,53 @@ class NominatimAPIAsync: return status + async def details(self, place: PlaceRef, + details: Optional[LookupDetails] = None) -> Optional[DetailedResult]: + """ Get detailed information about a place in the database. + + Returns None if there is no entry under the given ID. + """ + async with self.begin() as conn: + return await get_detailed_place(conn, place, details or LookupDetails()) + + + async def lookup(self, places: Sequence[PlaceRef], + details: Optional[LookupDetails] = None) -> SearchResults: + """ Get simple information about a list of places. + + Returns a list of place information for all IDs that were found. + """ + if details is None: + details = LookupDetails() + async with self.begin() as conn: + return SearchResults(filter(None, + [await get_simple_place(conn, p, details) for p in places])) + + + async def reverse(self, coord: AnyPoint, max_rank: Optional[int] = None, + layer: Optional[DataLayer] = None, + details: Optional[LookupDetails] = None) -> Optional[ReverseResult]: + """ Find a place by its coordinates. Also known as reverse geocoding. + + Returns the closest result that can be found or None if + no place matches the given criteria. + """ + # The following negation handles NaN correctly. Don't change. + if not abs(coord[0]) <= 180 or not abs(coord[1]) <= 90: + # There are no results to be expected outside valid coordinates. + return None + + if layer is None: + layer = DataLayer.ADDRESS | DataLayer.POI + + max_rank = max(0, min(max_rank or 30, 30)) + + async with self.begin() as conn: + geocoder = ReverseGeocoder(conn, max_rank, layer, + details or LookupDetails()) + return await geocoder.lookup(coord) + + class NominatimAPI: """ API loader, synchronous version. """ @@ -138,7 +196,41 @@ class NominatimAPI: self._loop.close() + @property + def config(self) -> Configuration: + """ Return the configuration used by the API. + """ + return self._async_api.config + def status(self) -> StatusResult: """ Return the status of the database. """ return self._loop.run_until_complete(self._async_api.status()) + + + def details(self, place: PlaceRef, + details: Optional[LookupDetails] = None) -> Optional[DetailedResult]: + """ Get detailed information about a place in the database. + """ + return self._loop.run_until_complete(self._async_api.details(place, details)) + + + def lookup(self, places: Sequence[PlaceRef], + details: Optional[LookupDetails] = None) -> SearchResults: + """ Get simple information about a list of places. + + Returns a list of place information for all IDs that were found. + """ + return self._loop.run_until_complete(self._async_api.lookup(places, details)) + + + def reverse(self, coord: AnyPoint, max_rank: Optional[int] = None, + layer: Optional[DataLayer] = None, + details: Optional[LookupDetails] = None) -> Optional[ReverseResult]: + """ Find a place by its coordinates. Also known as reverse geocoding. + + Returns the closest result that can be found or None if + no place matches the given criteria. + """ + return self._loop.run_until_complete( + self._async_api.reverse(coord, max_rank, layer, details))