election_day.screen_widgets.election
====================================

.. py:module:: election_day.screen_widgets.election


Classes
-------

.. autoapisummary::

   election_day.screen_widgets.election.ElectionCandidatesTableWidget
   election_day.screen_widgets.election.ElectionCandidatesByEntityTableWidget
   election_day.screen_widgets.election.ElectionListsTableWidget
   election_day.screen_widgets.election.ElectionPartyStrengthsTableWidget
   election_day.screen_widgets.election.ElectionCandidatesChartWidget
   election_day.screen_widgets.election.ElectionListsChartWidget
   election_day.screen_widgets.election.ElectionPartyStrengthsChartWidget
   election_day.screen_widgets.election.AllocatedMandatesWidget
   election_day.screen_widgets.election.NumberOfMandatesWidget
   election_day.screen_widgets.election.MandatesWidget
   election_day.screen_widgets.election.ElectionTurnoutWidget
   election_day.screen_widgets.election.AbsoluteMajorityWidget
   election_day.screen_widgets.election.IfAbsoluteMajorityWidget
   election_day.screen_widgets.election.IfRelateMajorityWidget


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

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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ModelBoundWidget`\ [\ :py:obj:`onegov.election_day.models.Election`\ ]


   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: 'election-candidates-table'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-candidates-table">
                     <div class="{@class}" tal:define="lists '{@lists}'">
                         <tal:block
                             metal:use-macro="layout.macros['election-candidates-table']"
                             tal:define="show_percentage (election.type != 'proporz')"
                             />
                     </div>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-candidates-table class="" lists=","/>'



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


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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ModelBoundWidget`\ [\ :py:obj:`onegov.election_day.models.Election`\ ]


   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: 'election-candidates-by-entity-table'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-candidates-by-entity-table">
                     <div class="{@class}">
                         <tal:block
                             metal:use-macro="layout.macros['election-candidates-by-entity-table']"
                             />
                     </div>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-candidates-by-entity-table class=""/>'



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


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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ModelBoundWidget`\ [\ :py:obj:`onegov.election_day.models.ProporzElection`\ ]


   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: 'election-lists-table'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-lists-table">
                     <div class="{@class}" tal:define="names '{@names}'">
                         <tal:block
                             metal:use-macro="layout.macros['election-lists-table']"
                             />
                     </div>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-lists-table class="" names=","/>'



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


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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ModelBoundWidget`\ [\ :py:obj:`onegov.election_day.models.ProporzElection`\ ]


   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: 'election-party-strengths-table'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-party-strengths-table">
                     <div class="{@class}" tal:define="year '{@year}'">
                         <tal:block
                             metal:use-macro="layout.macros['party-strengths-table']"
                             />
                     </div>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-party-strengths-table year="" class=""/>'



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


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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ChartWidget`\ [\ :py:obj:`onegov.election_day.models.Election`\ ]


   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: 'election-candidates-chart'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-candidates-chart">
                     <div class="{@class}"
                          tal:define="limit '0{@limit}';
                                      lists '{@lists}';
                                      elected '{@elected}';
                                      sort_by_lists '{@sort-by-lists}';
                                      ">
                         <tal:block
                             metal:use-macro="layout.macros['candidates-chart']"
                             />
                     </div>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-candidates-chart limit="" lists="," sort-by-lists="" elected="" class=""/>'



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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ChartWidget`\ [\ :py:obj:`onegov.election_day.models.ProporzElection`\ ]


   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: 'election-lists-chart'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-lists-chart">
                     <div class="{@class}"
                          tal:define="limit '0{@limit}';
                                      names '{@names}';
                                      sort_by_names '{@sort-by-names}'
                                      ">
                         <tal:block
                             metal:use-macro="layout.macros['lists-chart']"
                             />
                     </div>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-lists-chart limit="" names="," sort-by-names="" class=""/>'



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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ChartWidget`\ [\ :py:obj:`onegov.election_day.models.ProporzElection`\ ]


   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: 'election-party-strengths-chart'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-party-strengths-chart">
                     <div class="{@class}"
                          tal:define="horizontal '{@horizontal}'=='true'">
                         <tal:block
                             metal:use-macro="layout.macros['party-strengths-chart']"
                             />
                     </div>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-party-strengths-chart horizontal="false" class=""/>'



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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ModelBoundWidget`\ [\ :py:obj:`onegov.election_day.models.Election`\ ]


   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: 'allocated-mandates'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="allocated-mandates">
                     <span class="{@class}">
                         ${layout.format_number(model.allocated_mandates)}
                     </span>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<allocated-mandates class=""/>'



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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ModelBoundWidget`\ [\ :py:obj:`onegov.election_day.models.Election`\ ]


   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-mandates'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="number-of-mandates">
                     <span class="{@class}">
                         ${layout.format_number(model.number_of_mandates)}
                     </span>
                 </xsl:template>
             """

      .. raw:: html

         </details>




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



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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ModelBoundWidget`\ [\ :py:obj:`onegov.election_day.models.Election`\ ]


   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: 'mandates'



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

      .. raw:: html

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

      .. code-block:: python

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

      .. raw:: html

         </details>




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



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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ModelBoundWidget`\ [\ :py:obj:`onegov.election_day.models.Election`\ ]


   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: 'election-turnout'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-turnout">
                     <span class="{@class}">
                         ${'{0:.2f}'.format(model.turnout)} %
                     </span>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-turnout class=""/>'



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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ModelBoundWidget`\ [\ :py:obj:`onegov.election_day.models.Election`\ ]


   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: 'absolute-majority'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="absolute-majority">
                     <span class="{@class}">
                         ${layout.format_number(model.absolute_majority or 0)}
                     </span>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<absolute-majority class=""/>'



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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ModelBoundWidget`\ [\ :py:obj:`onegov.election_day.models.Election`\ ]


   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-absolute-majority'



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

      .. raw:: html

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

      .. code-block:: python

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

      .. raw:: html

         </details>




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



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

   Bases: :py:obj:`onegov.election_day.screen_widgets.generic.ModelBoundWidget`\ [\ :py:obj:`onegov.election_day.models.Election`\ ]


   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-relative-majority'



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

      .. raw:: html

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

      .. code-block:: python

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

      .. raw:: html

         </details>




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