core.layout
===========

.. py:module:: core.layout


Attributes
----------

.. autoapisummary::

   core.layout._T


Classes
-------

.. autoapisummary::

   core.layout.Layout
   core.layout.ChameleonLayout


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

.. py:data:: _T

.. py:class:: Layout(model: Any, request: core.request.CoreRequest)

   Contains useful methods related to rendering pages in html. Think of it
   as an API that you can rely on in your templates.

   The idea is to provide basic layout functions here, if they are usful for
   any kind of html application. You should then extend the core layout
   classes with your own.



   .. py:attribute:: timezone


   .. py:attribute:: time_format
      :value: 'HH:mm'



   .. py:attribute:: date_format
      :value: 'dd.MM.yyyy'



   .. py:attribute:: datetime_format
      :value: 'dd.MM.yyyy HH:mm'



   .. py:attribute:: date_long_format
      :value: 'dd. MMMM yyyy'



   .. py:attribute:: datetime_long_format
      :value: 'd. MMMM yyyy HH:mm'



   .. py:attribute:: weekday_long_format
      :value: 'EEEE'



   .. py:attribute:: weekday_short_format
      :value: 'E'



   .. py:attribute:: month_long_format
      :value: 'MMMM'



   .. py:attribute:: custom_body_attributes
      :type:  dict[str, Any]


   .. py:attribute:: custom_html_attributes
      :type:  dict[str, Any]


   .. py:attribute:: model


   .. py:attribute:: request


   .. py:property:: app
      :type: core.framework.Framework


      Returns the application behind the request. 



   .. py:method:: batched(iterable: collections.abc.Iterable[_T], batch_size: int, container_factory: type[tuple] = ...) -> collections.abc.Iterator[tuple[_T, Ellipsis]]
                  batched(iterable: collections.abc.Iterable[_T], batch_size: int, container_factory: type[list]) -> collections.abc.Iterator[list[_T]]
                  batched(iterable: collections.abc.Iterable[_T], batch_size: int, container_factory: collections.abc.Callable[[collections.abc.Iterator[_T]], collections.abc.Collection[_T]]) -> collections.abc.Iterator[collections.abc.Collection[_T]]

      See :func:`onegov.core.utils.batched`. 



   .. py:property:: csrf_token
      :type: str


      Returns a csrf token for use with DELETE links (forms do their
      own thing automatically).




   .. py:method:: csrf_protected_url(url: str) -> str

      Adds a csrf token to the given url. 



   .. py:method:: format_date(dt: datetime.datetime | datetime.date | None, format: str) -> str

      Takes a datetime and formats it according to local timezone and
      the given format.




   .. py:method:: isodate(date: datetime.datetime) -> str

      Returns the given date in the ISO 8601 format. 



   .. py:method:: parse_isodate(string: str) -> datetime.datetime

      Returns the given ISO 8601 string as datetime. 



   .. py:method:: number_symbols(locale: str) -> tuple[str, str]
      :staticmethod:


      Returns the locale specific number symbols. 



   .. py:method:: format_number(number: numbers.Number | decimal.Decimal | float | str | None, decimal_places: int | None = None, padding: str = '') -> str

      Takes the given numer and formats it according to locale.

      If the number is an integer, the default decimal places are 0,
      otherwise 2.




   .. py:property:: view_name
      :type: str | None


      Returns the view name of the current view, or None if it is the
      default view.

      Note: This relies on morepath internals and is experimental in nature!




   .. py:method:: today() -> datetime.date


   .. py:method:: now() -> datetime.datetime


.. py:class:: ChameleonLayout(model: Any, request: core.request.CoreRequest)

   Bases: :py:obj:`Layout`


   Extends the base layout class with methods related to chameleon
   template rendering.

   This class assumes the existance of two templates:

   - layout.pt -> Contains the page skeleton with headers, body and so on.
   - macros.pt -> Contains chameleon macros.



   .. py:property:: template_loader
      :type: core.templates.TemplateLoader


      Returns the chameleon template loader. 



   .. py:property:: base
      :type: chameleon.PageTemplateFile


      Returns the layout, which defines the base layout of all pages.

      See ``templates/layout.pt``.




   .. py:property:: macros
      :type: core.templates.MacrosLookup


      Returns the macros, which offer often used html constructs.
      See ``templates/macros.pt``.




   .. py:property:: elements
      :type: onegov.core.templates.PageTemplate | chameleon.PageTemplateFile


      The templates used by the elements. Overwrite this with your
      own ``templates/elements.pt`` if neccessary.