nominatim/result_formatter/base.py

   1 # SPDX-License-Identifier: GPL-2.0-only
   2 #
   3 # This file is part of Nominatim. (https://nominatim.org)
   4 #
   5 # Copyright (C) 2022 by the Nominatim developer community.
   6 # For a full list of authors see the git log.
   7 """
   8 Helper classes and function for writing result formatting modules.
   9 """
  10 from typing import Type, TypeVar, Dict, Mapping, List, Callable, Generic, Any
  11 from collections import defaultdict
  12
  13 T = TypeVar('T') # pylint: disable=invalid-name
  14 FormatFunc = Callable[[T], str]
  15
  16 class ResultFormatter(Generic[T]):
  17     """ This class dispatches format calls to the appropriate formatting
  18         function previously defined with the `format_func` decorator.
  19     """
  20
  21     def __init__(self, funcs: Mapping[str, FormatFunc[T]]) -> None:
  22         self.functions = funcs
  23
  24
  25     def list_formats(self) -> List[str]:
  26         """ Return a list of formats supported by this formatter.
  27         """
  28         return list(self.functions.keys())
  29
  30
  31     def supports_format(self, fmt: str) -> bool:
  32         """ Check if the given format is supported by this formatter.
  33         """
  34         return fmt in self.functions
  35
  36
  37     def format(self, result: T, fmt: str) -> str:
  38         """ Convert the given result into a string using the given format.
  39
  40             The format is expected to be in the list returned by
  41             `list_formats()`.
  42         """
  43         return self.functions[fmt](result)
  44
  45
  46 class FormatDispatcher:
  47     """ A factory class for result formatters.
  48     """
  49
  50     def __init__(self) -> None:
  51         self.format_functions: Dict[Type[Any], Dict[str, FormatFunc[Any]]] = defaultdict(dict)
  52
  53
  54     def format_func(self, result_class: Type[T],
  55                     fmt: str) -> Callable[[FormatFunc[T]], FormatFunc[T]]:
  56         """ Decorator for a function that formats a given type of result into the
  57             selected format.
  58         """
  59         def decorator(func: FormatFunc[T]) -> FormatFunc[T]:
  60             self.format_functions[result_class][fmt] = func
  61             return func
  62
  63         return decorator
  64
  65
  66     def __call__(self, result_class: Type[T]) -> ResultFormatter[T]:
  67         """ Create an instance of a format class for the given result type.
  68         """
  69         return ResultFormatter(self.format_functions[result_class])