election_day.screen_widgets.election_compound

Module Contents

Classes

ElectionCompoundSeatAllocationTableWidget	Abstract base class for generic types.
ElectionCompoundCandidatesTableWidget	Abstract base class for generic types.
ElectionCompoundListGroupsTableWidget	Abstract base class for generic types.
ElectionCompoundPartyStrengthsTableWidget	Abstract base class for generic types.
ElectionCompoundDistrictsTableWidget	Abstract base class for generic types.
ElectionCompoundDistrictsMapWidget	Abstract base class for generic types.
ElectionCompoundSuperregionsTableWidget	Abstract base class for generic types.
ElectionCompoundSuperregionsMapWidget	Abstract base class for generic types.
ElectionCompoundListGroupsChartWidget	Abstract base class for generic types.
ElectionCompoundSeatAllocationChartWidget	Abstract base class for generic types.
ElectionCompoundPartyStrengthsChartWidget	Abstract base class for generic types.

Attributes

ElectionCompoundWidget

election_day.screen_widgets.election_compound.ElectionCompoundWidget

class election_day.screen_widgets.election_compound.ElectionCompoundSeatAllocationTableWidget(model: _E | None = None)

Bases: 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

tag = 'election-compound-seat-allocation-table'

template = Multiline-String

Show Value

"""
        <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>
    """

usage = '<election-compound-seat-allocation-table class=""/>'

get_variables(layout: onegov.election_day.layouts.DefaultLayout) → dict[str, Any]

class election_day.screen_widgets.election_compound.ElectionCompoundCandidatesTableWidget(model: _E | None = None)

Bases: 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

tag = 'election-compound-candidates-table'

template = Multiline-String

Show Value

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

usage = '<election-compound-candidates-table class=""/>'

get_variables(layout: onegov.election_day.layouts.DefaultLayout) → dict[str, Any]

class election_day.screen_widgets.election_compound.ElectionCompoundListGroupsTableWidget(model: _E | None = None)

Bases: 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

tag = 'election-compound-list-groups-table'

template = Multiline-String

Show Value

"""
        <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>
    """

usage = '<election-compound-list-groups-table class="" />'

get_variables(layout: onegov.election_day.layouts.DefaultLayout) → dict[str, Any]

class election_day.screen_widgets.election_compound.ElectionCompoundPartyStrengthsTableWidget(model: _E | None = None)

Bases: 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

tag = 'election-compound-party-strengths-table'

template = Multiline-String

Show Value

"""
        <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>
    """

usage = '<election-compound-party-strengths-table year="" class=""/>'

get_variables(layout: onegov.election_day.layouts.DefaultLayout) → dict[str, Any]

class election_day.screen_widgets.election_compound.ElectionCompoundDistrictsTableWidget(model: _E | None = None)

Bases: 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

tag = 'election-compound-districts-table'

template = Multiline-String

Show Value

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

usage = '<election-compound-districts-table class=""/>'

get_variables(layout: onegov.election_day.layouts.DefaultLayout) → dict[str, Any]

class election_day.screen_widgets.election_compound.ElectionCompoundDistrictsMapWidget(model: _E | None = None)

Bases: 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

tag = 'election-compound-districts-map'

template = Multiline-String

Show Value

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

usage = '<election-compound-districts-map class=""/>'

get_variables(layout: onegov.election_day.layouts.DefaultLayout) → dict[str, Any]

class election_day.screen_widgets.election_compound.ElectionCompoundSuperregionsTableWidget(model: _E | None = None)

Bases: 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

tag = 'election-compound-superregions-table'

template = Multiline-String

Show Value

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

usage = '<election-compound-superregions-table class=""/>'

get_variables(layout: onegov.election_day.layouts.DefaultLayout) → dict[str, Any]

class election_day.screen_widgets.election_compound.ElectionCompoundSuperregionsMapWidget(model: _E | None = None)

Bases: 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

tag = 'election-compound-superregions-map'

template = Multiline-String

Show Value

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

usage = '<election-compound-superregions-map class=""/>'

get_variables(layout: onegov.election_day.layouts.DefaultLayout) → dict[str, Any]

class election_day.screen_widgets.election_compound.ElectionCompoundListGroupsChartWidget(model: _E | None = None)

Bases: onegov.election_day.screen_widgets.generic.ChartWidget[onegov.ballot.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

tag = 'election-compound-list-groups-chart'

template = Multiline-String

Show Value

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

usage = '<election-compound-list-groups-chart class=""/>'

class election_day.screen_widgets.election_compound.ElectionCompoundSeatAllocationChartWidget(model: _E | None = None)

Bases: onegov.election_day.screen_widgets.generic.ChartWidget[onegov.ballot.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

tag = 'election-compound-seat-allocation-chart'

template = Multiline-String

Show Value

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

usage = '<election-compound-seat-allocation-chart class=""/>'

class election_day.screen_widgets.election_compound.ElectionCompoundPartyStrengthsChartWidget(model: _E | None = None)

Bases: onegov.election_day.screen_widgets.generic.ChartWidget[onegov.ballot.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

tag = 'election-compound-party-strengths-chart'

template = Multiline-String

Show Value

"""
        <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>
    """

usage = '<election-compound-party-strengths-chart horizontal="false" class=""/>'