"""
from pathlib import Path
-PHPLIB_DIR = None
SQLLIB_DIR = (Path('@NOMINATIM_LIBDIR@') / 'lib-sql').resolve()
DATA_DIR = Path('@NOMINATIM_DATADIR@').resolve()
CONFIG_DIR = Path('@NOMINATIM_CONFIGDIR@').resolve()
"""
from pathlib import Path
-PHPLIB_DIR = None
DATA_DIR = None
SQLLIB_DIR = None
CONFIG_DIR = (Path(__file__) / '..' / 'resources' / 'settings').resolve()
"""
from pathlib import Path
-PHPLIB_DIR = None
DATA_DIR = (Path(__file__) / '..' / 'resources').resolve()
SQLLIB_DIR = (DATA_DIR / 'lib-sql')
CONFIG_DIR = (DATA_DIR / 'settings')
from .config import Configuration
from .errors import UsageError
-from .tools.exec_utils import run_php_server
from . import clicmd
from . import version
from .clicmd.args import NominatimArgs, Subcommand
from the current project directory. This webserver is only suitable
for testing and development. Do not use it in production setups!
- There are different webservers available. The default 'php' engine
- runs the classic PHP frontend. The other engines are Python servers
- which run the new Python frontend code. This is highly experimental
- at the moment and may not include the full API.
+ There are two different webserver implementations for Python available:
+ falcon (the default) and starlette. You need to make sure the
+ appropriate Python packages as well as the uvicorn package are
+ installed to use this function.
By the default, the webserver can be accessed at: http://127.0.0.1:8088
"""
group.add_argument('--server', default='127.0.0.1:8088',
help='The address the server will listen to.')
group.add_argument('--engine', default='falcon',
- choices=('php', 'falcon', 'starlette'),
+ choices=('falcon', 'starlette'),
help='Webserver framework to run. (default: falcon)')
def run(self, args: NominatimArgs) -> int:
- if args.engine == 'php':
- if args.config.lib_dir.php is None:
- raise UsageError("PHP frontend not configured.")
- LOG.warning('\n\nWARNING: the PHP frontend is deprecated '
- 'and will be removed in Nominatim 5.0.\n\n')
- run_php_server(args.server, args.project_dir / 'website')
- else:
- asyncio.run(self.run_uvicorn(args))
+ asyncio.run(self.run_uvicorn(args))
return 0
class _LibDirs:
module: Path
osm2pgsql: Path
- php = paths.PHPLIB_DIR
sql = paths.SQLLIB_DIR
data = paths.DATA_DIR
This module provides the functions to create and configure a new tokenizer
as well as instantiating the appropriate tokenizer for updating an existing
database.
-
-A tokenizer usually also includes PHP code for querying. The appropriate PHP
-normalizer module is installed, when the tokenizer is created.
"""
from typing import Optional
import logging
import itertools
import logging
from pathlib import Path
-from textwrap import dedent
from psycopg.types.json import Jsonb
from psycopg import sql as pysql
"""
self.loader = ICURuleLoader(config)
- self._install_php(config.lib_dir.php, overwrite=True)
self._save_config()
if init_db:
with connect(self.dsn) as conn:
self.loader.load_config_from_db(conn)
- self._install_php(config.lib_dir.php, overwrite=False)
-
def finalize_import(self, config: Configuration) -> None:
""" Do any required postprocessing to make the tokenizer data ready
return list(s[0].split('@')[0] for s in cur)
- def _install_php(self, phpdir: Optional[Path], overwrite: bool = True) -> None:
- """ Install the php script for the tokenizer.
- """
- if phpdir is not None:
- assert self.loader is not None
- php_file = self.data_dir / "tokenizer.php"
-
- if not php_file.exists() or overwrite:
- php_file.write_text(dedent(f"""\
- <?php
- @define('CONST_Max_Word_Frequency', 10000000);
- @define('CONST_Term_Normalization_Rules', "{self.loader.normalization_rules}");
- @define('CONST_Transliteration', "{self.loader.get_search_rules()}");
- require_once('{phpdir}/tokenizer/icu_tokenizer.php');"""), encoding='utf-8')
-
-
def _save_config(self) -> None:
""" Save the configuration that needs to remain stable for the given
database as database properties.
from pathlib import Path
import re
import shutil
-from textwrap import dedent
from icu import Transliterator
import psycopg
self.normalization = config.TERM_NORMALIZATION
- self._install_php(config, overwrite=True)
-
with connect(self.dsn) as conn:
_check_module(module_dir, conn)
self._save_config(conn, config)
config.lib_dir.module,
config.project_dir / 'module')
- self._install_php(config, overwrite=False)
-
def finalize_import(self, config: Configuration) -> None:
""" Do any required postprocessing to make the tokenizer data ready
for use.
return list(s[0] for s in cur)
- def _install_php(self, config: Configuration, overwrite: bool = True) -> None:
- """ Install the php script for the tokenizer.
- """
- if config.lib_dir.php is not None:
- php_file = self.data_dir / "tokenizer.php"
-
- if not php_file.exists() or overwrite:
- php_file.write_text(dedent(f"""\
- <?php
- @define('CONST_Max_Word_Frequency', {config.MAX_WORD_FREQUENCY});
- @define('CONST_Term_Normalization_Rules', "{config.TERM_NORMALIZATION}");
- require_once('{config.lib_dir.php}/tokenizer/legacy_tokenizer.php');
- """), encoding='utf-8')
-
-
def _init_db_tables(self, config: Configuration) -> None:
""" Set up the word table and fill it with pre-computed word
frequencies.
import subprocess
import shutil
-from ..typing import StrPath
from ..db.connection import get_pg_env
from ..errors import UsageError
from ..version import OSM2PGSQL_REQUIRED_VERSION
LOG = logging.getLogger()
-def run_php_server(server_address: str, base_dir: StrPath) -> None:
- """ Run the built-in server from the given directory.
- """
- subprocess.run(['/usr/bin/env', 'php', '-S', server_address],
- cwd=str(base_dir), check=True)
-
def run_osm2pgsql(options: Mapping[str, Any]) -> None:
""" Run osm2pgsql with the given options.
assert captured.out.startswith('Nominatim version')
-def test_cli_serve_php(cli_call, mock_func_factory):
- func = mock_func_factory(nominatim_db.cli, 'run_php_server')
-
- cli_call('serve', '--engine', 'php') == 0
-
- assert func.called == 1
-
-
-
class TestCliWithDb:
@pytest.fixture(autouse=True)
projects / nominatim.git / commitdiff