election_day.screen_widgets.generic
===================================

.. py:module:: election_day.screen_widgets.generic


Attributes
----------

.. autoapisummary::

   election_day.screen_widgets.generic.Entity
   election_day.screen_widgets.generic._E


Classes
-------

.. autoapisummary::

   election_day.screen_widgets.generic.H1Widget
   election_day.screen_widgets.generic.H2Widget
   election_day.screen_widgets.generic.H3Widget
   election_day.screen_widgets.generic.PWidget
   election_day.screen_widgets.generic.HRWidget
   election_day.screen_widgets.generic.GridRowWidget
   election_day.screen_widgets.generic.GridColumnWidget
   election_day.screen_widgets.generic.PrincipalLogoWidget
   election_day.screen_widgets.generic.QrCodeWidget
   election_day.screen_widgets.generic.ModelBoundWidget
   election_day.screen_widgets.generic.ModelTitleWidget
   election_day.screen_widgets.generic.IfCompletedWidget
   election_day.screen_widgets.generic.IfNotCompletedWidget
   election_day.screen_widgets.generic.ModelProgressWidget
   election_day.screen_widgets.generic.CountedEntitiesWidget
   election_day.screen_widgets.generic.ChartWidget
   election_day.screen_widgets.generic.LastResultChangeWidget
   election_day.screen_widgets.generic.NumberOfCountedEntitiesWidget
   election_day.screen_widgets.generic.TotalEntitiesWidget


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

.. py:type:: Entity
   :canonical: Election | ElectionCompound | Vote


.. py:data:: _E

.. py:class:: H1Widget

   .. py:attribute:: tag
      :value: 'h1'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="h1">
                     <h1 class="{@class}">
                         <xsl:apply-templates select="node()"/>
                     </h1>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<h1 class=""></h1>'



.. py:class:: H2Widget

   .. py:attribute:: tag
      :value: 'h2'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="h2">
                     <h2 class="{@class}">
                         <xsl:apply-templates select="node()"/>
                     </h2>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<h2 class=""></h2>'



.. py:class:: H3Widget

   .. py:attribute:: tag
      :value: 'h3'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="h3">
                     <h3 class="{@class}">
                         <xsl:apply-templates select="node()"/>
                     </h3>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<h3 class=""></h3>'



.. py:class:: PWidget

   .. py:attribute:: tag
      :value: 'p'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="p">
                     <p class="{@class}">
                         <xsl:apply-templates select="node()"/>
                     </p>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<p class=""></p>'



.. py:class:: HRWidget

   .. py:attribute:: tag
      :value: 'hr'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="hr">
                     <hr class="{@class}" />
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<hr class=""/>'



.. py:class:: GridRowWidget

   .. py:attribute:: tag
      :value: 'grid-row'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="grid-row">
                     <div class="row {@class}" style="max-width: none">
                         <xsl:apply-templates select="node()"/>
                     </div>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<grid-row class=""></grid-row>'



.. py:class:: GridColumnWidget

   .. py:attribute:: tag
      :value: 'grid-column'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="grid-column">
                     <div class="small-12 medium-{@span} columns {@class}">
                         <xsl:apply-templates select="node()"/>
                         &#160;
                     </div>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<grid-column span="" class=""></grid-column>'



.. py:class:: PrincipalLogoWidget

   .. py:attribute:: tag
      :value: 'principal-logo'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="principal-logo">
                     <img
                         tal:attributes="src logo"
                         tal:condition="logo"
                         class="{@class}"
                         />
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<principal-logo class=""/>'



   .. py:method:: get_variables(layout: onegov.election_day.layouts.DefaultLayout) -> dict[str, Any]


.. py:class:: QrCodeWidget

   .. py:attribute:: tag
      :value: 'qr-code'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="qr-code">
                     <tal:block tal:define="url '{@url}'; src qr_code(url)">
                         <img tal:attributes="src src"
                              class="{@class}"
                              />
                     </tal:block>
         
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<qr-code class="" url="https://"/>'



   .. py:method:: qr_code(url: str) -> str
      :staticmethod:



   .. py:method:: get_variables(layout: onegov.election_day.layouts.DefaultLayout) -> dict[str, Any]


.. py:class:: ModelBoundWidget(model: _E | None = None)

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


   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:: model
      :value: None



   .. py:method:: get_variables(layout: onegov.election_day.layouts.DefaultLayout) -> dict[str, Any]


.. py:class:: ModelTitleWidget(model: _E | None = None)

   Bases: :py:obj:`ModelBoundWidget`\ [\ :py:obj:`Entity`\ ]


   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:: tag
      :value: 'model-title'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="model-title">
                     <span tal:content="model.title" class="{@class}" />
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<model-title class=""/>'



.. py:class:: IfCompletedWidget(model: _E | None = None)

   Bases: :py:obj:`ModelBoundWidget`\ [\ :py:obj:`Entity`\ ]


   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:: tag
      :value: 'if-completed'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="if-completed">
                     <tal:block tal:condition="model.completed">
                         <xsl:apply-templates select="node()"/>
                     </tal:block>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<if-completed></if-completed>'



.. py:class:: IfNotCompletedWidget(model: _E | None = None)

   Bases: :py:obj:`ModelBoundWidget`\ [\ :py:obj:`Entity`\ ]


   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:: tag
      :value: 'if-not-completed'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="if-not-completed">
                     <tal:block tal:condition="not model.completed">
                         <xsl:apply-templates select="node()"/>
                     </tal:block>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<if-not-completed></if-not-completed>'



.. py:class:: ModelProgressWidget(model: _E | None = None)

   Bases: :py:obj:`ModelBoundWidget`\ [\ :py:obj:`Entity`\ ]


   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:: tag
      :value: 'model-progress'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="model-progress">
                     <span class="{@class}">
                         <tal:block
                             metal:use-macro="layout.macros['progress']"
                             tal:define="progress model.progress"
                             />
                     </span>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<model-progress class=""/>'



.. py:class:: CountedEntitiesWidget(model: _E | None = None)

   Bases: :py:obj:`ModelBoundWidget`\ [\ :py:obj:`Entity`\ ]


   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:: tag
      :value: 'counted-entities'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="counted-entities">
                     <span class="{@class}">${entities}</span>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<counted-entities class=""/>'



   .. py:method:: get_variables(layout: onegov.election_day.layouts.DefaultLayout) -> dict[str, Any]


.. py:class:: ChartWidget(model: _E | None = None)

   Bases: :py:obj:`ModelBoundWidget`\ [\ :py:obj:`_E`\ ]


   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:method:: get_variables(layout: onegov.election_day.layouts.DefaultLayout) -> dict[str, Any]


.. py:class:: LastResultChangeWidget(model: _E | None = None)

   Bases: :py:obj:`ModelBoundWidget`\ [\ :py:obj:`Entity`\ ]


   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:: tag
      :value: 'last-result-change'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="last-result-change">
                     <span class="{@class}">
                     ${layout.format_date(layout.last_result_change, 'datetime_long')}
                     </span>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<last-result-change class=""/>'



.. py:class:: NumberOfCountedEntitiesWidget(model: _E | None = None)

   Bases: :py:obj:`ModelBoundWidget`\ [\ :py:obj:`Entity`\ ]


   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:: tag
      :value: 'number-of-counted-entities'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="number-of-counted-entities">
                     <span class="{@class}">
                         ${layout.format_number(model.progress[0])}
                     </span>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<number-of-counted-entities class=""/>'



.. py:class:: TotalEntitiesWidget(model: _E | None = None)

   Bases: :py:obj:`ModelBoundWidget`\ [\ :py:obj:`Entity`\ ]


   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:: tag
      :value: 'total-entities'



   .. py:attribute:: template
      :value: Multiline-String

      .. raw:: html

         <details><summary>Show Value</summary>

      .. code-block:: python

         """
                 <xsl:template match="total-entities">
                     <span class="{@class}">
                         ${layout.format_number(model.progress[1])}
                     </span>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<total-entities class=""/>'