API reference¶

This page provides a complete reference for all public APIs in selenium-expect.

expect() — Entry point for all assertions
poll() — Poll-based assertions on arbitrary functions
extend() — Register custom matchers
merge_expects() — Combine matchers from modules
SoftAssertionCollector — Soft assertion management
assert_all() — Raise collected soft failures
ExpectConfig — Configuration dataclass
Configuration setters — Global defaults
Assertion classes — All assertion class references

`expect(target, ...)`¶

Create an assertion for the given target. Dispatches to the appropriate assertion class based on the target's type.

Supported targets¶

Target type	Assertion class	Example
`WebElement`	`ExpectElement`	`expect(element).to_be_visible()`
`WebDriver`	`ExpectDriver`	`expect(driver).to_have_title("Page")`
`list[WebElement]`	`ExpectList`	`expect(elements).to_have_count(5)`
`Alert`	`ExpectAlert`	`expect(alert).to_have_text("Confirm?")`
`Select`	`ExpectSelect`	`expect(select).to_have_value("opt1")`
`ShadowRoot`	`ExpectShadow`	`expect(shadow).to_have_element(By.ID, "x")`
`WebDriver` + `by`/`value`	`LocatorExpect`	`expect(driver, by=By.ID, value="x").to_be_visible()`

Parameters¶

Parameter	Type	Default	Description
`target`	`Any`	—	The object to assert on
`by`	`str`	`None`	Locator strategy (for locator-based expect)
`value`	`str`	`None`	Locator value (for locator-based expect)
`locator`	`tuple[str, str]`	`None`	`(by, value)` tuple shorthand
`message`	`str`	`None`	Custom message for error output
`soft`	`bool`	`False`	Enable soft assertion mode
`timeout`	`float`	`None`	Override default timeout
`polling`	`float \\| list[float]`	`None`	Override default polling

selenium_expect._expect.Expect ¶

Callable expect dispatcher with attached utilities.

Use expect(target) to create assertions, expect.poll(fn) for retry-based polling, and expect.configure(...) for pre-configured variants.

Source code in selenium_expect/_expect.py

class Expect:
    """Callable expect dispatcher with attached utilities.

    Use ``expect(target)`` to create assertions, ``expect.poll(fn)`` for
    retry-based polling, and ``expect.configure(...)`` for pre-configured
    variants.
    """

    def __call__(
        self,
        target: Any,
        /,
        *,
        message: str | None = None,
        timeout: float | None = None,
        polling: float | list[float] | None = None,
        soft: bool | None = None,
        config: ExpectConfig | None = None,
        by: str | None = None,
        value: str | None = None,
        locator: tuple[str, str] | None = None,
    ) -> AssertionMixin:
        """Create an expect assertion for the given target.

        Dispatches to the appropriate assertion class via ``ASSERTION_REGISTRY``
        based on the target's type.

        If ``by`` and ``value`` are provided, a ``LocatorExpect`` is created
        that re-finds the element on each poll cycle.

        Alternatively, ``locator=(By.ID, 'foo')`` can be used as a tuple
        shorthand for ``by=..., value=...``.
        """
        if locator is not None:
            if by is not None or value is not None:
                raise ValueError("Cannot use both 'locator' and 'by/value' arguments")
            by, value = locator

        if (by is not None) != (value is not None):
            raise ValueError("Must provide both 'by' and 'value', or neither")

        if by is not None and value is not None:
            from selenium_expect._locator import LocatorExpect

            if not isinstance(target, WebDriver):
                raise TypeError("expect() with by/value requires a WebDriver target")

            effective_config = config if config is not None else get_config()
            if timeout is not None or polling is not None or soft is not None:
                overrides: dict[str, Any] = {}
                if timeout is not None:
                    overrides["timeout"] = normalize_timeout(timeout)
                if polling is not None:
                    if isinstance(polling, list):
                        overrides["polling_intervals"] = polling
                    else:
                        overrides["polling_interval"] = polling
                if soft is not None:
                    overrides["soft_mode"] = soft
                effective_config = effective_config.replace(**overrides)

            return LocatorExpect(
                driver=target,
                by=by,
                value=value,
                config=effective_config,
                message=message,
            )

        if target is None:
            raise TypeError("expect() does not support None as target")

        type_name = _resolve_target_type(target)
        cls = ASSERTION_REGISTRY.get(type_name)
        if cls is None:
            raise TypeError(f"expect() does not support target type '{type_name}'")

        assertion_cls = cast(type[AssertionMixin], cls)

        effective_config = config if config is not None else get_config()

        if timeout is not None or polling is not None or soft is not None:
            cfg_overrides: dict[str, Any] = {}
            if timeout is not None:
                cfg_overrides["timeout"] = normalize_timeout(timeout)
            if polling is not None:
                if isinstance(polling, list):
                    cfg_overrides["polling_intervals"] = polling
                else:
                    cfg_overrides["polling_interval"] = polling
            if soft is not None:
                cfg_overrides["soft_mode"] = soft
            effective_config = effective_config.replace(**cfg_overrides)

        return assertion_cls(target=target, config=effective_config, message=message)

    def poll(
        self,
        fn: Callable[[], Any],
        *,
        timeout: float | None = None,
        polling: float | list[float] | None = None,
        config: ExpectConfig | None = None,
    ) -> PollAssertion:
        """Create a ``PollAssertion`` for retry-based assertions on *fn*.

        Usage::

            expect.poll(lambda: driver.execute_script("return document.readyState"))
                .to_equal("complete")
        """
        return PollAssertion(fn, timeout=timeout, polling=polling, config=config)

    def configure(self, **defaults: Any) -> Callable[..., AssertionMixin]:
        """Create a pre-configured expect variant.

        Returns a callable that behaves like ``expect()`` with *defaults*
        pre-applied. Explicit kwargs from the caller override the defaults.

        Usage::

            fast_expect = expect.configure(timeout=1.0, polling=0.1)
            fast_expect(el).to_be_visible()
        """

        def _configured_expect(
            target: Any,
            /,
            **overrides: Any,
        ) -> AssertionMixin:
            merged: dict[str, Any] = {**defaults, **overrides}
            return self(target, **merged)

        return _configured_expect

call ¶

__call__(target: Any, /, *, message: str | None = None, timeout: float | None = None, polling: float | list[float] | None = None, soft: bool | None = None, config: ExpectConfig | None = None, by: str | None = None, value: str | None = None, locator: tuple[str, str] | None = None) -> AssertionMixin

Create an expect assertion for the given target.

Dispatches to the appropriate assertion class via ASSERTION_REGISTRY based on the target's type.

If by and value are provided, a LocatorExpect is created that re-finds the element on each poll cycle.

Alternatively, locator=(By.ID, 'foo') can be used as a tuple shorthand for by=..., value=....

Source code in selenium_expect/_expect.py

def __call__(
    self,
    target: Any,
    /,
    *,
    message: str | None = None,
    timeout: float | None = None,
    polling: float | list[float] | None = None,
    soft: bool | None = None,
    config: ExpectConfig | None = None,
    by: str | None = None,
    value: str | None = None,
    locator: tuple[str, str] | None = None,
) -> AssertionMixin:
    """Create an expect assertion for the given target.

    Dispatches to the appropriate assertion class via ``ASSERTION_REGISTRY``
    based on the target's type.

    If ``by`` and ``value`` are provided, a ``LocatorExpect`` is created
    that re-finds the element on each poll cycle.

    Alternatively, ``locator=(By.ID, 'foo')`` can be used as a tuple
    shorthand for ``by=..., value=...``.
    """
    if locator is not None:
        if by is not None or value is not None:
            raise ValueError("Cannot use both 'locator' and 'by/value' arguments")
        by, value = locator

    if (by is not None) != (value is not None):
        raise ValueError("Must provide both 'by' and 'value', or neither")

    if by is not None and value is not None:
        from selenium_expect._locator import LocatorExpect

        if not isinstance(target, WebDriver):
            raise TypeError("expect() with by/value requires a WebDriver target")

        effective_config = config if config is not None else get_config()
        if timeout is not None or polling is not None or soft is not None:
            overrides: dict[str, Any] = {}
            if timeout is not None:
                overrides["timeout"] = normalize_timeout(timeout)
            if polling is not None:
                if isinstance(polling, list):
                    overrides["polling_intervals"] = polling
                else:
                    overrides["polling_interval"] = polling
            if soft is not None:
                overrides["soft_mode"] = soft
            effective_config = effective_config.replace(**overrides)

        return LocatorExpect(
            driver=target,
            by=by,
            value=value,
            config=effective_config,
            message=message,
        )

    if target is None:
        raise TypeError("expect() does not support None as target")

    type_name = _resolve_target_type(target)
    cls = ASSERTION_REGISTRY.get(type_name)
    if cls is None:
        raise TypeError(f"expect() does not support target type '{type_name}'")

    assertion_cls = cast(type[AssertionMixin], cls)

    effective_config = config if config is not None else get_config()

    if timeout is not None or polling is not None or soft is not None:
        cfg_overrides: dict[str, Any] = {}
        if timeout is not None:
            cfg_overrides["timeout"] = normalize_timeout(timeout)
        if polling is not None:
            if isinstance(polling, list):
                cfg_overrides["polling_intervals"] = polling
            else:
                cfg_overrides["polling_interval"] = polling
        if soft is not None:
            cfg_overrides["soft_mode"] = soft
        effective_config = effective_config.replace(**cfg_overrides)

    return assertion_cls(target=target, config=effective_config, message=message)

configure ¶

configure(**defaults: Any) -> Callable[..., AssertionMixin]

Create a pre-configured expect variant.

Returns a callable that behaves like expect() with defaults pre-applied. Explicit kwargs from the caller override the defaults.

Usage::

fast_expect = expect.configure(timeout=1.0, polling=0.1)
fast_expect(el).to_be_visible()

Source code in selenium_expect/_expect.py

def configure(self, **defaults: Any) -> Callable[..., AssertionMixin]:
    """Create a pre-configured expect variant.

    Returns a callable that behaves like ``expect()`` with *defaults*
    pre-applied. Explicit kwargs from the caller override the defaults.

    Usage::

        fast_expect = expect.configure(timeout=1.0, polling=0.1)
        fast_expect(el).to_be_visible()
    """

    def _configured_expect(
        target: Any,
        /,
        **overrides: Any,
    ) -> AssertionMixin:
        merged: dict[str, Any] = {**defaults, **overrides}
        return self(target, **merged)

    return _configured_expect

poll ¶

poll(fn: Callable[[], Any], *, timeout: float | None = None, polling: float | list[float] | None = None, config: ExpectConfig | None = None) -> PollAssertion

Create a PollAssertion for retry-based assertions on fn.

Usage::

expect.poll(lambda: driver.execute_script("return document.readyState"))
    .to_equal("complete")

Source code in selenium_expect/_expect.py

def poll(
    self,
    fn: Callable[[], Any],
    *,
    timeout: float | None = None,
    polling: float | list[float] | None = None,
    config: ExpectConfig | None = None,
) -> PollAssertion:
    """Create a ``PollAssertion`` for retry-based assertions on *fn*.

    Usage::

        expect.poll(lambda: driver.execute_script("return document.readyState"))
            .to_equal("complete")
    """
    return PollAssertion(fn, timeout=timeout, polling=polling, config=config)

`ExpectConfig`¶

Immutable configuration dataclass for all assertions.

Fields¶

Field	Type	Default	Description
`timeout`	`float`	`5.0`	Default timeout in seconds
`polling_interval`	`float`	`0.5`	Fixed polling interval
`polling_intervals`	`list[float] \\| None`	`None`	Backoff schedule
`screenshot_on_failure`	`bool`	`False`	Capture screenshot on failure
`screenshot_path`	`str \\| None`	`None`	Screenshot directory
`debug_mode`	`bool`	`False`	Debug logging
`soft_mode`	`bool`	`False`	Soft assertion mode

Usage¶

from selenium_expect import ExpectConfig, expect

# Create a custom config
config = ExpectConfig(timeout=10, polling_interval=0.25, debug_mode=True)

# Use with expect.configure()
debug_expect = expect.configure(timeout=10, polling=0.25, debug_mode=True)

selenium_expect._config.ExpectConfig `dataclass` ¶

Immutable configuration for expect assertions.

Use replace() to create a new instance with overridden fields. The global config singleton is mutated via the module-level setters.

Source code in selenium_expect/_config.py

@dataclass(frozen=True, slots=True)
class ExpectConfig:
    """Immutable configuration for expect assertions.

    Use ``replace()`` to create a new instance with overridden fields.
    The global config singleton is mutated via the module-level setters.
    """

    timeout: float = 5.0
    polling_interval: float = 0.5
    polling_intervals: list[float] | None = None
    screenshot_on_failure: bool = False
    screenshot_path: str | None = None
    debug_mode: bool = False
    soft_mode: bool = False

    def __post_init__(self) -> None:
        if self.timeout < 0:
            raise ValueError(f"timeout must be >= 0, got {self.timeout}")
        if self.polling_interval < 0:
            raise ValueError(f"polling_interval must be >= 0, got {self.polling_interval}")
        if self.polling_intervals is not None:
            if len(self.polling_intervals) == 0:
                raise ValueError("polling_intervals must not be empty; use None for fixed interval")
            for i, interval in enumerate(self.polling_intervals):
                if interval < 0:
                    raise ValueError(f"polling_intervals[{i}] must be >= 0, got {interval}")

    def replace(self, **kwargs: Any) -> ExpectConfig:
        """Return a new instance with overridden fields."""
        return _replace(self, **kwargs)

replace ¶

replace(**kwargs: Any) -> ExpectConfig

Return a new instance with overridden fields.

Source code in selenium_expect/_config.py

def replace(self, **kwargs: Any) -> ExpectConfig:
    """Return a new instance with overridden fields."""
    return _replace(self, **kwargs)

`poll(fn, ...)`¶

Create a PollAssertion for retry-based assertions on an arbitrary function.

Parameters¶

Parameter	Type	Default	Description
`fn`	`Callable[[], Any]`	—	Zero-argument callable to poll
`timeout`	`float`	`None`	Override default timeout
`polling`	`float \\| list[float]`	`None`	Override default polling

Example¶

from selenium_expect import expect, poll

# Using expect.poll
expect.poll(lambda: driver.execute_script("return document.readyState")).to_equal("complete")

# Using standalone poll
poll(lambda: driver.current_url, timeout=10).to_match(r"https://.*\.example\.com")

selenium_expect._poll.poll ¶

poll(fn: Callable[[], Any], *, timeout: float | None = None, polling: float | list[float] | None = None, config: ExpectConfig | None = None) -> PollAssertion

Create a PollAssertion for retry-based assertions on fn.

Usage::

poll(lambda: driver.execute_script("return document.readyState"))
    .to_equal("complete")

Source code in selenium_expect/_poll.py

def poll(
    fn: Callable[[], Any],
    *,
    timeout: float | None = None,
    polling: float | list[float] | None = None,
    config: ExpectConfig | None = None,
) -> PollAssertion:
    """Create a ``PollAssertion`` for retry-based assertions on *fn*.

    Usage::

        poll(lambda: driver.execute_script("return document.readyState"))
            .to_equal("complete")
    """
    return PollAssertion(fn, timeout=timeout, polling=polling, config=config)

`PollAssertion`¶

Assertion over an arbitrary function with retry loop.

Methods¶

Method	Description
`to_equal(expected)`	Assert `fn() == expected`
`to_be_truthy()`	Assert `bool(fn())` is `True`
`to_be_falsy()`	Assert `bool(fn())` is `False`
`to_be_none()`	Assert `fn()` is `None`
`to_contain(expected)`	Assert `expected in fn()`
`to_match(pattern)`	Assert `re.search(pattern, str(fn()))` matches
`to_be_greater_than(expected)`	Assert `fn() > expected`
`to_be_less_than(expected)`	Assert `fn() < expected`
`to_be_in_list(expected)`	Assert `fn() in expected`
`to_have_length(expected)`	Assert `len(fn()) == expected`

selenium_expect._poll.PollAssertion ¶

Assertion over an arbitrary function with retry loop.

Source code in selenium_expect/_poll.py

class PollAssertion:
    """Assertion over an arbitrary function with retry loop."""

    def __init__(
        self,
        fn: Callable[[], Any],
        timeout: float | None = None,
        polling: float | list[float] | None = None,
        config: ExpectConfig | None = None,
    ) -> None:
        self._fn = fn
        self._config = config if config is not None else get_config()
        self._timeout = _normalize_timeout(timeout) if timeout is not None else self._config.timeout
        if self._timeout < 0:
            raise ValueError(f"timeout must be >= 0, got {self._timeout}")
        if polling is None:
            self._polling_interval = self._config.polling_interval
            self._polling_intervals = self._config.polling_intervals
        elif isinstance(polling, list):
            if len(polling) == 0:
                raise ValueError("polling list must not be empty; use a float for fixed interval")
            self._polling_interval = 0.5
            self._polling_intervals = polling
        else:
            self._polling_interval = polling
            self._polling_intervals = None
        if self._polling_interval < 0:
            raise ValueError(f"polling interval must be >= 0, got {self._polling_interval}")
        if self._polling_intervals is not None:
            for i, interval in enumerate(self._polling_intervals):
                if interval < 0:
                    raise ValueError(f"polling_intervals[{i}] must be >= 0, got {interval}")

    def _run(
        self,
        condition: Callable[[], tuple[bool, Any]],
        condition_name: str,
        expected: Any = None,
    ) -> None:
        """Execute the retry loop and raise on failure."""
        result = retry_until(
            condition=condition,
            timeout=self._timeout,
            polling_interval=self._polling_interval,
            polling_intervals=self._polling_intervals,
            debug=self._config.debug_mode,
        )
        if result.passed:
            return
        error_msg = AssertionFormatter.format_error(
            entity="poll()",
            condition=condition_name,
            expected=expected,
            actual=result.actual_value,
            elapsed_ms=result.elapsed_ms,
            poll_count=result.poll_count,
            polling_interval=self._polling_interval,
            timeline=result.timeline,
        )
        if self._config.soft_mode:
            from selenium_expect._soft import SoftAssertionCollector

            SoftAssertionCollector.add_failure(error_msg)
        else:
            raise AssertionError(error_msg)

    def to_equal(self, expected: Any) -> None:
        """Assert fn() == expected."""
        fn = self._fn

        def condition() -> tuple[bool, Any]:
            actual = fn()
            return (actual == expected, actual)

        self._run(condition, f"to equal {expected!r}", expected)

    def to_be_truthy(self) -> None:
        """Assert bool(fn()) is True."""
        fn = self._fn

        def condition() -> tuple[bool, Any]:
            actual = fn()
            return (bool(actual), actual)

        self._run(condition, "to be truthy", True)

    def to_be_falsy(self) -> None:
        """Assert bool(fn()) is False."""
        fn = self._fn

        def condition() -> tuple[bool, Any]:
            actual = fn()
            return (not bool(actual), actual)

        self._run(condition, "to be falsy", False)

    def to_be_none(self) -> None:
        """Assert fn() is None."""
        fn = self._fn

        def condition() -> tuple[bool, Any]:
            actual = fn()
            return (actual is None, actual)

        self._run(condition, "to be None", None)

    def to_contain(self, expected: Any) -> None:
        """Assert expected in fn()."""
        fn = self._fn

        def condition() -> tuple[bool, Any]:
            actual = fn()
            if actual is None:
                return (False, actual)
            try:
                return (expected in actual, actual)
            except TypeError:
                return (False, f"not iterable: {actual!r}")

        self._run(condition, f"to contain {expected!r}", expected)

    def to_match(self, pattern: str) -> None:
        """Assert re.search(pattern, str(fn()))."""
        fn = self._fn

        def condition() -> tuple[bool, Any]:
            actual = fn()
            return (re.search(pattern, str(actual)) is not None, actual)

        self._run(condition, f"to match {pattern!r}", pattern)

    def to_be_greater_than(self, expected: Any) -> None:
        """Assert fn() > expected."""
        fn = self._fn

        def condition() -> tuple[bool, Any]:
            actual = fn()
            try:
                return (actual > expected, actual)
            except TypeError:
                return (False, f"not comparable: {actual!r} > {expected!r}")

        self._run(condition, f"to be greater than {expected}", expected)

    def to_be_less_than(self, expected: Any) -> None:
        """Assert fn() < expected."""
        fn = self._fn

        def condition() -> tuple[bool, Any]:
            actual = fn()
            try:
                return (actual < expected, actual)
            except TypeError:
                return (False, f"not comparable: {actual!r} < {expected!r}")

        self._run(condition, f"to be less than {expected}", expected)

    def to_be_in_list(self, expected: list[Any]) -> None:
        """Assert fn() in expected."""
        fn = self._fn

        def condition() -> tuple[bool, Any]:
            actual = fn()
            return (actual in expected, actual)

        self._run(condition, f"to be in {expected!r}", expected)

    def to_have_length(self, expected: int) -> None:
        """Assert len(fn()) == expected."""
        fn = self._fn

        def condition() -> tuple[bool, Any]:
            actual = fn()
            try:
                actual_len = len(actual)
            except TypeError:
                return (False, f"no len() for {actual!r}")
            return (actual_len == expected, actual_len)

        self._run(condition, f"to have length {expected}", expected)

to_be_falsy ¶

to_be_falsy() -> None

Assert bool(fn()) is False.

Source code in selenium_expect/_poll.py

def to_be_falsy(self) -> None:
    """Assert bool(fn()) is False."""
    fn = self._fn

    def condition() -> tuple[bool, Any]:
        actual = fn()
        return (not bool(actual), actual)

    self._run(condition, "to be falsy", False)

to_be_greater_than ¶

to_be_greater_than(expected: Any) -> None

Assert fn() > expected.

Source code in selenium_expect/_poll.py

def to_be_greater_than(self, expected: Any) -> None:
    """Assert fn() > expected."""
    fn = self._fn

    def condition() -> tuple[bool, Any]:
        actual = fn()
        try:
            return (actual > expected, actual)
        except TypeError:
            return (False, f"not comparable: {actual!r} > {expected!r}")

    self._run(condition, f"to be greater than {expected}", expected)

to_be_in_list ¶

to_be_in_list(expected: list[Any]) -> None

Assert fn() in expected.

Source code in selenium_expect/_poll.py

def to_be_in_list(self, expected: list[Any]) -> None:
    """Assert fn() in expected."""
    fn = self._fn

    def condition() -> tuple[bool, Any]:
        actual = fn()
        return (actual in expected, actual)

    self._run(condition, f"to be in {expected!r}", expected)

to_be_less_than ¶

to_be_less_than(expected: Any) -> None

Assert fn() < expected.

Source code in selenium_expect/_poll.py

def to_be_less_than(self, expected: Any) -> None:
    """Assert fn() < expected."""
    fn = self._fn

    def condition() -> tuple[bool, Any]:
        actual = fn()
        try:
            return (actual < expected, actual)
        except TypeError:
            return (False, f"not comparable: {actual!r} < {expected!r}")

    self._run(condition, f"to be less than {expected}", expected)

to_be_none ¶

to_be_none() -> None

Assert fn() is None.

Source code in selenium_expect/_poll.py

def to_be_none(self) -> None:
    """Assert fn() is None."""
    fn = self._fn

    def condition() -> tuple[bool, Any]:
        actual = fn()
        return (actual is None, actual)

    self._run(condition, "to be None", None)

to_be_truthy ¶

to_be_truthy() -> None

Assert bool(fn()) is True.

Source code in selenium_expect/_poll.py

def to_be_truthy(self) -> None:
    """Assert bool(fn()) is True."""
    fn = self._fn

    def condition() -> tuple[bool, Any]:
        actual = fn()
        return (bool(actual), actual)

    self._run(condition, "to be truthy", True)

to_contain ¶

to_contain(expected: Any) -> None

Assert expected in fn().

Source code in selenium_expect/_poll.py

def to_contain(self, expected: Any) -> None:
    """Assert expected in fn()."""
    fn = self._fn

    def condition() -> tuple[bool, Any]:
        actual = fn()
        if actual is None:
            return (False, actual)
        try:
            return (expected in actual, actual)
        except TypeError:
            return (False, f"not iterable: {actual!r}")

    self._run(condition, f"to contain {expected!r}", expected)

to_equal ¶

to_equal(expected: Any) -> None

Assert fn() == expected.

Source code in selenium_expect/_poll.py

def to_equal(self, expected: Any) -> None:
    """Assert fn() == expected."""
    fn = self._fn

    def condition() -> tuple[bool, Any]:
        actual = fn()
        return (actual == expected, actual)

    self._run(condition, f"to equal {expected!r}", expected)

to_have_length ¶

to_have_length(expected: int) -> None

Assert len(fn()) == expected.

Source code in selenium_expect/_poll.py

def to_have_length(self, expected: int) -> None:
    """Assert len(fn()) == expected."""
    fn = self._fn

    def condition() -> tuple[bool, Any]:
        actual = fn()
        try:
            actual_len = len(actual)
        except TypeError:
            return (False, f"no len() for {actual!r}")
        return (actual_len == expected, actual_len)

    self._run(condition, f"to have length {expected}", expected)

to_match ¶

to_match(pattern: str) -> None

Assert re.search(pattern, str(fn())).

Source code in selenium_expect/_poll.py

def to_match(self, pattern: str) -> None:
    """Assert re.search(pattern, str(fn()))."""
    fn = self._fn

    def condition() -> tuple[bool, Any]:
        actual = fn()
        return (re.search(pattern, str(actual)) is not None, actual)

    self._run(condition, f"to match {pattern!r}", pattern)

`extend(name)`¶

Decorator to register a custom matcher under name.

Parameters¶

Parameter	Type	Description
`name`	`str`	Method name to register (e.g. `"to_be_in_viewport"`)

Matcher signature¶

def my_matcher(target: Any, *args, **kwargs) -> tuple[bool, Any]:
    ...
    return (passed, actual_value)

Example¶

from selenium_expect import extend

@extend("to_have_trimmed_text")
def check_trimmed_text(element, expected: str):
    actual = element.text.strip()
    return (actual == expected, actual)

# Usage
expect(element).to_have_trimmed_text("Hello!")
expect(element).not_.to_have_trimmed_text("  Hello!  ")

selenium_expect._matcher.extend ¶

extend(name: str) -> Callable[[_MatcherFn], _MatcherFn]

Decorator to register a custom matcher under name.

Usage::

@extend("to_be_in_viewport")
def check_in_viewport(element: Any) -> tuple[bool, Any]:
    ...
    return (passed, actual_value)

The matcher function receives the assertion's _target as its first argument and must return a (bool, Any) tuple where the bool indicates pass/fail and the Any is the actual value for error reporting.

Source code in selenium_expect/_matcher.py

def extend(name: str) -> Callable[[_MatcherFn], _MatcherFn]:
    """Decorator to register a custom matcher under *name*.

    Usage::

        @extend("to_be_in_viewport")
        def check_in_viewport(element: Any) -> tuple[bool, Any]:
            ...
            return (passed, actual_value)

    The matcher function receives the assertion's ``_target`` as its
    first argument and must return a ``(bool, Any)`` tuple where the
    bool indicates pass/fail and the Any is the actual value for
    error reporting.
    """

    def decorator(fn: Callable[..., tuple[bool, Any]]) -> Callable[..., tuple[bool, Any]]:
        CustomMatcherRegistry.register(name, fn)
        fn._selenium_expect_matcher = name  # type: ignore[attr-defined]
        return fn

    return decorator

`merge_expects(*modules)`¶

Combine custom matchers from multiple modules into the registry.

Parameters¶

Parameter	Type	Description
`*modules`	`ModuleType \\| str`	Modules or importable module paths

Example¶

from selenium_expect import merge_expects

# Pass module objects
import my_project.matchers
import my_project.custom_assertions
merge_expects(my_project.matchers, my_project.custom_assertions)

# Or pass importable strings
merge_expects("my_project.matchers", "my_project.custom_assertions")

selenium_expect._matcher.merge_expects ¶

merge_expects(*modules: ModuleType | str) -> list[str]

Combine custom matchers from multiple modules into the registry.

Each module should have used @extend to register matchers. Pass modules as objects or importable strings.

Usage::

import my_matchers
merge_expects(my_matchers)

# or by import path:
merge_expects("my_project.matchers")

Returns the list of newly registered matcher names.

Source code in selenium_expect/_matcher.py

def merge_expects(*modules: ModuleType | str) -> list[str]:
    """Combine custom matchers from multiple modules into the registry.

    Each module should have used ``@extend`` to register matchers.
    Pass modules as objects or importable strings.

    Usage::

        import my_matchers
        merge_expects(my_matchers)

        # or by import path:
        merge_expects("my_project.matchers")

    Returns the list of newly registered matcher names.
    """
    import importlib

    resolved: list[ModuleType] = []
    for mod in modules:
        if isinstance(mod, str):
            resolved.append(importlib.import_module(mod))
        else:
            resolved.append(mod)
    return CustomMatcherRegistry.merge_from(*resolved)

`SoftAssertionCollector`¶

Collects soft assertion failures for deferred raising.

Methods¶

Method	Description
`reset()`	Clear all collected failures
`get_failures()`	Return list of failure messages
`assert_all()`	Raise `AssertionError` if any failures, then reset

Example¶

from selenium_expect import expect, SoftAssertionCollector, assert_all

SoftAssertionCollector.reset()

expect(element).to_be_visible(soft=True)
expect(element).to_have_text("Hello", soft=True)

failures = SoftAssertionCollector.get_failures()
if failures:
    print(f"{len(failures)} failures collected")

assert_all()  # raises if any failures

selenium_expect._soft.SoftAssertionCollector ¶

Collects soft assertion failures for deferred raising.

Source code in selenium_expect/_soft.py

class SoftAssertionCollector:
    """Collects soft assertion failures for deferred raising."""

    _failures: ClassVar[list[str]] = []

    @classmethod
    def add_failure(cls, message: str) -> None:
        """Record a soft assertion failure."""
        cls._failures.append(message)

    @classmethod
    def get_failures(cls) -> list[str]:
        """Return all collected failures."""
        return list(cls._failures)

    @classmethod
    def reset(cls) -> None:
        """Clear all collected failures."""
        cls._failures.clear()

    @classmethod
    def assert_all(cls) -> None:
        """Raise ``AssertionError`` if any failures were collected, then reset."""
        if not cls._failures:
            return
        messages = list(cls._failures)
        cls.reset()
        combined = "\n---\n".join(messages)
        raise AssertionError(f"Soft assertion failures ({len(messages)}):\n{combined}")

add_failure `classmethod` ¶

add_failure(message: str) -> None

Record a soft assertion failure.

Source code in selenium_expect/_soft.py

@classmethod
def add_failure(cls, message: str) -> None:
    """Record a soft assertion failure."""
    cls._failures.append(message)

assert_all `classmethod` ¶

assert_all() -> None

Raise AssertionError if any failures were collected, then reset.

Source code in selenium_expect/_soft.py

@classmethod
def assert_all(cls) -> None:
    """Raise ``AssertionError`` if any failures were collected, then reset."""
    if not cls._failures:
        return
    messages = list(cls._failures)
    cls.reset()
    combined = "\n---\n".join(messages)
    raise AssertionError(f"Soft assertion failures ({len(messages)}):\n{combined}")

get_failures `classmethod` ¶

get_failures() -> list[str]

Return all collected failures.

Source code in selenium_expect/_soft.py

@classmethod
def get_failures(cls) -> list[str]:
    """Return all collected failures."""
    return list(cls._failures)

reset `classmethod` ¶

reset() -> None

Clear all collected failures.

Source code in selenium_expect/_soft.py

@classmethod
def reset(cls) -> None:
    """Clear all collected failures."""
    cls._failures.clear()

`assert_all()`¶

Raise AssertionError if any soft failures were collected, then reset.

Example¶

from selenium_expect import expect, assert_all

expect(element).to_be_visible(soft=True)
expect(element).to_have_text("Hello", soft=True)

assert_all()  # raises AssertionError with combined message if any failed

selenium_expect._soft.assert_all ¶

assert_all() -> None

Raise AssertionError if any soft failures were collected, then reset.

Convenience wrapper around SoftAssertionCollector.assert_all().

Source code in selenium_expect/_soft.py

def assert_all() -> None:
    """Raise ``AssertionError`` if any soft failures were collected, then reset.

    Convenience wrapper around ``SoftAssertionCollector.assert_all()``.
    """
    SoftAssertionCollector.assert_all()

Configuration setters¶

`set_default_timeout(seconds)`¶

Set the global default timeout for all assertions.

from selenium_expect import set_default_timeout

set_default_timeout(10)     # 10 seconds
set_default_timeout(5000)   # interpreted as 5000ms = 5 seconds (int >= 1000)

selenium_expect._config.set_default_timeout ¶

set_default_timeout(seconds: float) -> None

Set the default timeout for all expect assertions.

If seconds is an int >= 1000, it is interpreted as milliseconds (consistent with expect(timeout=...)).

Source code in selenium_expect/_config.py

def set_default_timeout(seconds: float) -> None:
    """Set the default timeout for all expect assertions.

    If *seconds* is an int >= 1000, it is interpreted as milliseconds
    (consistent with ``expect(timeout=...)``).
    """
    global _global_config
    _global_config = _global_config.replace(timeout=normalize_timeout(seconds))

`set_default_polling_interval(seconds)`¶

Set the global default polling interval (fixed).

from selenium_expect import set_default_polling_interval

set_default_polling_interval(0.25)

selenium_expect._config.set_default_polling_interval ¶

set_default_polling_interval(seconds: float) -> None

Set the default polling interval for all expect assertions.

Source code in selenium_expect/_config.py

def set_default_polling_interval(seconds: float) -> None:
    """Set the default polling interval for all expect assertions."""
    global _global_config
    _global_config = _global_config.replace(polling_interval=seconds)

`set_default_polling_intervals(intervals)`¶

Set a backoff schedule for polling. The list is cycled through during the retry loop.

from selenium_expect import set_default_polling_intervals

set_default_polling_intervals([0.1, 0.2, 0.5, 1.0])

selenium_expect._config.set_default_polling_intervals ¶

set_default_polling_intervals(intervals: list[float]) -> None

Set a backoff schedule for polling intervals.

Source code in selenium_expect/_config.py

def set_default_polling_intervals(intervals: list[float]) -> None:
    """Set a backoff schedule for polling intervals."""
    global _global_config
    _global_config = _global_config.replace(polling_intervals=intervals)

`set_screenshot_on_failure(enabled, path=None)`¶

Enable automatic screenshot capture on assertion failure.

from selenium_expect import set_screenshot_on_failure

set_screenshot_on_failure(True, path="./screenshots/")

selenium_expect._config.set_screenshot_on_failure ¶

set_screenshot_on_failure(enabled: bool, path: str | None = None) -> None

Enable or disable screenshot capture on assertion failure.

Source code in selenium_expect/_config.py

def set_screenshot_on_failure(enabled: bool, path: str | None = None) -> None:
    """Enable or disable screenshot capture on assertion failure."""
    global _global_config
    _global_config = _global_config.replace(
        screenshot_on_failure=enabled,
        screenshot_path=path if path is not None else "./screenshots/",
    )

`set_debug_mode(enabled)`¶

Enable debug logging for retry loops. Prints poll count, elapsed time, and actual values.

from selenium_expect import set_debug_mode

set_debug_mode(True)

selenium_expect._config.set_debug_mode ¶

set_debug_mode(enabled: bool) -> None

Enable or disable debug logging for retry loops.

Source code in selenium_expect/_config.py

def set_debug_mode(enabled: bool) -> None:
    """Enable or disable debug logging for retry loops."""
    global _global_config
    _global_config = _global_config.replace(debug_mode=enabled)

`get_config()`¶

Return the current global ExpectConfig instance.

from selenium_expect import get_config

config = get_config()
print(f"Timeout: {config.timeout}s, Polling: {config.polling_interval}s")

selenium_expect._config.get_config ¶

get_config() -> ExpectConfig

Return the current global config.

Source code in selenium_expect/_config.py

def get_config() -> ExpectConfig:
    """Return the current global config."""
    return _global_config

Assertion classes¶

`ExpectElement`¶

Assertions for WebElement objects. Provides methods for visibility, state, text, attributes, CSS, identity, position, accessibility, shadow DOM, and JavaScript properties.

Key method categories:

State: to_be_visible, to_be_hidden, to_be_present, to_be_enabled, to_be_disabled, to_be_selected, to_be_checked, to_be_clickable, to_be_stale
Text: to_have_text, to_have_text_contains, to_have_text_matches, to_have_trimmed_text
Attributes: to_have_attribute, to_have_attribute_present, to_have_attribute_absent, to_have_class, to_have_class_contain, to_have_id, to_have_value
CSS: to_have_css_property, to_have_css_value_contains
Identity: to_have_tag, to_have_role, to_have_aria_label, to_have_aria_describedby
Position: to_have_position, to_have_size, to_have_rect
Composition: to_satisfy_all, to_satisfy_any, to_satisfy_none