search.utils
============

.. py:module:: search.utils


Attributes
----------

.. autoapisummary::

   search.utils.T
   search.utils.T_co
   search.utils.HASHTAG
   search.utils._invalid_index_characters


Classes
-------

.. autoapisummary::

   search.utils.classproperty
   search.utils.LanguageDetector


Functions
---------

.. autoapisummary::

   search.utils.searchable_sqlalchemy_models
   search.utils.is_valid_index_name
   search.utils.is_valid_type_name
   search.utils.normalize_index_segment
   search.utils.extract_hashtags
   search.utils.iter_subclasses
   search.utils.related_types


Module Contents
---------------

.. py:data:: T

.. py:data:: T_co

.. py:data:: HASHTAG

.. py:function:: searchable_sqlalchemy_models(base: type[T]) -> collections.abc.Iterator[type[onegov.search.Searchable]]

   Searches through the given SQLAlchemy base and returns the classes
   of all SQLAlchemy models found which inherit from the
   :class:`onegov.search.mixins.Searchable` interface.



.. py:data:: _invalid_index_characters

.. py:function:: is_valid_index_name(name: str) -> bool

   Checks if the given name is a valid elasticsearch index name.
   Elasticsearch does it's own checks, but we can do it earlier and we are
   a bit stricter.



.. py:function:: is_valid_type_name(name: str) -> bool

.. py:function:: normalize_index_segment(segment: str, allow_wildcards: bool) -> str

.. py:function:: extract_hashtags(text: str) -> list[str]

.. py:class:: classproperty(f: collections.abc.Callable[[type[Any]], T_co])

   Bases: :py:obj:`Generic`\ [\ :py:obj:`T_co`\ ]


   Abstract base class for generic types.

   A generic type is typically declared by inheriting from
   this class parameterized with one or more type variables.
   For example, a generic mapping type might be defined as::

     class Mapping(Generic[KT, VT]):
         def __getitem__(self, key: KT) -> VT:
             ...
         # Etc.

   This class can then be used as follows::

     def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
         try:
             return mapping[key]
         except KeyError:
             return default


   .. py:attribute:: f


   .. py:method:: __get__(obj: object | None, owner: type[object]) -> T_co


.. py:function:: iter_subclasses(baseclass: type[T]) -> collections.abc.Iterator[type[T]]

.. py:function:: related_types(model: type[object]) -> set[str]

   Gathers all related es type names from the given model. A type is
   counted as related a model is part of a polymorphic setup.

   If no polymorphic identity is found, the result is simply a set with the
   model's type itself.



.. py:class:: LanguageDetector(supported_languages: collections.abc.Sequence[str])

   Detects languages with the help of langdetect.

   Unlike langdetect this detector may be limited to a subset of all
   supported languages, which may improve accuracy if the subset is known and
   saves some memory.



   .. py:attribute:: supported_languages


   .. py:attribute:: factory


   .. py:method:: spawn_detector(text: str) -> langdetect.detector.Detector


   .. py:method:: detect(text: str) -> str


   .. py:method:: probabilities(text: str) -> list[langdetect.language.Language]