election_day.screen_widgets.election_compound
=============================================

.. py:module:: election_day.screen_widgets.election_compound


Attributes
----------

.. autoapisummary::

   election_day.screen_widgets.election_compound.ElectionCompoundWidget


Classes
-------

.. autoapisummary::

   election_day.screen_widgets.election_compound.ElectionCompoundSeatAllocationTableWidget
   election_day.screen_widgets.election_compound.ElectionCompoundCandidatesTableWidget
   election_day.screen_widgets.election_compound.ElectionCompoundListGroupsTableWidget
   election_day.screen_widgets.election_compound.ElectionCompoundPartyStrengthsTableWidget
   election_day.screen_widgets.election_compound.ElectionCompoundDistrictsTableWidget
   election_day.screen_widgets.election_compound.ElectionCompoundDistrictsMapWidget
   election_day.screen_widgets.election_compound.ElectionCompoundSuperregionsTableWidget
   election_day.screen_widgets.election_compound.ElectionCompoundSuperregionsMapWidget
   election_day.screen_widgets.election_compound.ElectionCompoundListGroupsChartWidget
   election_day.screen_widgets.election_compound.ElectionCompoundSeatAllocationChartWidget
   election_day.screen_widgets.election_compound.ElectionCompoundPartyStrengthsChartWidget


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

.. py:data:: ElectionCompoundWidget

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

   Bases: :py:obj:`ElectionCompoundWidget`


   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-compound-seat-allocation-table'



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

      .. raw:: html

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

      .. code-block:: python

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

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-compound-seat-allocation-table class=""/>'



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


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

   Bases: :py:obj:`ElectionCompoundWidget`


   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-compound-candidates-table'



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

      .. raw:: html

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

      .. code-block:: python

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

      .. raw:: html

         </details>




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



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


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

   Bases: :py:obj:`ElectionCompoundWidget`


   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-compound-list-groups-table'



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

      .. raw:: html

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

      .. code-block:: python

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

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-compound-list-groups-table class="" />'



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


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

   Bases: :py:obj:`ElectionCompoundWidget`


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



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-compound-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-compound-party-strengths-table year="" class=""/>'



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


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

   Bases: :py:obj:`ElectionCompoundWidget`


   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-compound-districts-table'



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

      .. raw:: html

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

      .. code-block:: python

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

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-compound-districts-table class=""/>'



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


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

   Bases: :py:obj:`ElectionCompoundWidget`


   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-compound-districts-map'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-compound-districts-map">
                     <div class="{@class}">
                         <tal:block
                             metal:use-macro="layout.macros['election-compound-districts-map']"
                             />
                     </div>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-compound-districts-map class=""/>'



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


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

   Bases: :py:obj:`ElectionCompoundWidget`


   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-compound-superregions-table'



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

      .. raw:: html

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

      .. code-block:: python

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

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-compound-superregions-table class=""/>'



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


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

   Bases: :py:obj:`ElectionCompoundWidget`


   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-compound-superregions-map'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-compound-superregions-map">
                     <div class="{@class}">
                         <tal:block
                             metal:use-macro="layout.macros['election-compound-superregions-map']"
                             />
                     </div>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-compound-superregions-map class=""/>'



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


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

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


   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-compound-list-groups-chart'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-compound-list-groups-chart">
                     <div class="{@class}">
                         <tal:block
                             metal:use-macro="layout.macros['list-groups-chart']"
                             />
                     </div>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-compound-list-groups-chart class=""/>'



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

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


   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-compound-seat-allocation-chart'



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-compound-seat-allocation-chart">
                     <div class="{@class}">
                         <tal:block
                             metal:use-macro="layout.macros['seat-allocation-chart']"
                             />
                     </div>
                 </xsl:template>
             """

      .. raw:: html

         </details>




   .. py:attribute:: usage
      :value: '<election-compound-seat-allocation-chart class=""/>'



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

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


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



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

      .. raw:: html

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

      .. code-block:: python

         """
                 <xsl:template match="election-compound-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-compound-party-strengths-chart horizontal="false" class=""/>'