event-reduce 7.4.2__py3-none-any.whl

event_reduce/__init__.py

@@ -0,0 +1,89 @@
+"""
+EventReduce: update live query results from change events without re-running the query.
+
+Only the BDD that the JavaScript implementation generated is used, it is not created or optimized here.
+"""
+
+from __future__ import annotations
+
+from typing import Any, TypeVar
+
+from .actions import ACTION_FUNCTION_LIST, ORDERED_ACTION_LIST, ActionFunction
+from .bdd import resolve_input
+from .bdd_generated import PACKED_BDD
+from .result_window_buffer import (
+    ResultWindowBuffer,
+    ResultWindowBufferChangeResult,
+    ResultWindowBufferQuery,
+    ResultWindowBufferResult,
+    get_recommended_result_window_buffer_size,
+)
+from .states import ORDERED_STATE_LIST, get_state_set, resolve_state
+from .types import (
+    ActionName,
+    ChangeEvent,
+    EventReduceError,
+    QueryParams,
+    ResultKeyDocumentMap,
+    StateName,
+    StateResolveFunctionInput,
+    WriteOperation,
+)
+from .util import dict_query_params, get_property
+
+D = TypeVar("D")
+
+
+def calculate_action_name(input: StateResolveFunctionInput[Any]) -> ActionName:
+    """
+    Returns the action that transforms the previous results into the new results.
+    If it is RUN_FULL_QUERY_AGAIN, the query must be run over the database again.
+    """
+    return ORDERED_ACTION_LIST[resolve_input(input)]
+
+
+def run_action(
+    action: ActionName,
+    query_params: QueryParams[D],
+    change_event: ChangeEvent[D],
+    previous_results: list[D],
+    key_document_map: dict[str, D] | None = None,
+) -> list[D]:
+    """
+    Applies the action to the results.
+    For performance reasons, it mutates previous_results and the key_document_map
+    and returns the mutated results.
+    Raises an EventReduceError for RUN_FULL_QUERY_AGAIN and UNKNOWN_ACTION.
+    """
+    ACTION_FUNCTION_LIST[ORDERED_ACTION_LIST.index(action)](
+        StateResolveFunctionInput(query_params, change_event, previous_results, key_document_map)
+    )
+    return previous_results
+
+
+__all__ = [
+    "ORDERED_ACTION_LIST",
+    "ORDERED_STATE_LIST",
+    "PACKED_BDD",
+    "ActionFunction",
+    "ActionName",
+    "ChangeEvent",
+    "EventReduceError",
+    "QueryParams",
+    "ResultKeyDocumentMap",
+    "ResultWindowBuffer",
+    "ResultWindowBufferChangeResult",
+    "ResultWindowBufferQuery",
+    "ResultWindowBufferResult",
+    "StateName",
+    "StateResolveFunctionInput",
+    "WriteOperation",
+    "calculate_action_name",
+    "dict_query_params",
+    "get_property",
+    "get_recommended_result_window_buffer_size",
+    "get_state_set",
+    "resolve_input",
+    "resolve_state",
+    "run_action",
+]

event_reduce/actions.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from .types import ActionName, EventReduceError, StateResolveFunctionInput
+from .util import index_of_document_id, push_at_sort_position
+
+ActionFunction = Callable[[StateResolveFunctionInput[Any]], None]
+"""For performance reasons, action functions mutate the results and the key document map of the input."""
+
+ORDERED_ACTION_LIST: list[ActionName] = list(ActionName)
+"""All actions, in the same order as the JavaScript implementation. The BDD references the actions by their index."""
+
+
+def _find_index_of_changed_doc(input: StateResolveFunctionInput[Any]) -> int:
+    """Returns the index of the changed document inside of the previous results or -1."""
+    id = input.change_event.id
+    if input.key_document_map is not None and id not in input.key_document_map:
+        return -1
+    return index_of_document_id(input.query_params, input.previous_results, id)
+
+
+def _changed_doc(input: StateResolveFunctionInput[Any]) -> Any:
+    """The new document of the change event. Only the BDD knows that it exists for the given action."""
+    doc = input.change_event.doc
+    if doc is None:
+        raise EventReduceError("UNK_ACT")
+    return doc
+
+
+def _add_to_map(input: StateResolveFunctionInput[Any], doc: Any) -> None:
+    if input.key_document_map is not None:
+        input.key_document_map[input.change_event.id] = doc
+
+
+def _remove_from_map(input: StateResolveFunctionInput[Any], id: str) -> None:
+    if input.key_document_map is not None:
+        input.key_document_map.pop(id, None)
+
+
+def do_nothing(input: StateResolveFunctionInput[Any]) -> None:
+    pass
+
+
+def insert_first(input: StateResolveFunctionInput[Any]) -> None:
+    doc = _changed_doc(input)
+    input.previous_results.insert(0, doc)
+    _add_to_map(input, doc)
+
+
+def insert_last(input: StateResolveFunctionInput[Any]) -> None:
+    doc = _changed_doc(input)
+    input.previous_results.append(doc)
+    _add_to_map(input, doc)
+
+
+def remove_first_item(input: StateResolveFunctionInput[Any]) -> None:
+    if not input.previous_results:
+        return
+    first = input.previous_results.pop(0)
+    _remove_from_map(input, input.query_params.get_document_id(first))
+
+
+def remove_last_item(input: StateResolveFunctionInput[Any]) -> None:
+    if not input.previous_results:
+        return
+    last = input.previous_results.pop()
+    _remove_from_map(input, input.query_params.get_document_id(last))
+
+
+def remove_first_insert_last(input: StateResolveFunctionInput[Any]) -> None:
+    remove_first_item(input)
+    insert_last(input)
+
+
+def remove_last_insert_first(input: StateResolveFunctionInput[Any]) -> None:
+    remove_last_item(input)
+    insert_first(input)
+
+
+def remove_first_insert_first(input: StateResolveFunctionInput[Any]) -> None:
+    remove_first_item(input)
+    insert_first(input)
+
+
+def remove_last_insert_last(input: StateResolveFunctionInput[Any]) -> None:
+    remove_last_item(input)
+    insert_last(input)
+
+
+def remove_existing(input: StateResolveFunctionInput[Any]) -> None:
+    index = _find_index_of_changed_doc(input)
+    _remove_from_map(input, input.change_event.id)
+    if index >= 0:
+        del input.previous_results[index]
+
+
+def replace_existing(input: StateResolveFunctionInput[Any]) -> None:
+    index = _find_index_of_changed_doc(input)
+    if index >= 0:
+        doc = _changed_doc(input)
+        input.previous_results[index] = doc
+        _add_to_map(input, doc)
+
+
+def insert_at_sort_position(input: StateResolveFunctionInput[Any]) -> None:
+    doc = _changed_doc(input)
+    id = input.change_event.id
+    key_document_map = input.key_document_map
+    # If document is already in results,
+    # we cannot add it again because it would throw on non-deterministic ordering.
+    if key_document_map is not None:
+        if id in key_document_map:
+            return
+        key_document_map[id] = doc
+    elif index_of_document_id(input.query_params, input.previous_results, id) >= 0:
+        return
+    push_at_sort_position(input.previous_results, doc, input.query_params.sort_comparator)
+
+
+def remove_existing_and_insert_at_sort_position(input: StateResolveFunctionInput[Any]) -> None:
+    remove_existing(input)
+    insert_at_sort_position(input)
+
+
+def _insert_at_sort_position_and_remove(input: StateResolveFunctionInput[Any], remove: ActionFunction) -> None:
+    length_before = len(input.previous_results)
+    insert_at_sort_position(input)
+    # insert_at_sort_position() does nothing if the document is already in the results
+    if len(input.previous_results) > length_before:
+        remove(input)
+
+
+def insert_at_sort_position_remove_last(input: StateResolveFunctionInput[Any]) -> None:
+    """
+    Inserts the document at its sort position and then removes the last document.
+    Used when the limit was reached and the new document
+    sorts in between the first and the last document,
+    so the previous last document is pushed out of the results.
+    """
+    _insert_at_sort_position_and_remove(input, remove_last_item)
+
+
+def insert_at_sort_position_remove_first(input: StateResolveFunctionInput[Any]) -> None:
+    """
+    Inserts the document at its sort position and then removes the first document.
+    Used when a document moves out of the skipped documents into the results,
+    so the previous first document is pushed into the skipped documents.
+    """
+    _insert_at_sort_position_and_remove(input, remove_first_item)
+
+
+def run_full_query_again(input: StateResolveFunctionInput[Any]) -> None:
+    raise EventReduceError("RUN_FULL")
+
+
+def unknown_action(input: StateResolveFunctionInput[Any]) -> None:
+    raise EventReduceError("UNK_ACT")
+
+
+ACTION_FUNCTION_LIST: list[ActionFunction] = [
+    do_nothing,
+    insert_first,
+    insert_last,
+    remove_first_item,
+    remove_last_item,
+    remove_first_insert_last,
+    remove_last_insert_first,
+    remove_first_insert_first,
+    remove_last_insert_last,
+    remove_existing,
+    replace_existing,
+    # alwaysWrong is only used by the truth-table generator and never returned by the BDD
+    unknown_action,
+    insert_at_sort_position,
+    remove_existing_and_insert_at_sort_position,
+    insert_at_sort_position_remove_last,
+    insert_at_sort_position_remove_first,
+    run_full_query_again,
+    unknown_action,
+]
+"""The action functions in the same order as ORDERED_ACTION_LIST."""

event_reduce/bdd.py

@@ -0,0 +1,38 @@
+"""
+Resolves the action with the BDD of the JavaScript implementation.
+Only the already generated BDD is used, it is not created or optimized here.
+
+The BDD is a PackedBdd of the binary-decision-diagram npm package,
+bdd_generated.PACKED_BDD holds its decoded entries.
+
+Layout of the entries:
+- Every non-leaf node takes three consecutive entries: [level, ref0, ref1]
+  - level is the index of the state function in ORDERED_STATE_LIST
+  - ref0 is followed when the state is false, ref1 when it is true
+- The node with the id x starts at index 3 * x, the root node has the id 0.
+- With n = len(entries) / 3, a reference r < n points to the node with the id r,
+  r >= n is a leaf with the action index r - n in ORDERED_ACTION_LIST.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .bdd_generated import PACKED_BDD
+from .states import STATE_RESOLVE_FUNCTION_BY_INDEX
+from .types import StateResolveFunctionInput
+
+_NODE_COUNT = len(PACKED_BDD) // 3
+
+
+def resolve_input(input: StateResolveFunctionInput[Any]) -> int:
+    """Walks the BDD and returns the index of the action in ORDERED_ACTION_LIST."""
+    bdd = PACKED_BDD
+    fns = STATE_RESOLVE_FUNCTION_BY_INDEX
+    n = _NODE_COUNT
+    i = 0
+    while True:
+        ref = bdd[i + 2] if fns[bdd[i]](input) else bdd[i + 1]
+        if ref >= n:
+            return ref - n
+        i = ref * 3

event_reduce/bdd_generated.py

@@ -0,0 +1,4 @@
+# Code generated by the truth-table-generator of the JavaScript implementation. DO NOT EDIT.
+# Run `npm run optimize-bdd` in ./javascript instead.
+
+PACKED_BDD: tuple[int, ...] = (1, 1, 2, 0, 3, 4, 17, 5, 6, 6, 7, 92, 17, 92, 8, 6, 9, 92, 6, 10, 11, 11, 12, 13, 6, 14, 15, 11, 16, 13, 11, 17, 18, 5, 93, 19, 5, 92, 20, 7, 21, 108, 5, 22, 23, 5, 93, 108, 5, 92, 24, 5, 22, 25, 5, 26, 27, 16, 108, 92, 12, 92, 28, 8, 29, 95, 7, 30, 31, 7, 32, 33, 10, 34, 20, 10, 35, 36, 10, 37, 38, 10, 37, 39, 7, 40, 41, 9, 101, 96, 15, 42, 94, 15, 43, 92, 15, 44, 94, 15, 45, 92, 7, 46, 47, 7, 48, 49, 12, 23, 50, 8, 51, 52, 7, 53, 54, 7, 55, 56, 16, 92, 95, 16, 92, 108, 14, 104, 93, 4, 57, 97, 14, 104, 108, 4, 58, 108, 15, 59, 92, 15, 60, 92, 15, 61, 94, 15, 62, 92, 7, 63, 64, 9, 102, 100, 9, 99, 97, 8, 65, 66, 8, 67, 68, 8, 69, 70, 8, 71, 72, 14, 106, 98, 14, 106, 108, 14, 92, 40, 4, 73, 41, 14, 104, 19, 4, 74, 19, 15, 75, 76, 15, 77, 41, 9, 105, 78, 9, 79, 97, 9, 80, 81, 9, 82, 108, 9, 83, 84, 9, 85, 108, 15, 86, 108, 9, 71, 108, 14, 92, 41, 14, 106, 19, 14, 87, 19, 16, 94, 97, 4, 88, 19, 15, 89, 100, 15, 90, 97, 15, 105, 108, 15, 89, 108, 15, 90, 108, 15, 86, 105, 15, 86, 100, 15, 86, 97, 14, 105, 108, 16, 104, 107, 14, 91, 19, 14, 105, 98, 14, 105, 99, 16, 106, 107)  # fmt: skip

event_reduce/result_window_buffer.py

@@ -0,0 +1,356 @@
+"""
+Result window buffer
+------------
+For a query with a limit or a skip, EventReduce returns runFullQueryAgain
+when a row has to move into the result window that is not in the previous results:
+the row after the last row (a row left a full window) or the last skipped row
+(a row was added in front of the window).
+The result window buffer keeps rows on both sides of the window in memory,
+so these rows can be taken from memory instead.
+See docs/result-window-buffer.md for the explanation and measurements.
+
+Invariant: `buffer` is always an exact, contiguous slice of the full sorted result
+(without skip and limit): exactly `offset` matching rows sort before its first row,
+and it never contains a wrong row or misses a row in between.
+If `complete` is true, there are no rows after its last row.
+Only if the buffer is empty, `offset` can be larger than the real number of rows.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Generic, NamedTuple, TypeVar
+
+from . import actions
+from .actions import ACTION_FUNCTION_LIST, ActionFunction
+from .bdd import resolve_input
+from .types import ChangeEvent, EventReduceError, QueryParams, StateResolveFunctionInput
+from .util import index_of_document_id, push_at_sort_position
+
+D = TypeVar("D")
+
+BufferSize = int | float
+"""A whole number of rows, or math.inf to keep all rows on that side."""
+
+
+class ResultWindowBufferResult(str, Enum):
+    """What apply_change_event() did."""
+
+    EVENT_REDUCE = "eventReduce"
+    """An EventReduce action calculated the new buffer."""
+    BUFFER = "buffer"
+    """EventReduce could not do it (or would have dropped a row), the slice rule did it."""
+    RUN_FULL_QUERY_AGAIN = "runFullQueryAgain"
+    """The caller must run the query with the skip and limit of query() and pass the rows to reset()."""
+
+
+class ResultWindowBufferQuery(NamedTuple):
+    """The skip and limit to run the query of the buffer with, limit is None if all rows after the skip are needed."""
+
+    skip: int
+    limit: int | None
+
+
+@dataclass(frozen=True)
+class ResultWindowBufferChangeResult(Generic[D]):
+    """
+    What apply_change_events() returns.
+    results are the rows of the original skip and limit,
+    changed is true if they are not the same rows as before the change events.
+    """
+
+    run_full_query_again: bool
+    changed: bool = False
+    results: list[D] = field(default_factory=list)
+
+
+ACTIONS_THAT_DROP_A_ROW: frozenset[ActionFunction] = frozenset(
+    {
+        actions.remove_first_item,
+        actions.remove_last_item,
+        actions.remove_first_insert_last,
+        actions.remove_last_insert_first,
+        actions.remove_first_insert_first,
+        actions.remove_last_insert_last,
+        actions.insert_at_sort_position_remove_last,
+        actions.insert_at_sort_position_remove_first,
+    }
+)
+"""Actions that keep the length of the result by dropping its first or last row. The slice rule can keep that row."""
+
+
+def get_recommended_result_window_buffer_size(limit: int | None = None) -> int:
+    """
+    The recommended buffer size for each side of the result window.
+    About log2(limit) for small limits, grows faster around limit 400 and is at most 30.
+    Returns 0 for a limit of 1 (like a find-one query) and for queries without a limit.
+    """
+    if not limit:
+        return 0
+    return min(30, math.floor(math.log2(limit) + 19 / (1 + (400 / limit) ** 2)))
+
+
+def _to_buffer_size(size: BufferSize | None) -> BufferSize:
+    """
+    Buffer sizes are whole numbers, rounded down. Not set means 0,
+    math.inf keeps all rows on that side.
+    Raises on negative sizes and on values that are not numbers, like NaN.
+    """
+    if size is None:
+        return 0
+    if isinstance(size, bool) or not isinstance(size, (int, float)) or math.isnan(size) or size < 0:
+        raise EventReduceError("RWB_SIZE")
+    return size if math.isinf(size) else math.floor(size)
+
+
+class ResultWindowBuffer(Generic[D]):
+    """
+    Keeps rows on both sides of the result window of a query with a skip or limit in memory.
+    Create it, run the query with the skip and limit of query()
+    and pass the rows to reset() before using it.
+    """
+
+    def __init__(
+        self,
+        query_params: QueryParams[D],
+        limit_buffer_size: BufferSize | None = None,
+        skip_buffer_size: BufferSize | None = None,
+    ) -> None:
+        self.query_params = query_params
+        """QueryParams of the original query, with the skip and limit that are shown to the user."""
+        limit_size = _to_buffer_size(limit_buffer_size)
+        skip_size = _to_buffer_size(skip_buffer_size)
+        # with limit 0 the result is always empty, so no rows are kept
+        is_empty_query = query_params.limit == 0
+        self.limit_buffer_size: BufferSize = 0 if is_empty_query else limit_size
+        """Amount of rows to keep after the last row of the result window."""
+        self.skip_buffer_size: BufferSize = 0 if is_empty_query else skip_size
+        """Amount of rows to keep before the first row of the result window, out of the skipped rows."""
+        self.buffer: list[D] = []
+        self.key_document_map: dict[str, D] = {}
+        self.offset = 0
+        """Number of matching rows that sort before the first row of the buffer."""
+        self.complete = False
+        """True if there are no rows after the last row of the buffer."""
+
+    def _skip(self) -> int:
+        return self.query_params.skip or 0
+
+    def query(self) -> ResultWindowBufferQuery:
+        """The skip and limit to run the query of the buffer with."""
+        skip = self._skip()
+        buffer_skip = max(0, skip - self.skip_buffer_size)
+        limit = self.query_params.limit
+        buffer_limit = None
+        if limit is not None and not math.isinf(self.limit_buffer_size):
+            buffer_limit = int((skip - buffer_skip) + limit + self.limit_buffer_size)
+        return ResultWindowBufferQuery(int(buffer_skip), buffer_limit)
+
+    def reset(self, rows: Iterable[D]) -> None:
+        """Set the buffer to the rows of a fresh query that ran with the skip and limit of query()."""
+        query = self.query()
+        get_id = self.query_params.get_document_id
+        self.buffer = list(rows)
+        self.key_document_map = {get_id(doc): doc for doc in self.buffer}
+        self.offset = query.skip
+        # fewer rows than requested means there are no more rows
+        self.complete = query.limit is None or len(self.buffer) < query.limit
+
+    def results(self) -> list[D]:
+        """
+        The result that is shown to the user.
+        Raises if the result window is not in the buffer, which happens
+        before reset() was called or when apply_change_event() returned RUN_FULL_QUERY_AGAIN
+        and the query did not run again.
+        """
+        if not self._is_result_window_in_buffer():
+            raise EventReduceError("RWB_OUTDATED")
+        start = self._skip() - self.offset
+        limit = self.query_params.limit
+        return self.buffer[start : None if limit is None else start + limit]
+
+    def apply_change_event(self, change_event: ChangeEvent[D]) -> ResultWindowBufferResult:
+        """Updates the buffer with the change event."""
+        buffer = self.buffer
+        if self.query_params.limit == 0:
+            # the result of a query with limit 0 is always empty, nothing can change it
+            return ResultWindowBufferResult.EVENT_REDUCE
+        if not self.complete and not buffer:
+            return ResultWindowBufferResult.RUN_FULL_QUERY_AGAIN
+
+        # 1. Let EventReduce handle the buffer as if it was the result of a query
+        # with skip = offset and limit = len(buffer). This is exactly true,
+        # because the buffer is an exact slice of the full result.
+        # If the buffer is complete, we use len(buffer) + 1, so EventReduce
+        # knows that the limit is not reached and there are no more rows.
+        query_params = self.query_params
+        input = StateResolveFunctionInput(
+            QueryParams(
+                query_params.get_document_id,
+                query_params.query_matcher,
+                query_params.sort_comparator,
+                query_params.sort_fields_changed,
+                self.offset if self.offset > 0 else None,
+                len(buffer) + 1 if self.complete else len(buffer),
+            ),
+            change_event,
+            buffer,
+            self.key_document_map,
+        )
+        action = ACTION_FUNCTION_LIST[resolve_input(input)]
+        if action is actions.run_full_query_again or action in ACTIONS_THAT_DROP_A_ROW:
+            # 2. EventReduce needs a row before or after the buffer, which it does not know,
+            # or it would drop a row to keep the length of the result.
+            # But the buffer does not have to keep its length, only to stay an exact slice,
+            # so the slice rule lets it shrink or grow instead.
+            self._apply_slice_rule(change_event)
+            result = ResultWindowBufferResult.BUFFER
+        else:
+            action(input)
+            result = ResultWindowBufferResult.EVENT_REDUCE
+
+        # 3. Do not let the buffer grow without bounds on either side.
+        self._trim()
+
+        # 4. Run the query again if the result window does not fit into the buffer anymore.
+        if not self._is_result_window_in_buffer():
+            return ResultWindowBufferResult.RUN_FULL_QUERY_AGAIN
+        return result
+
+    def apply_change_events(self, change_events: Iterable[ChangeEvent[D]]) -> ResultWindowBufferChangeResult[D]:
+        """
+        Updates the buffer with all change events.
+        Returns the new results, and if they changed,
+        or run_full_query_again if the result window does not fit into the buffer anymore.
+        Then run the query of query() and pass the rows to reset().
+        """
+        if not self._is_result_window_in_buffer():
+            return ResultWindowBufferChangeResult(run_full_query_again=True)
+        previous_results = self.results()
+        for change_event in change_events:
+            if self.apply_change_event(change_event) == ResultWindowBufferResult.RUN_FULL_QUERY_AGAIN:
+                return ResultWindowBufferChangeResult(run_full_query_again=True)
+        results = self.results()
+        # Changed rows are always new objects from the change events,
+        # so comparing the rows by reference finds every change.
+        changed = len(results) != len(previous_results) or any(
+            row is not previous for row, previous in zip(results, previous_results, strict=False)
+        )
+        return ResultWindowBufferChangeResult(run_full_query_again=False, changed=changed, results=results)
+
+    def _is_result_window_in_buffer(self) -> bool:
+        """True if all rows of the result window are in the buffer."""
+        start = self._skip() - self.offset
+        if start < 0:
+            return False
+        if self.complete:
+            return True
+        limit = self.query_params.limit
+        return limit is not None and len(self.buffer) >= start + limit
+
+    def _trim(self) -> None:
+        """
+        Removes rows before the window that are more than skip_buffer_size
+        and rows after the window that are more than limit_buffer_size.
+        """
+        get_id = self.query_params.get_document_id
+        rows_before_window = self._skip() - self.offset
+        remove_from_start = min(rows_before_window - self.skip_buffer_size, len(self.buffer))
+        if remove_from_start > 0:
+            remove = int(remove_from_start)
+            for doc in self.buffer[:remove]:
+                del self.key_document_map[get_id(doc)]
+            del self.buffer[:remove]
+            self.offset += remove
+
+        limit = self.query_params.limit
+        if limit is not None:
+            max_length = max(0, self._skip() - self.offset) + limit + self.limit_buffer_size
+            if len(self.buffer) > max_length:
+                keep = int(max_length)
+                for doc in self.buffer[keep:]:
+                    del self.key_document_map[get_id(doc)]
+                del self.buffer[keep:]
+                self.complete = False
+
+    def _apply_slice_rule(self, change_event: ChangeEvent[D]) -> None:
+        """
+        The slice rule:
+        Exactly `offset` matching rows sort before the first row of the buffer,
+        and all matching rows that sort between the first and the last row are in the buffer.
+        After the change event, this is still true for the old first and last row, so:
+        - the old version of the changed row is removed from the buffer,
+        - the new version is added if it sorts between the old first and last row,
+        - offset changes by one if the changed row moved into or out of the rows before the first row.
+        If offset is 0, there are no rows before the first row, so a row that sorts before it is added.
+        If the buffer is complete, there are no rows after the last row, so a row that sorts after it is added.
+
+        An empty buffer (only valid when complete) knows only the number of rows before it.
+        There, offset is only an upper bound, which stays an upper bound with the same update.
+        """
+        query_params = self.query_params
+        buffer = self.buffer
+        previous = change_event.previous
+        doc = change_event.doc
+        was_matching = previous is not None and query_params.query_matcher(previous)
+        does_match_now = doc is not None and query_params.query_matcher(doc)
+
+        if not buffer:
+            if self.offset == 0:
+                # there are no rows at all
+                if doc is not None and does_match_now:
+                    self._insert_at_sort_position(doc)
+            else:
+                self.offset += int(does_match_now) - int(was_matching)
+            return
+
+        first = buffer[0]
+        last = buffer[-1]
+        has_rows_before = self.offset > 0
+        was_before = previous is not None and was_matching and has_rows_before and self._compare(previous, first) < 0
+        is_before_now = doc is not None and does_match_now and has_rows_before and self._compare(doc, first) < 0
+
+        id = change_event.id
+        if self.key_document_map.pop(id, None) is not None:
+            del buffer[index_of_document_id(query_params, buffer, id)]
+        if (
+            doc is not None
+            and does_match_now
+            and not is_before_now
+            and (self.complete or self._compare(doc, last) <= 0)
+        ):
+            self._insert_at_sort_position(doc)
+        self.offset += int(is_before_now) - int(was_before)
+
+    def _compare(self, a: D, b: D) -> int:
+        """
+        Compares two rows with the sort comparator of the query.
+        Returns 0 only for two versions of the same row that sort at the same position.
+        For different rows that the comparator sees as equal,
+        the primary key decides, so that the order is always deterministic.
+        """
+        query_params = self.query_params
+        id_a = query_params.get_document_id(a)
+        id_b = query_params.get_document_id(b)
+        result = _sign(query_params.sort_comparator(a, b))
+        if id_a == id_b:
+            # A deterministic comparator breaks ties by the primary key,
+            # which gives the same answer for both directions when the sort values are equal.
+            if result == 0 or result == _sign(query_params.sort_comparator(b, a)):
+                return 0
+            return result
+        if result != 0:
+            return result
+        return -1 if id_a < id_b else 1
+
+    def _insert_at_sort_position(self, doc: D) -> None:
+        # _compare() returns 0 only for another version of the same row, which was removed before
+        push_at_sort_position(self.buffer, doc, self._compare)
+        self.key_document_map[self.query_params.get_document_id(doc)] = doc
+
+
+def _sign(value: int) -> int:
+    return (value > 0) - (value < 0)

event_reduce/states.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from .types import StateName, StateResolveFunctionInput, WriteOperation
+from .util import index_of_document_id
+
+StateResolveFunction = Callable[[StateResolveFunctionInput[Any]], bool]
+
+ORDERED_STATE_LIST: list[StateName] = list(StateName)
+"""All states, in the same order as the JavaScript implementation. The BDD references the states by their index."""
+
+
+def has_limit(input: StateResolveFunctionInput[Any]) -> bool:
+    return bool(input.query_params.limit)
+
+
+def is_find_one(input: StateResolveFunctionInput[Any]) -> bool:
+    return input.query_params.limit == 1
+
+
+def has_skip(input: StateResolveFunctionInput[Any]) -> bool:
+    skip = input.query_params.skip
+    return skip is not None and skip > 0
+
+
+def is_delete(input: StateResolveFunctionInput[Any]) -> bool:
+    return input.change_event.operation == WriteOperation.DELETE
+
+
+def is_insert(input: StateResolveFunctionInput[Any]) -> bool:
+    return input.change_event.operation == WriteOperation.INSERT
+
+
+def is_update(input: StateResolveFunctionInput[Any]) -> bool:
+    return input.change_event.operation == WriteOperation.UPDATE
+
+
+def was_limit_reached(input: StateResolveFunctionInput[Any]) -> bool:
+    limit = input.query_params.limit
+    return bool(limit) and len(input.previous_results) >= limit  # type: ignore[operator]
+
+
+def sort_params_changed(input: StateResolveFunctionInput[Any]) -> bool:
+    doc = input.change_event.doc
+    prev = input.change_event.previous
+    if doc is None:
+        return False
+    if prev is None:
+        return True
+    return input.query_params.sort_fields_changed(prev, doc)
+
+
+def was_in_result(input: StateResolveFunctionInput[Any]) -> bool:
+    id = input.change_event.id
+    if input.key_document_map is not None:
+        return id in input.key_document_map
+    return index_of_document_id(input.query_params, input.previous_results, id) >= 0
+
+
+def was_first(input: StateResolveFunctionInput[Any]) -> bool:
+    results = input.previous_results
+    return bool(results) and input.query_params.get_document_id(results[0]) == input.change_event.id
+
+
+def was_last(input: StateResolveFunctionInput[Any]) -> bool:
+    results = input.previous_results
+    return bool(results) and input.query_params.get_document_id(results[-1]) == input.change_event.id
+
+
+def _compare_previous_with_result(
+    input: StateResolveFunctionInput[Any], first: bool, expected: Callable[[int], bool]
+) -> bool:
+    """
+    Compares the previous document with the first or last result item.
+    If the changed document is the result item itself,
+    we cannot sort-compare them, because it might end in a non-deterministic
+    sort order. Because both document could be equal.
+    So instead we have to return true.
+    """
+    prev = input.change_event.previous
+    results = input.previous_results
+    if prev is None or not results:
+        return False
+    result_item = results[0] if first else results[-1]
+    if input.query_params.get_document_id(result_item) == input.change_event.id:
+        return True
+    return expected(input.query_params.sort_comparator(prev, result_item))
+
+
+def _compare_doc_with_result(
+    input: StateResolveFunctionInput[Any], first: bool, expected: Callable[[int], bool]
+) -> bool:
+    """
+    Compares the new document with the first or last result item.
+    If the changed document is the result item itself,
+    it compares with the neighbor of the result item instead,
+    so we know if the changed document still sorts first or last.
+    If there is no neighbor, the changed document is still first or last.
+    """
+    doc = input.change_event.doc
+    results = input.previous_results
+    if doc is None or not results:
+        return False
+    result_item = results[0] if first else results[-1]
+    if input.query_params.get_document_id(result_item) == input.change_event.id:
+        if len(results) < 2:
+            return True
+        result_item = results[1] if first else results[-2]
+    return expected(input.query_params.sort_comparator(doc, result_item))
+
+
+def _is_negative(c: int) -> bool:
+    return c < 0
+
+
+def _is_positive(c: int) -> bool:
+    return c > 0
+
+
+def was_sorted_before_first(input: StateResolveFunctionInput[Any]) -> bool:
+    return _compare_previous_with_result(input, True, _is_negative)
+
+
+def was_sorted_after_last(input: StateResolveFunctionInput[Any]) -> bool:
+    return _compare_previous_with_result(input, False, _is_positive)
+
+
+def is_sorted_before_first(input: StateResolveFunctionInput[Any]) -> bool:
+    return _compare_doc_with_result(input, True, _is_negative)
+
+
+def is_sorted_after_last(input: StateResolveFunctionInput[Any]) -> bool:
+    return _compare_doc_with_result(input, False, _is_positive)
+
+
+def was_matching(input: StateResolveFunctionInput[Any]) -> bool:
+    prev = input.change_event.previous
+    return prev is not None and input.query_params.query_matcher(prev)
+
+
+def does_match_now(input: StateResolveFunctionInput[Any]) -> bool:
+    doc = input.change_event.doc
+    return doc is not None and input.query_params.query_matcher(doc)
+
+
+def was_results_empty(input: StateResolveFunctionInput[Any]) -> bool:
+    return not input.previous_results
+
+
+STATE_RESOLVE_FUNCTION_BY_INDEX: list[StateResolveFunction] = [
+    is_insert,
+    is_update,
+    is_delete,
+    has_limit,
+    is_find_one,
+    has_skip,
+    was_results_empty,
+    was_limit_reached,
+    was_first,
+    was_last,
+    sort_params_changed,
+    was_in_result,
+    was_sorted_before_first,
+    was_sorted_after_last,
+    is_sorted_before_first,
+    is_sorted_after_last,
+    was_matching,
+    does_match_now,
+]
+"""The state functions in the same order as ORDERED_STATE_LIST."""
+
+
+def resolve_state(state: StateName, input: StateResolveFunctionInput[Any]) -> bool:
+    return STATE_RESOLVE_FUNCTION_BY_INDEX[ORDERED_STATE_LIST.index(state)](input)
+
+
+def get_state_set(input: StateResolveFunctionInput[Any]) -> str:
+    """
+    Returns the binary representation of all states
+    like '010110110111...' where the first '0' means that the first state is false.
+    """
+    return "".join("1" if fn(input) else "0" for fn in STATE_RESOLVE_FUNCTION_BY_INDEX)

event_reduce/types.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import Enum
+from typing import Generic, TypeVar
+
+D = TypeVar("D")
+
+
+class WriteOperation(str, Enum):
+    INSERT = "INSERT"
+    UPDATE = "UPDATE"
+    DELETE = "DELETE"
+
+
+@dataclass(frozen=True)
+class ChangeEvent(Generic[D]):
+    """
+    A write event on the database.
+    `id` is the value of the primary key of the changed document.
+    `doc` is the document after the write (None on deletes),
+    `previous` the document before the write (None on inserts).
+    """
+
+    operation: WriteOperation
+    id: str
+    doc: D | None
+    previous: D | None
+
+    @staticmethod
+    def insert(id: str, doc: D) -> ChangeEvent[D]:
+        return ChangeEvent(WriteOperation.INSERT, id, doc, None)
+
+    @staticmethod
+    def update(id: str, doc: D, previous: D) -> ChangeEvent[D]:
+        return ChangeEvent(WriteOperation.UPDATE, id, doc, previous)
+
+    @staticmethod
+    def delete(id: str, previous: D) -> ChangeEvent[D]:
+        return ChangeEvent(WriteOperation.DELETE, id, None, previous)
+
+
+@dataclass(frozen=True)
+class QueryParams(Generic[D]):
+    """
+    Describes the query whose results are kept up to date.
+    For dict documents, dict_query_params() creates it from a primary key and the sort fields.
+    """
+
+    get_document_id: Callable[[D], str]
+    """Returns the id of a document, must return the same value as the id of the change events."""
+    query_matcher: Callable[[D], bool]
+    """Returns true if the document matches the query."""
+    sort_comparator: Callable[[D, D], int]
+    """
+    To have a deterministic sorting, the comparator must never return 0
+    for two different documents. Use the primary key as last sort field to ensure that.
+    """
+    sort_fields_changed: Callable[[D, D], bool]
+    """
+    Returns true if any of the fields that the query sorts by
+    differs between the previous and the new version of a document.
+    Called as sort_fields_changed(previous, doc).
+    """
+    skip: int | None = None
+    limit: int | None = None
+
+
+ResultKeyDocumentMap = dict[str, D]
+"""Map from the id of each document in the results to the document."""
+
+
+@dataclass
+class StateResolveFunctionInput(Generic[D]):
+    """
+    The input of the state functions, of the action functions and of calculate_action_name().
+    Action functions mutate previous_results and key_document_map.
+    """
+
+    query_params: QueryParams[D]
+    change_event: ChangeEvent[D]
+    previous_results: list[D]
+    key_document_map: dict[str, D] | None = None
+
+
+class ActionName(str, Enum):
+    """The actions, in the same order as the JavaScript implementation, the values are the JavaScript names."""
+
+    DO_NOTHING = "doNothing"
+    INSERT_FIRST = "insertFirst"
+    INSERT_LAST = "insertLast"
+    REMOVE_FIRST_ITEM = "removeFirstItem"
+    REMOVE_LAST_ITEM = "removeLastItem"
+    REMOVE_FIRST_INSERT_LAST = "removeFirstInsertLast"
+    REMOVE_LAST_INSERT_FIRST = "removeLastInsertFirst"
+    REMOVE_FIRST_INSERT_FIRST = "removeFirstInsertFirst"
+    REMOVE_LAST_INSERT_LAST = "removeLastInsertLast"
+    REMOVE_EXISTING = "removeExisting"
+    REPLACE_EXISTING = "replaceExisting"
+    # only used by the truth-table generator, never returned by the BDD
+    ALWAYS_WRONG = "alwaysWrong"
+    INSERT_AT_SORT_POSITION = "insertAtSortPosition"
+    REMOVE_EXISTING_AND_INSERT_AT_SORT_POSITION = "removeExistingAndInsertAtSortPosition"
+    INSERT_AT_SORT_POSITION_REMOVE_LAST = "insertAtSortPositionRemoveLast"
+    INSERT_AT_SORT_POSITION_REMOVE_FIRST = "insertAtSortPositionRemoveFirst"
+    RUN_FULL_QUERY_AGAIN = "runFullQueryAgain"
+    # if a state was never reached, we do not know the correct action
+    UNKNOWN_ACTION = "unknownAction"
+
+
+class StateName(str, Enum):
+    """The states, in the same order as the JavaScript implementation, the values are the JavaScript names."""
+
+    IS_INSERT = "isInsert"
+    IS_UPDATE = "isUpdate"
+    IS_DELETE = "isDelete"
+    HAS_LIMIT = "hasLimit"
+    IS_FIND_ONE = "isFindOne"
+    HAS_SKIP = "hasSkip"
+    WAS_RESULTS_EMPTY = "wasResultsEmpty"
+    WAS_LIMIT_REACHED = "wasLimitReached"
+    WAS_FIRST = "wasFirst"
+    WAS_LAST = "wasLast"
+    SORT_PARAMS_CHANGED = "sortParamsChanged"
+    WAS_IN_RESULT = "wasInResult"
+    WAS_SORTED_BEFORE_FIRST = "wasSortedBeforeFirst"
+    WAS_SORTED_AFTER_LAST = "wasSortedAfterLast"
+    IS_SORTED_BEFORE_FIRST = "isSortedBeforeFirst"
+    IS_SORTED_AFTER_LAST = "isSortedAfterLast"
+    WAS_MATCHING = "wasMatching"
+    DOES_MATCH_NOW = "doesMatchNow"
+
+
+class EventReduceError(Exception):
+    """Raised for the actions that cannot be applied to the results and for invalid input."""
+
+    def __init__(self, code: str) -> None:
+        super().__init__("EventReduce:" + code)
+        self.code = code

event_reduce/util.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from typing import Any, TypeVar
+
+from .types import QueryParams
+
+D = TypeVar("D")
+
+_MISSING = object()
+
+
+def get_property(obj: Any, path: str, default: Any = None) -> Any:
+    """
+    Returns the value at the dot-separated path like 'items.0.rank'.
+    List entries are accessed by their index.
+    Returns the given default value if the path does not exist.
+    """
+    return _get_path(obj, path.split("."), default)
+
+
+def _get_path(obj: Any, keys: list[str], default: Any = None) -> Any:
+    for key in keys:
+        if isinstance(obj, Mapping):
+            obj = obj.get(key, _MISSING)
+        elif isinstance(obj, (list, tuple)) and key.isdigit() and int(key) < len(obj):
+            obj = obj[int(key)]
+        else:
+            return default
+        if obj is _MISSING or obj is None:
+            return default
+    return obj
+
+
+def normalize_sort_field(field: str) -> str:
+    """normalizes sort-field, in: '-age', out: 'age'"""
+    return field[1:] if field.startswith("-") else field
+
+
+def dict_query_params(
+    primary_key: str,
+    sort_fields: Sequence[str],
+    query_matcher: Callable[[dict[str, Any]], bool],
+    sort_comparator: Callable[[dict[str, Any], dict[str, Any]], int],
+    skip: int | None = None,
+    limit: int | None = None,
+) -> QueryParams[dict[str, Any]]:
+    """
+    QueryParams for dict documents, like the primaryKey and sortFields of the JavaScript implementation.
+    The sort fields can be dot-separated paths and can start with '-'.
+    """
+    # Like JavaScript, fields without a dot are read directly, paths are split only once.
+    fields: list[str] = []
+    paths: list[list[str]] = []
+    for sort_field in sort_fields:
+        field = normalize_sort_field(sort_field)
+        if "." in field:
+            paths.append(field.split("."))
+        else:
+            fields.append(field)
+
+    def sort_fields_changed(previous: dict[str, Any], doc: dict[str, Any]) -> bool:
+        for field in fields:
+            if previous.get(field) != doc.get(field):
+                return True
+        for path in paths:
+            if _get_path(previous, path) != _get_path(doc, path):
+                return True
+        return False
+
+    def get_document_id(doc: dict[str, Any]) -> str:
+        return str(doc[primary_key])
+
+    return QueryParams(
+        get_document_id=get_document_id,
+        query_matcher=query_matcher,
+        sort_comparator=sort_comparator,
+        sort_fields_changed=sort_fields_changed,
+        skip=skip,
+        limit=limit,
+    )
+
+
+def index_of_document_id(query_params: QueryParams[D], docs: list[D], id: str) -> int:
+    """Returns the index of the document with the given id or -1 if it is not in the given documents."""
+    get_id = query_params.get_document_id
+    for index, doc in enumerate(docs):
+        if get_id(doc) == id:
+            return index
+    return -1
+
+
+def push_at_sort_position(items: list[D], item: D, compare: Callable[[D, D], int]) -> None:
+    """
+    Inserts the item at its sort position, which is much faster than re-sorting the list.
+    Items that are equal to the new item stay before it.
+    """
+    # Shortcut: the item belongs at the end, append() is O(1).
+    if not items or compare(items[-1], item) <= 0:
+        items.append(item)
+        return
+    low = 0
+    high = len(items)
+    while low < high:
+        mid = (low + high) >> 1
+        if compare(items[mid], item) <= 0:
+            low = mid + 1
+        else:
+            high = mid
+    items.insert(low, item)

event_reduce-7.4.2.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: event-reduce
+Version: 7.4.2
+Summary: Update live query results from database change events without re-running the query.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pubkey/event-reduce
+Project-URL: Repository, https://github.com/pubkey/event-reduce
+Keywords: live-query,reactive,realtime,database,bdd
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# event-reduce (Python)
+
+Python implementation of the [EventReduce algorithm](https://github.com/pubkey/event-reduce).
+It takes the previous results of a query and a change event of the database
+and calculates the new results **in memory, without running the query over the database again**.
+
+It uses the BDD that the [JavaScript implementation](../javascript/) created,
+so both always decide on the same action. It needs Python 3.10 or newer and has no dependencies.
+
+## Installation
+
+```sh
+pip install event-reduce
+```
+
+## Usage
+
+```python
+from event_reduce import (
+    ActionName,
+    ChangeEvent,
+    StateResolveFunctionInput,
+    calculate_action_name,
+    dict_query_params,
+    run_action,
+)
+
+
+def compare(a, b):
+    # must never return 0 for two different documents, so sort by the primary key last
+    if a["age"] != b["age"]:
+        return -1 if a["age"] < b["age"] else 1
+    return -1 if a["id"] < b["id"] else 1
+
+
+# SELECT * FROM users WHERE age > 18 ORDER BY age, id LIMIT 10
+query_params = dict_query_params(
+    primary_key="id",
+    sort_fields=["age", "id"],
+    query_matcher=lambda doc: doc["age"] > 18,
+    sort_comparator=compare,
+    limit=10,
+)
+
+results = [{"id": "a", "age": 20}, {"id": "b", "age": 30}]
+
+# a change event from the change stream of your database
+change_event = ChangeEvent.insert("c", {"id": "c", "age": 25})
+
+action = calculate_action_name(StateResolveFunctionInput(query_params, change_event, results))
+if action == ActionName.RUN_FULL_QUERY_AGAIN:
+    results = run_query_on_database()  # EventReduce could not optimize this event
+else:
+    run_action(action, query_params, change_event, results)
+    # -> [a, c, b]
+```
+
+`dict_query_params()` is for dict documents, like the `primaryKey` and `sortFields` of the JavaScript implementation.
+The sort fields can be dot-separated paths like `"address.city"`.
+For other documents, create the `QueryParams` with a `get_document_id` function
+and a `sort_fields_changed(previous, doc)` function that returns true if a sort field changed.
+
+### Key document map
+
+For big result sets, pass a dict from the id to the document as `key_document_map`
+to both `StateResolveFunctionInput` and `run_action()`.
+It is used to check whether a document is in the results without scanning them,
+and `run_action()` keeps it in sync with the results.
+
+### Differences to the JavaScript implementation
+
+- Change events are created with `ChangeEvent.insert()`, `ChangeEvent.update()` and `ChangeEvent.delete()`.
+- The names are snake_case, `ActionName` and `StateName` are enums whose values are the JavaScript names.
+- `run_action()` raises an `EventReduceError` for `RUN_FULL_QUERY_AGAIN` and `UNKNOWN_ACTION`.
+  `ALWAYS_WRONG` is only used by the truth-table generator and raises like `UNKNOWN_ACTION`.
+
+## Result window buffer
+
+For a query with a limit or a skip, EventReduce returns `RUN_FULL_QUERY_AGAIN` when a row has to move into the result window that is not in the previous results:
+the row after the window (when a row leaves a full window) or the last skipped row (when a row is added in front of the window).
+The result window buffer avoids most of these full queries: it keeps `limit_buffer_size` rows after the window and `skip_buffer_size` skipped rows before it in memory.
+It works like the [result window buffer of the JavaScript implementation](../docs/result-window-buffer.md),
+which explains how it works, how to choose the buffer sizes and has measurements.
+
+```python
+from event_reduce import ResultWindowBuffer, get_recommended_result_window_buffer_size
+
+# recommended size: about log2(limit), at most 30
+size = get_recommended_result_window_buffer_size(query_params.limit)
+buffer = ResultWindowBuffer(query_params, limit_buffer_size=size, skip_buffer_size=size)
+# run the query with the skip and limit of the buffer
+buffer.reset(run_query(buffer.query()))
+# the rows of the original skip and limit
+results = buffer.results()
+
+# on new change events
+result = buffer.apply_change_events(change_events)
+if result.run_full_query_again:
+    buffer.reset(run_query(buffer.query()))
+    results = buffer.results()
+elif result.changed:
+    results = result.results
+```
+
+`query()` returns the `skip` and `limit` to run the query with, `limit` is None if all rows after the skip are needed.
+`math.inf` as a buffer size keeps all rows on that side, like `Infinity` in JavaScript.
+
+## Development
+
+```sh
+pip install pytest ruff mypy
+pytest
+ruff check . && ruff format --check . && mypy src
+```
+
+The BDD is generated by the truth-table generator of the JavaScript implementation,
+which also writes `src/event_reduce/bdd_generated.py`.
+The tests run the [shared test suite](../test-suite/), the same tests as all other implementations.
+
+## Who uses EventReduce
+
+[RxDB](https://rxdb.info/), the local-first database, uses EventReduce for its live queries since [version 9.0.0](https://rxdb.info/releases/9.0.0.html), where it is enabled by default.
+When an app subscribes to a query, RxDB keeps the results up to date by running each write event through EventReduce,
+and only queries the storage again when EventReduce returns `RUN_FULL_QUERY_AGAIN`.

event_reduce-7.4.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+event_reduce/__init__.py,sha256=dPlXb39ukXvg53yXaKX1Cdms6UBmqyLUWbzleGo0J2A,2530
+event_reduce/actions.py,sha256=miJl5LPsJ5l9CMNpUa_DYn_NWSwdqQBI6n-ZdMc7pMo,6352
+event_reduce/bdd.py,sha256=KYq1BAOMbFxK5kEHNkm4yUqv7I_1YdROFyZHcRJZNcs,1356
+event_reduce/bdd_generated.py,sha256=sWbodc7xt9OuoTg-qv_szzxc4P6Pn_wskkMnw7byHH8,1280
+event_reduce/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+event_reduce/result_window_buffer.py,sha256=wMdjjQijGAeq6BRweqIG-MTbhVNm6G_29ofIoFM0qyQ,15964
+event_reduce/states.py,sha256=gGoYZexiVXH3G_svWAzvTqT2YHjC5xz-cxIxmhbdHhs,6187
+event_reduce/types.py,sha256=wonFGpccRXtR5tgr8WBZBnpAlKlWW31p774g1HdjFHI,4784
+event_reduce/util.py,sha256=WIqR9g168bWwZMrapgkgDpFqqClSbE5V8_ROVLLFO6E,3569
+event_reduce-7.4.2.dist-info/METADATA,sha256=MPe8oJW_J6IBSK_UvbxX8ZEkANHc5p-k7M5V5Phms_E,5548
+event_reduce-7.4.2.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+event_reduce-7.4.2.dist-info/top_level.txt,sha256=zSKcgKrau6mGJVMEFS-H0wBrPsa_7-S3W3t1Y_aircA,13
+event_reduce-7.4.2.dist-info/RECORD,,

event_reduce-7.4.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

event_reduce-7.4.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+event_reduce