core.i18n.translation_string
============================

.. py:module:: core.i18n.translation_string


Classes
-------

.. autoapisummary::

   core.i18n.translation_string.HasHTML
   core.i18n.translation_string.TranslationMarkup
   core.i18n.translation_string.TranslationStringSerializer


Functions
---------

.. autoapisummary::

   core.i18n.translation_string.TranslationStringFactory


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

.. py:class:: HasHTML

   Bases: :py:obj:`Protocol`


   Base class for protocol classes.

   Protocol classes are defined as::

       class Proto(Protocol):
           def meth(self) -> int:
               ...

   Such classes are primarily used with static type checkers that recognize
   structural subtyping (static duck-typing).

   For example::

       class C:
           def meth(self) -> int:
               return 0

       def func(x: Proto) -> int:
           return x.meth()

       func(C())  # Passes static type check

   See PEP 544 for details. Protocol classes decorated with
   @typing.runtime_checkable act as simple-minded runtime protocols that check
   only the presence of given attributes, ignoring their type signatures.
   Protocol classes can be generic, they are defined as::

       class GenProto(Protocol[T]):
           def meth(self) -> T:
               ...


   .. py:method:: __html__(/) -> str


.. py:class:: TranslationMarkup

   Bases: :py:obj:`translationstring.TranslationString`


   Markup aware version of TranslationString


   .. py:attribute:: __slots__
      :value: ('domain', 'context', 'default', 'mapping')



   .. py:attribute:: domain
      :type:  str | None


   .. py:attribute:: context
      :type:  str | None


   .. py:attribute:: default
      :type:  markupsafe.Markup


   .. py:attribute:: mapping
      :type:  dict[str, markupsafe.Markup] | None


   .. py:method:: __mod__(options: Any) -> Self

      Create a new TranslationString instance with an updated mapping.
      This makes it possible to use the standard python %-style string
      formatting with translatable strings. Only dictionary
      arguments are supported.



   .. py:method:: interpolate(translated: str | None = None) -> markupsafe.Markup

      Interpolate the value ``translated`` which is assumed to
      be a Unicode object containing zero or more *replacement
      markers* (``$foo`` or ``${bar}``) using the ``mapping``
      dictionary attached to this instance.  If the ``mapping``
      dictionary is empty or ``None``, no interpolation is
      performed.

      If ``translated`` is ``None``, interpolation will be performed
      against the ``default`` value.



   .. py:method:: escape(s: object) -> Self
      :classmethod:



   .. py:method:: __html__() -> markupsafe.Markup


.. py:function:: TranslationStringFactory(factory_domain: str) -> TStrCallable

   Creates a TranslationMarkup for Markup and a TranslationString
   otherwise.


.. py:class:: TranslationStringSerializer(tag: int, target: type[_T])

   Bases: :py:obj:`onegov.core.custom.msgpack.Serializer`\ [\ :py:obj:`translationstring.TranslationString`\ ]


   Provides a way to encode all objects of a given class or its
   subclasses to and from MessagePack using extension types.



   .. py:method:: encode(obj: translationstring.TranslationString) -> bytes


   .. py:method:: decode(value: bytes) -> translationstring.TranslationString