event.collections.occurrences

Attributes

DateRange
MISSING

Classes

OccurenceSearchWidget	Base class for protocol classes.
_Sentinel	Create a collection of name/value pairs.
OccurrenceCollection	Manages a list of occurrences.
Tags	Custom class as 'tag' is a member of class Element and cannot be

Module Contents

class event.collections.occurrences.OccurenceSearchWidget

Bases: Protocol

Base class for protocol classes.

Protocol classes are defined as:

class Proto(Protocol):
    def meth(self) -> int:
        ...

Such classes are primarily used with static type checkers that recognize structural subtyping (static duck-typing).

For example:

class C:
    def meth(self) -> int:
        return 0

def func(x: Proto) -> int:
    return x.meth()

func(C())  # Passes static type check

See PEP 544 for details. Protocol classes decorated with @typing.runtime_checkable act as simple-minded runtime protocols that check only the presence of given attributes, ignoring their type signatures. Protocol classes can be generic, they are defined as:

class GenProto(Protocol[T]):
    def meth(self) -> T:
        ...

property name: str

property search_query: sqlalchemy.orm.Query[onegov.event.models.Occurrence]

adapt(query: sqlalchemy.orm.Query[onegov.event.models.Occurrence]) → sqlalchemy.orm.Query[onegov.event.models.Occurrence]

event.collections.occurrences.DateRange

class event.collections.occurrences._Sentinel(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

>>> Color.RED
<Color.RED: 1>

• value lookup:

>>> Color(1)
<Color.RED: 1>

• name lookup:

>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

MISSING

event.collections.occurrences.MISSING

class event.collections.occurrences.OccurrenceCollection(session: sqlalchemy.orm.Session, page: int = 0, range: DateRange | None = None, start: datetime.date | None = None, end: datetime.date | None = None, outdated: bool = False, tags: Sequence[str] | None = None, filter_keywords: Mapping[str, list[str] | str] | None = None, locations: Sequence[str] | None = None, only_public: bool = False, search_widget: OccurenceSearchWidget | None = None, event_filter_configuration: dict[str, Any] | None = None, event_filter_fields: Sequence[ParsedField] | None = None)

Bases: onegov.core.collection.Pagination[onegov.event.models.Occurrence]

Manages a list of occurrences.

Occurrences are read only (no add method here), they are generated automatically when adding a new event.

Occurrences can be filtered by relative date ranges (today, tomorrow, weekend, week, month, past) or by a given start date and/or end date. The range filter is dominant and overwrites the start and end dates if provided.

By default, only current occurrences are used.

Occurrences can be additionally filtered by tags and locations.

date_ranges: tuple[DateRange, Ellipsis] = ('today', 'tomorrow', 'weekend', 'week', 'month', 'past')

session

range

outdated

tags

filter_keywords

locations

only_public

search_widget

event_filter_configuration

event_filter_fields

__eq__(other: object) → bool

Returns True if the current and the other Pagination instance are equal. Used to find the current page in a list of pages.

subset() → Query[Occurrence]

Returns an SQLAlchemy query containing all records that should be considered for pagination.

property search: str | None

property search_query: Query[Occurrence] | None

property page_index: int

Returns the current page index (starting at 0).

page_by_index(index: int) → Self

Returns the page at the given index. A page here means an instance of the class inheriting from the Pagination base class.

range_to_dates(range: DateRange | None, start: datetime.date | None = None, end: datetime.date | None = None) → tuple[datetime.date | None, datetime.date | None]

Returns the start and end date for the given range relative to now. Defaults to the given start and end date.

Valid ranges are:

• today

• tomorrow

• weekend (next or current Friday to Sunday)

• week (current Monday to Sunday)

• month (current)

• past (events in the past)

for_keywords(singular: bool = False, **keywords: list[str]) → Self

for_toggled_keyword_value(keyword: str, value: str, singular: bool = False) → Self

for_filter(*, range: DateRange | None = None, start: date | None | MissingType = MISSING, end: date | None | MissingType = MISSING, outdated: bool | None = None, tags: Sequence[str] | None = None, tag: str | None = None, locations: Sequence[str] | None = None, location: str | None = None) → Self

Returns a new instance of the collection with the given filters and copies the current filters if not specified.

If a valid range is provided, start and end dates are ignored. If the range is invalid, it is ignored.

Adds or removes a single tag/location if given.

without_keywords_and_tags() → Self

property used_timezones: list[str]

Returns a list of all the timezones used by the occurrences.

property tag_counts: dict[str, int]

Returns a dict with all existing tags as keys and the number of existence as value.

set_event_filter_configuration(config: dict[str, Any] | None) → None

set_event_filter_fields(fields: Sequence[ParsedField] | None) → None

valid_keywords(parameters: Mapping[str, T]) → dict[str, T]

available_filters(sort_choices: bool = False, sortfunc: Callable[[str], SupportsRichComparison] | None = None) → Iterable[tuple[str, str, list[str]]]

Retrieve the filters with their choices. Return by default in the order of how they are defined in the config structure. To filter alphabetically, set sort_choices=True.

:return tuple containing tuples with keyword, label and list of values :rtype tuple(tuples(keyword, title, values as list)

property used_tags: set[str]

Returns a list of all the tags used by all future occurrences.

query() → Query[Occurrence]

Queries occurrences with the set parameters.

Finds occurrences which: * are between start and end date * have any of the tags * have any of the locations (exact word)

Start and end date are assumed to be dates only and therefore without a timezone - we search for the given date in the timezone of the occurrence.

In case of a search widget request the query will filter for events containing the text search term in e.g. title

by_name(name: str) → onegov.event.models.Occurrence | None

Returns an occurrence by its URL-friendly name.

The URL-friendly name is automatically constructed as follows:

unique name of the event-date of the occurrence

e.g.

squirrel-park-visit-6-2015-06-20

as_ical(request: onegov.core.request.CoreRequest) → bytes

Returns the the events of the given occurrences as iCalendar string.

as_xml(future_events_only: bool = True) → bytes

Returns all published occurrences as xml.

The xml format was Winterthur’s wish (no specs behind). Their mobile app will consume the events from.

Format:

<events>
    <event>
        <id></id>
        <title></title>
        <tags></tags>
            <tag></tag>
        <description></description>
        <start></start>
        <end></end>
        <location></location>
        <price></price>
        ..
    </event>
    <event>
        ..
    </event>
    ..
</events>

Parameters:

future_events_only – if set, only future events will be returned, all events otherwise

Return type:

str

Returns:

xml string

class event.collections.occurrences.Tags(tags: Sequence[str] = ())

Bases: lxml.etree.ElementBase

Custom class as ‘tag’ is a member of class Element and cannot be used as tag name.

tag = 'tags'