chore(deps): update dependency pytest-asyncio to ^0.23.0 #12
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This PR contains the following updates:
^0.18.1
->^0.23.0
Release Notes
pytest-dev/pytest-asyncio (pytest-asyncio)
v0.23.8
: pytest-asyncio 0.23.8Compare Source
0.23.8 (2024-07-17)
Known issues
As of v0.23, pytest-asyncio attaches an asyncio event loop to each item of the test suite (i.e. session, packages, modules, classes, functions) and allows tests to be run in those loops when marked accordingly. Pytest-asyncio currently assumes that async fixture scope is correlated with the new event loop scope. This prevents fixtures from being evaluated independently from the event loop scope and breaks some existing test suites (see #706). For example, a test suite may require all fixtures and tests to run in the same event loop, but have async fixtures that are set up and torn down for each module. If you're affected by this issue, please continue using the v0.21 release, until it is resolved.
v0.23.7
: pytest-asyncio 0.23.7Compare Source
0.23.7 (2024-05-19)
Known issues
As of v0.23, pytest-asyncio attaches an asyncio event loop to each item of the test suite (i.e. session, packages, modules, classes, functions) and allows tests to be run in those loops when marked accordingly. Pytest-asyncio currently assumes that async fixture scope is correlated with the new event loop scope. This prevents fixtures from being evaluated independently from the event loop scope and breaks some existing test suites (see #706). For example, a test suite may require all fixtures and tests to run in the same event loop, but have async fixtures that are set up and torn down for each module. If you're affected by this issue, please continue using the v0.21 release, until it is resolved.
v0.23.6
: pytest-asyncio 0.23.6Compare Source
0.23.6 (2024-03-19)
Known issues
As of v0.23, pytest-asyncio attaches an asyncio event loop to each item of the test suite (i.e. session, packages, modules, classes, functions) and allows tests to be run in those loops when marked accordingly. Pytest-asyncio currently assumes that async fixture scope is correlated with the new event loop scope. This prevents fixtures from being evaluated independently from the event loop scope and breaks some existing test suites (see #706). For example, a test suite may require all fixtures and tests to run in the same event loop, but have async fixtures that are set up and torn down for each module. If you're affected by this issue, please continue using the v0.21 release, until it is resolved.
v0.23.5
: pytest-asyncio 0.23.5Compare Source
0.23.5 (2024-02-09)
asyncio.get_event_loop()
from affecting test cases #757Known issues
As of v0.23, pytest-asyncio attaches an asyncio event loop to each item of the test suite (i.e. session, packages, modules, classes, functions) and allows tests to be run in those loops when marked accordingly. Pytest-asyncio currently assumes that async fixture scope is correlated with the new event loop scope. This prevents fixtures from being evaluated independently from the event loop scope and breaks some existing test suites (see #706). For example, a test suite may require all fixtures and tests to run in the same event loop, but have async fixtures that are set up and torn down for each module. If you're affected by this issue, please continue using the v0.21 release, until it is resolved.
v0.23.4
: pytest-asyncio 0.23.4Compare Source
0.23.4 (2024-01-28)
v0.23.3
: pytest-asyncio 0.23.3Compare Source
0.23.3 (2024-01-01)
Known issues
As of v0.23, pytest-asyncio attaches an asyncio event loop to each item of the test suite (i.e. session, packages, modules, classes, functions) and allows tests to be run in those loops when marked accordingly. Pytest-asyncio currently assumes that async fixture scope is correlated with the new event loop scope. This prevents fixtures from being evaluated independently from the event loop scope and breaks some existing test suites (see #706). For example, a test suite may require all fixtures and tests to run in the same event loop, but have async fixtures that are set up and torn down for each module. If you're affected by this issue, please continue using the v0.21 release, until it is resolved.
v0.23.2
: pytest-asyncio 0.23.2Compare Source
0.23.2 (2023-12-04)
v0.23.1
: pytest-asyncio 0.23.1Compare Source
0.23.1 (2023-12-03)
v0.23.0
: pytest-asyncio 0.23.0Compare Source
This release is backwards-compatible with v0.21. Changes are
non-breaking, unless you upgrade from v0.22.
loops with class, module, package, and session scopes can be
requested via the scope keyword argument to the asyncio
mark.
non-default or multiple event loops #662
pytest_asyncio.is_async_test
which returns whether atest item is managed by pytest-asyncio #376
dependencies #620, #674, #678
v0.22.0
: pytest-asyncio 0.22.0 (yanked)Compare Source
This release deprecated event loop overrides, but didn't provide adequate replacement functionality for all relevant use cases. As such, the release was yanked from PyPI.
0.22.0 (2023-10-31)
via the asyncio_event_loop mark. #620
Users requiring a class-scoped or module-scoped asyncio event loop for their tests
should mark the corresponding class or module with asyncio_event_loop.
v0.21.2
: pytest-asyncio 0.21.2Compare Source
0.21.2 (2024-04-29)
v0.21.1
: pytest-asyncio 0.21.1Compare Source
0.21.1 (2023-07-12)
asyncio_mode
is selected.#531
v0.21.0
: pytest-asyncio 0.21.0Compare Source
0.21.0 (23-03-19)
event_loop fixture. This behavior has been deprecated and pytest-asyncio emits a
DeprecationWarning when tearing down the event_loop fixture and current event loop
has not been closed.
v0.20.3
: pytest-asyncio 0.20.3Compare Source
title: 'pytest-asyncio'
pytest-asyncio is a
pytest plugin. It
facilitates testing of code that uses the
asyncio library.
Specifically, pytest-asyncio provides support for coroutines as test
functions. This allows users to await code inside their tests. For
example, the following code is executed as a test item by pytest:
Note that test classes subclassing the standard
unittest library are
not supported. Users are advised to use
unittest.IsolatedAsyncioTestCase
or an async framework such as
asynctest.
pytest-asyncio is available under the Apache License
2.0.
Installation
To install pytest-asyncio, simply:
This is enough for pytest to pick up pytest-asyncio.
Contributing
Contributions are very welcome. Tests can be run with
tox
, pleaseensure the coverage at least stays the same before you submit a pull
request.
v0.20.2
: pytest-asyncio 0.20.2Compare Source
title: 'pytest-asyncio: pytest support for asyncio'
pytest-asyncio is an Apache2 licensed library, written in Python, for
testing asyncio code with pytest.
asyncio code is usually written in the form of coroutines, which makes
it slightly more difficult to test using normal testing tools.
pytest-asyncio provides useful fixtures and markers to make testing
easier.
pytest-asyncio has been strongly influenced by
pytest-tornado.
Features
loop
fixtures
automatically by asyncio; provide strict mode if a test suite
should work with different async frameworks simultaneously, e.g.
asyncio
andtrio
.Installation
To install pytest-asyncio, simply:
This is enough for pytest to pick up pytest-asyncio.
Modes
Pytest-asyncio provides two modes: auto and strict with strict
mode being the default.
The mode can be set by
asyncio_mode
configuration option inconfiguration
file:
The value can be overridden by command-line option for
pytest
invocation:
Auto mode
When the mode is auto, all discovered async tests are considered
asyncio-driven even if they have no
@pytest.mark.asyncio
marker.All async fixtures are considered asyncio-driven as well, even if they
are decorated with a regular
@pytest.fixture
decorator instead ofdedicated
@pytest_asyncio.fixture
counterpart.asyncio-driven means that tests and fixtures are executed by
pytest-asyncio
plugin.This mode requires the simplest tests and fixtures configuration and is
recommended for default usage unless the same project and its test
suite should execute tests from different async frameworks, e.g.
asyncio
andtrio
. In this case, auto-handling can break testsdesigned for other framework; please use strict mode instead.
Strict mode
Strict mode enforces
@pytest.mark.asyncio
and@pytest_asyncio.fixture
usage. Without these markers, tests andfixtures are not considered as asyncio-driven, other pytest plugin can
handle them.
Please use this mode if multiple async frameworks should be combined in
the same test suite.
This mode is used by default for the sake of project
inter-compatibility.
Fixtures
event_loop
Creates a new asyncio event loop based on the current event loop policy.
The new loop is available as the return value of this fixture or via
asyncio.get_running_loop.
The event loop is closed when the fixture scope ends. The fixture scope
defaults to
function
scope.Note that just using the
event_loop
fixture won't make your testfunction a coroutine. You'll need to interact with the event loop
directly, using methods like
event_loop.run_until_complete
. See thepytest.mark.asyncio
marker for treating test functions likecoroutines.
The
event_loop
fixture can be overridden in any of the standard pytestlocations, e.g. directly in the test file, or in
conftest.py
. Thisallows redefining the fixture scope, for example:
If you need to change the type of the event loop, prefer setting a
custom event loop policy over redefining the
event_loop
fixture.If the
pytest.mark.asyncio
marker is applied to a test function, theevent_loop
fixture will be requested automatically by the testfunction.
unused_tcp_port
Finds and yields a single unused TCP port on the localhost interface.
Useful for binding temporary test servers.
unused_tcp_port_factory
A callable which returns a different unused TCP port each invocation.
Useful when several unused TCP ports are required in a test.
unused_udp_port
andunused_udp_port_factory
Work just like their TCP counterparts but return unused UDP ports.
Async fixtures
Asynchronous fixtures are defined just like ordinary pytest fixtures,
except they should be decorated with
@pytest_asyncio.fixture
.All scopes are supported, but if you use a non-function scope you will
need to redefine the
event_loop
fixture to have the same or broaderscope. Async fixtures need the event loop, and so must have the same or
narrower scope than the
event_loop
fixture.auto mode automatically converts async fixtures declared with the
standard
@pytest.fixture
decorator to asyncio-driven versions.Markers
pytest.mark.asyncio
Mark your test coroutine with this marker and pytest will execute it as
an asyncio task using the event loop provided by the
event_loop
fixture. See the introductory section for an example.
The event loop used can be overridden by overriding the
event_loop
fixture (see above).
In order to make your test code a little more concise, the pytest
pytestmark
_ feature can be used to mark entire modules or classeswith this marker. Only test coroutines will be affected (by default,
coroutines prefixed by
test_
), so, for example, fixtures are safe todefine.
In auto mode, the
pytest.mark.asyncio
marker can be omitted, themarker is added automatically to async test functions.
Note about unittest
Test classes subclassing the standard
unittest library are
not supported, users are recommended to use
unittest.IsolatedAsyncioTestCase
or an async framework such as
asynctest.
Contributing
Contributions are very welcome. Tests can be run with
tox
, pleaseensure the coverage at least stays the same before you submit a pull
request.
v0.20.1
: pytest-asyncio 0.20.1Compare Source
title: 'pytest-asyncio: pytest support for asyncio'
pytest-asyncio is an Apache2 licensed library, written in Python, for
testing asyncio code with pytest.
asyncio code is usually written in the form of coroutines, which makes
it slightly more difficult to test using normal testing tools.
pytest-asyncio provides useful fixtures and markers to make testing
easier.
pytest-asyncio has been strongly influenced by
pytest-tornado.
Features
loop
fixtures
automatically by asyncio; provide strict mode if a test suite
should work with different async frameworks simultaneously, e.g.
asyncio
andtrio
.Installation
To install pytest-asyncio, simply:
This is enough for pytest to pick up pytest-asyncio.
Modes
Pytest-asyncio provides two modes: auto and strict with strict
mode being the default.
The mode can be set by
asyncio_mode
configuration option inconfiguration
file:
The value can be overridden by command-line option for
pytest
invocation:
Auto mode
When the mode is auto, all discovered async tests are considered
asyncio-driven even if they have no
@pytest.mark.asyncio
marker.All async fixtures are considered asyncio-driven as well, even if they
are decorated with a regular
@pytest.fixture
decorator instead ofdedicated
@pytest_asyncio.fixture
counterpart.asyncio-driven means that tests and fixtures are executed by
pytest-asyncio
plugin.This mode requires the simplest tests and fixtures configuration and is
recommended for default usage unless the same project and its test
suite should execute tests from different async frameworks, e.g.
asyncio
andtrio
. In this case, auto-handling can break testsdesigned for other framework; please use strict mode instead.
Strict mode
Strict mode enforces
@pytest.mark.asyncio
and@pytest_asyncio.fixture
usage. Without these markers, tests andfixtures are not considered as asyncio-driven, other pytest plugin can
handle them.
Please use this mode if multiple async frameworks should be combined in
the same test suite.
This mode is used by default for the sake of project
inter-compatibility.
Fixtures
event_loop
Creates a new asyncio event loop based on the current event loop policy.
The new loop is available as the return value of this fixture or via
asyncio.get_running_loop.
The event loop is closed when the fixture scope ends. The fixture scope
defaults to
function
scope.Note that just using the
event_loop
fixture won't make your testfunction a coroutine. You'll need to interact with the event loop
directly, using methods like
event_loop.run_until_complete
. See thepytest.mark.asyncio
marker for treating test functions likecoroutines.
The
event_loop
fixture can be overridden in any of the standard pytestlocations, e.g. directly in the test file, or in
conftest.py
. Thisallows redefining the fixture scope, for example:
If you need to change the type of the event loop, prefer setting a
custom event loop policy over redefining the
event_loop
fixture.If the
pytest.mark.asyncio
marker is applied to a test function, theevent_loop
fixture will be requested automatically by the testfunction.
unused_tcp_port
Finds and yields a single unused TCP port on the localhost interface.
Useful for binding temporary test servers.
unused_tcp_port_factory
A callable which returns a different unused TCP port each invocation.
Useful when several unused TCP ports are required in a test.
unused_udp_port
andunused_udp_port_factory
Work just like their TCP counterparts but return unused UDP ports.
Async fixtures
Asynchronous fixtures are defined just like ordinary pytest fixtures,
except they should be decorated with
@pytest_asyncio.fixture
.All scopes are supported, but if you use a non-function scope you will
need to redefine the
event_loop
fixture to have the same or broaderscope. Async fixtures need the event loop, and so must have the same or
narrower scope than the
event_loop
fixture.auto mode automatically converts async fixtures declared with the
standard
@pytest.fixture
decorator to asyncio-driven versions.Markers
pytest.mark.asyncio
Mark your test coroutine with this marker and pytest will execute it as
an asyncio task using the event loop provided by the
event_loop
fixture. See the introductory section for an example.
The event loop used can be overridden by overriding the
event_loop
fixture (see above).
In order to make your test code a little more concise, the pytest
pytestmark
_ feature can be used to mark entire modules or classeswith this marker. Only test coroutines will be affected (by default,
coroutines prefixed by
test_
), so, for example, fixtures are safe todefine.
In auto mode, the
pytest.mark.asyncio
marker can be omitted, themarker is added automatically to async test functions.
Note about unittest
Test classes subclassing the standard
unittest library are
not supported, users are recommended to use
unittest.IsolatedAsyncioTestCase
or an async framework such as
asynctest.
Contributing
Contributions are very welcome. Tests can be run with
tox
, pleaseensure the coverage at least stays the same before you submit a pull
request.
v0.20.0
: pytest-asyncio 0.20.0Compare Source
title: 'pytest-asyncio: pytest support for asyncio'
pytest-asyncio is an Apache2 licensed library, written in Python, for
testing asyncio code with pytest.
asyncio code is usually written in the form of coroutines, which makes
it slightly more difficult to test using normal testing tools.
pytest-asyncio provides useful fixtures and markers to make testing
easier.
pytest-asyncio has been strongly influenced by
pytest-tornado.
Features
loop
fixtures
automatically by asyncio; provide strict mode if a test suite
should work with different async frameworks simultaneously, e.g.
asyncio
andtrio
.Installation
To install pytest-asyncio, simply:
This is enough for pytest to pick up pytest-asyncio.
Modes
Pytest-asyncio provides two modes: auto and strict with strict
mode being the default.
The mode can be set by
asyncio_mode
configuration option inconfiguration
file:
The value can be overridden by command-line option for
pytest
invocation:
Auto mode
When the mode is auto, all discovered async tests are considered
asyncio-driven even if they have no
@pytest.mark.asyncio
marker.All async fixtures are considered asyncio-driven as well, even if they
are decorated with a regular
@pytest.fixture
decorator instead ofdedicated
@pytest_asyncio.fixture
counterpart.asyncio-driven means that tests and fixtures are executed by
pytest-asyncio
plugin.This mode requires the simplest tests and fixtures configuration and is
recommended for default usage unless the same project and its test
suite should execute tests from different async frameworks, e.g.
asyncio
andtrio
. In this case, auto-handling can break testsdesigned for other framework; please use strict mode instead.
Strict mode
Strict mode enforces
@pytest.mark.asyncio
and@pytest_asyncio.fixture
usage. Without these markers, tests andfixtures are not considered as asyncio-driven, other pytest plugin can
handle them.
Please use this mode if multiple async frameworks should be combined in
the same test suite.
This mode is used by default for the sake of project
inter-compatibility.
Fixtures
event_loop
Creates a new asyncio event loop based on the current event loop policy.
The new loop is available as the return value of this fixture or via
asyncio.get_running_loop.
The event loop is closed when the fixture scope ends. The fixture scope
defaults to
function
scope.Note that just using the
event_loop
fixture won't make your testfunction a coroutine. You'll need to interact with the event loop
directly, using methods like
event_loop.run_until_complete
. See thepytest.mark.asyncio
marker for treating test functions likecoroutines.
The
event_loop
fixture can be overridden in any of the standard pytestlocations, e.g. directly in the test file, or in
conftest.py
. Thisallows redefining the fixture scope, for example:
If you need to change the type of the event loop, prefer setting a
custom event loop policy over redefining the
event_loop
fixture.If the
pytest.mark.asyncio
marker is applied to a test function, theevent_loop
fixture will be requested automatically by the testfunction.
unused_tcp_port
Finds and yields a single unused TCP port on the localhost interface.
Useful for binding temporary test servers.
unused_tcp_port_factory
A callable which returns a different unused TCP port each invocation.
Useful when several unused TCP ports are required in a test.
unused_udp_port
andunused_udp_port_factory
Work just like their TCP counterparts but return unused UDP ports.
Async fixtures
Asynchronous fixtures are defined just like ordinary pytest fixtures,
except they should be decorated with
@pytest_asyncio.fixture
.All scopes are supported, but if you use a non-function scope you will
need to redefine the
event_loop
fixture to have the same or broaderscope. Async fixtures need the event loop, and so must have the same or
narrower scope than the
event_loop
fixture.auto mode automatically converts async fixtures declared with the
standard
@pytest.fixture
decorator to asyncio-driven versions.Markers
pytest.mark.asyncio
Mark your test coroutine with this marker and pytest will execute it as
an asyncio task using the event loop provided by the
event_loop
fixture. See the introductory section for an example.
The event loop used can be overridden by overriding the
event_loop
fixture (see above).
In order to make your test code a little more concise, the pytest
pytestmark
_ feature can be used to mark entire modules or classeswith this marker. Only test coroutines will be affected (by default,
coroutines prefixed by
test_
), so, for example, fixtures are safe todefine.
In auto mode, the
pytest.mark.asyncio
marker can be omitted, themarker is added automatically to async test functions.
Note about unittest
Test classes subclassing the standard
unittest library are
not supported, users are recommended to use
unittest.IsolatedAsyncioTestCase
or an async framework such as
asynctest.
Contributing
Contributions are very welcome. Tests can be run with
tox
, pleaseensure the coverage at least stays the same before you submit a pull
request.
v0.19.0
: pytest-asyncio 0.19.0Compare Source
title: 'pytest-asyncio: pytest support for asyncio'
pytest-asyncio is an Apache2 licensed library, written in Python, for
testing asyncio code with pytest.
asyncio code is usually written in the form of coroutines, which makes
it slightly more difficult to test using normal testing tools.
pytest-asyncio provides useful fixtures and markers to make testing
easier.
pytest-asyncio has been strongly influenced by
pytest-tornado.
Features
loop
fixtures
automatically by asyncio; provide strict mode if a test suite
should work with different async frameworks simultaneously, e.g.
asyncio
andtrio
.Installation
To install pytest-asyncio, simply:
This is enough for pytest to pick up pytest-asyncio.
Modes
Starting from
pytest-asyncio>=0.17
, three modes are provided: auto,strict and legacy. Starting from
pytest-asyncio>=0.19
the strictmode is the default.
The mode can be set by
asyncio_mode
configuration option inconfiguration
file:
The value can be overridden by command-line option for
pytest
invocation:
Auto mode
When the mode is auto, all discovered async tests are considered
asyncio-driven even if they have no
@pytest.mark.asyncio
marker.All async fixtures are considered asyncio-driven as well, even if they
are decorated with a regular
@pytest.fixture
decorator instead ofdedicated
@pytest_asyncio.fixture
counterpart.asyncio-driven means that tests and fixtures are executed by
pytest-asyncio
plugin.This mode requires the simplest tests and fixtures configuration and is
recommended for default usage unless the same project and its test
suite should execute tests from different async frameworks, e.g.
asyncio
andtrio
. In this case, auto-handling can break testsdesigned for other framework; please use strict mode instead.
Strict mode
Strict mode enforces
@pytest.mark.asyncio
and@pytest_asyncio.fixture
usage. Without these markers, tests andfixtures are not considered as asyncio-driven, other pytest plugin can
handle them.
Please use this mode if multiple async frameworks should be combined in
the same test suite.
This mode is used by default for the sake of project
inter-compatibility.
Legacy mode
This mode follows rules used by
pytest-asyncio<0.17
: tests are notauto-marked but fixtures are.
Deprecation warnings are emitted with suggestion to either switching to
auto
mode or usingstrict
mode with@pytest_asyncio.fixture
decorators.
The default was changed to
strict
inpytest-asyncio>=0.19
.Fixtures
event_loop
Creates a new asyncio event loop based on the current event loop policy.
The new loop is available as the return value of this fixture or via
asyncio.get_running_loop.
The event loop is closed when the fixture scope ends. The fixture scope
defaults to
function
scope.Note that just using the
event_loop
fixture won't make your testfunction a coroutine. You'll need to interact with the event loop
directly, using methods like
event_loop.run_until_complete
. See thepytest.mark.asyncio
marker for treating test functions likecoroutines.
The
event_loop
fixture can be overridden in any of the standard pytestlocations, e.g. directly in the test file, or in
conftest.py
. Thisallows redefining the fixture scope, for example:
If you need to change the type of the event loop, prefer setting a
custom event loop policy over redefining the
event_loop
fixture.If the
pytest.mark.asyncio
marker is applied to a test function, theevent_loop
fixture will be requested automatically by the testfunction.
unused_tcp_port
Finds and yields a single unused TCP port on the localhost interface.
Useful for binding temporary test servers.
unused_tcp_port_factory
A callable which returns a different unused TCP port each invocation.
Useful when several unused TCP ports are required in a test.
unused_udp_port
andunused_udp_port_factory
Work just like their TCP counterparts but return unused UDP ports.
Async fixtures
Asynchronous fixtures are defined just like ordinary pytest fixtures,
except they should be decorated with
@pytest_asyncio.fixture
.All scopes are supported, but if you use a non-function scope you will
need to redefine the
event_loop
fixture to have the same or broaderscope. Async fixtures need the event loop, and so must have the same or
narrower scope than the
event_loop
fixture.auto and legacy mode automatically converts async fixtures declared
with the standard
@pytest.fixture
decorator to asyncio-drivenversions.
Markers
pytest.mark.asyncio
Mark your test coroutine with this marker and pytest will execute it as
an asyncio task using the event loop provided by the
event_loop
fixture. See the introductory section for an example.
The event loop used can be overridden by overriding the
event_loop
fixture (see above).
In order to make your test code a little more concise, the pytest
pytestmark
_ feature can be used to mark entire modules or classeswith this marker. Only test coroutines will be affected (by default,
coroutines prefixed by
test_
), so, for example, fixtures are safe todefine.
In auto mode, the
pytest.mark.asyncio
marker can be omitted, themarker is added automatically to async test functions.
Note about unittest
Test classes subclassing the standard
unittest library are
not supported, users are recommended to use
unittest.IsolatedAsyncioTestCase
or an async framework such as
asynctest.
Contributing
Contributions are very welcome. Tests can be run with
tox
, pleaseensure the coverage at least stays the same before you submit a pull
request.
Configuration
📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).
🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.
♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.
🔕 Ignore: Close this PR and you won't be reminded about this update again.
This PR was generated by Mend Renovate. View the repository job log.