#434

Committed 11 Aug 2025 10:38AM UTC coverage: 92.953% (-1.8%) from 94.8%

Build # #434

Build Type

push

coveralls-python

Committed by

LeanderCS

Commit Message

Optimze performance for heavy processing

Run Details

39 of 86 new or added lines in 9 files covered. (45.35%)

3 existing lines in 3 files now uncovered.

2005 of 2157 relevant lines covered (92.95%)

0.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

28.13

/flask_inputfilter/filters/lazy_filter_chain.py

from __future__ import annotations

from typing import TYPE_CHECKING, Any, Generator

if TYPE_CHECKING:
    from flask_inputfilter.models import BaseFilter


class LazyFilterChain:
    """
    A lazy evaluation wrapper for filter chains that delays processing until
    needed.

    This can significantly improve performance when dealing with large filter
    chains or when early filters might invalidate the need for later
    processing.
    """

    __slots__ = ("_filters", "_processed", "_result", "_value")

    def __init__(self, filters: list[BaseFilter], value: Any) -> None:
        self._filters = filters
        self._value = value
        self._processed = False
        self._result = None

    def _process(self) -> Generator[Any, None, None]:
        """Generator that lazily applies filters."""
        current_value = self._value
        for filter in self._filters:
            if current_value is None:
                yield None
                return
            current_value = filter.apply(current_value)
            yield current_value

    def get_result(self) -> Any:
        """Get the final result, processing filters only when needed."""
        if not self._processed:
            # Process all filters and get the final result
            for result in self._process():
                self._result = result
            self._processed = True
        return self._result

    def apply_until(self, condition: callable) -> Any:
        """
        Apply filters until a condition is met.

        This allows for early termination of filter processing.
        """
        current_value = self._value
        for filter in self._filters:
            if current_value is None or condition(current_value):
                return current_value
            current_value = filter.apply(current_value)
        return current_value

1	from __future__ import annotations	1✔
2
3	from typing import TYPE_CHECKING, Any, Generator	1✔
4
5	if TYPE_CHECKING:	1✔
NEW 6	from flask_inputfilter.models import BaseFilter	×
7
8
9	class LazyFilterChain:	1✔
10	"""
11	A lazy evaluation wrapper for filter chains that delays processing until
12	needed.
13
14	This can significantly improve performance when dealing with large filter
15	chains or when early filters might invalidate the need for later
16	processing.
17	"""
18
19	__slots__ = ("_filters", "_processed", "_result", "_value")	1✔
20
21	def __init__(self, filters: list[BaseFilter], value: Any) -> None:	1✔
NEW 22	self._filters = filters	×
NEW 23	self._value = value	×
NEW 24	self._processed = False	×
NEW 25	self._result = None	×
26
27	def _process(self) -> Generator[Any, None, None]:	1✔
28	"""Generator that lazily applies filters."""
NEW 29	current_value = self._value	×
NEW 30	for filter in self._filters:	×
NEW 31	if current_value is None:	×
NEW 32	yield None	×
NEW 33	return	×
NEW 34	current_value = filter.apply(current_value)	×
NEW 35	yield current_value	×
36
37	def get_result(self) -> Any:	1✔
38	"""Get the final result, processing filters only when needed."""
NEW 39	if not self._processed:	×
40	# Process all filters and get the final result
NEW 41	for result in self._process():	×
NEW 42	self._result = result	×
NEW 43	self._processed = True	×
NEW 44	return self._result	×
45
46	def apply_until(self, condition: callable) -> Any:	1✔
47	"""
48	Apply filters until a condition is met.
49
50	This allows for early termination of filter processing.
51	"""
NEW 52	current_value = self._value	×
NEW 53	for filter in self._filters:	×
NEW 54	if current_value is None or condition(current_value):	×
NEW 55	return current_value	×
NEW 56	current_value = filter.apply(current_value)	×
NEW 57	return current_value	×

LeanderCS / flask-inputfilter / #434

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous