cleanup: remove venv from image repo

venv/.gitignore

@@ -1,2 +0,0 @@
-# Created by venv; see https://docs.python.org/3/library/venv.html
-*

venv/Lib/site-packages/PySocks-1.7.1.dist-info/INSTALLER

@@ -1 +0,0 @@
-pip

venv/Lib/site-packages/PySocks-1.7.1.dist-info/LICENSE

@@ -1,22 +0,0 @@
-Copyright 2006 Dan-Haim. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-3. Neither the name of Dan Haim nor the names of his contributors may be used
-   to endorse or promote products derived from this software without specific
-   prior written permission.
-   
-THIS SOFTWARE IS PROVIDED BY DAN HAIM "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-EVENT SHALL DAN HAIM OR HIS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA
-OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
-OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMANGE.

venv/Lib/site-packages/PySocks-1.7.1.dist-info/METADATA

@@ -1,321 +0,0 @@
-Metadata-Version: 2.1
-Name: PySocks
-Version: 1.7.1
-Summary: A Python SOCKS client module. See https://github.com/Anorov/PySocks for more information.
-Home-page: https://github.com/Anorov/PySocks
-Author: Anorov
-Author-email: anorov.vorona@gmail.com
-License: BSD
-Keywords: socks,proxy
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
-Description-Content-Type: text/markdown
-
-PySocks
-=======
-
-PySocks lets you send traffic through SOCKS and HTTP proxy servers. It is a modern fork of [SocksiPy](http://socksipy.sourceforge.net/) with bug fixes and extra features.
-
-Acts as a drop-in replacement to the socket module. Seamlessly configure SOCKS proxies for any socket object by calling `socket_object.set_proxy()`.
-
-----------------
-
-Features
-========
-
-* SOCKS proxy client for Python 2.7 and 3.4+
-* TCP supported
-* UDP mostly supported (issues may occur in some edge cases)
-* HTTP proxy client included but not supported or recommended (you should use urllib2's or requests' own HTTP proxy interface)
-* urllib2 handler included. `pip install` / `setup.py install` will automatically install the `sockshandler` module.
-
-Installation
-============
-
-    pip install PySocks
-
-Or download the tarball / `git clone` and...
-
-    python setup.py install
-
-These will install both the `socks` and `sockshandler` modules.
-
-Alternatively, include just `socks.py` in your project.
-
---------------------------------------------
-
-*Warning:* PySocks/SocksiPy only supports HTTP proxies that use CONNECT tunneling. Certain HTTP proxies may not work with this library. If you wish to use HTTP (not SOCKS) proxies, it is recommended that you rely on your HTTP client's native proxy support (`proxies` dict for `requests`, or `urllib2.ProxyHandler` for `urllib2`) instead.
-
---------------------------------------------
-
-Usage
-=====
-
-## socks.socksocket ##
-
-    import socks
-
-    s = socks.socksocket() # Same API as socket.socket in the standard lib
-
-    s.set_proxy(socks.SOCKS5, "localhost") # SOCKS4 and SOCKS5 use port 1080 by default
-    # Or
-    s.set_proxy(socks.SOCKS4, "localhost", 4444)
-    # Or
-    s.set_proxy(socks.HTTP, "5.5.5.5", 8888)
-
-    # Can be treated identical to a regular socket object
-    s.connect(("www.somesite.com", 80))
-    s.sendall("GET / HTTP/1.1 ...")
-    print s.recv(4096)
-
-## Monkeypatching ##
-
-To monkeypatch the entire standard library with a single default proxy:
-
-    import urllib2
-    import socket
-    import socks
-
-    socks.set_default_proxy(socks.SOCKS5, "localhost")
-    socket.socket = socks.socksocket
-
-    urllib2.urlopen("http://www.somesite.com/") # All requests will pass through the SOCKS proxy
-
-Note that monkeypatching may not work for all standard modules or for all third party modules, and generally isn't recommended. Monkeypatching is usually an anti-pattern in Python.
-
-## urllib2 Handler ##
-
-Example use case with the `sockshandler` urllib2 handler. Note that you must import both `socks` and `sockshandler`, as the handler is its own module separate from PySocks. The module is included in the PyPI package.
-
-    import urllib2
-    import socks
-    from sockshandler import SocksiPyHandler
-
-    opener = urllib2.build_opener(SocksiPyHandler(socks.SOCKS5, "127.0.0.1", 9050))
-    print opener.open("http://www.somesite.com/") # All requests made by the opener will pass through the SOCKS proxy
-
---------------------------------------------
-
-Original SocksiPy README attached below, amended to reflect API changes.
-
---------------------------------------------
-
-SocksiPy
-
-A Python SOCKS module.
-
-(C) 2006 Dan-Haim. All rights reserved.
-
-See LICENSE file for details.
-
-
-*WHAT IS A SOCKS PROXY?*
-
-A SOCKS proxy is a proxy server at the TCP level. In other words, it acts as
-a tunnel, relaying all traffic going through it without modifying it.
-SOCKS proxies can be used to relay traffic using any network protocol that
-uses TCP.
-
-*WHAT IS SOCKSIPY?*
-
-This Python module allows you to create TCP connections through a SOCKS
-proxy without any special effort.
-It also supports relaying UDP packets with a SOCKS5 proxy.
-
-*PROXY COMPATIBILITY*
-
-SocksiPy is compatible with three different types of proxies:
-
-1. SOCKS Version 4 (SOCKS4), including the SOCKS4a extension.
-2. SOCKS Version 5 (SOCKS5).
-3. HTTP Proxies which support tunneling using the CONNECT method.
-
-*SYSTEM REQUIREMENTS*
-
-Being written in Python, SocksiPy can run on any platform that has a Python
-interpreter and TCP/IP support.
-This module has been tested with Python 2.3 and should work with greater versions
-just as well.
-
-
-INSTALLATION
--------------
-
-Simply copy the file "socks.py" to your Python's `lib/site-packages` directory,
-and you're ready to go. [Editor's note: it is better to use `python setup.py install` for PySocks]
-
-
-USAGE
-------
-
-First load the socks module with the command:
-
-    >>> import socks
-    >>>
-
-The socks module provides a class called `socksocket`, which is the base to all of the module's functionality.
-
-The `socksocket` object has the same initialization parameters as the normal socket
-object to ensure maximal compatibility, however it should be noted that `socksocket` will only function with family being `AF_INET` and
-type being either `SOCK_STREAM` or `SOCK_DGRAM`.
-Generally, it is best to initialize the `socksocket` object with no parameters
-
-    >>> s = socks.socksocket()
-    >>>
-
-The `socksocket` object has an interface which is very similiar to socket's (in fact
-the `socksocket` class is derived from socket) with a few extra methods.
-To select the proxy server you would like to use, use the `set_proxy` method, whose
-syntax is:
-
-    set_proxy(proxy_type, addr[, port[, rdns[, username[, password]]]])
-
-Explanation of the parameters:
-
-`proxy_type` - The type of the proxy server. This can be one of three possible
-choices: `PROXY_TYPE_SOCKS4`, `PROXY_TYPE_SOCKS5` and `PROXY_TYPE_HTTP` for SOCKS4,
-SOCKS5 and HTTP servers respectively. `SOCKS4`, `SOCKS5`, and `HTTP` are all aliases, respectively.
-
-`addr` - The IP address or DNS name of the proxy server.
-
-`port` - The port of the proxy server. Defaults to 1080 for socks and 8080 for http.
-
-`rdns` - This is a boolean flag than modifies the behavior regarding DNS resolving.
-If it is set to True, DNS resolving will be preformed remotely, on the server.
-If it is set to False, DNS resolving will be preformed locally. Please note that
-setting this to True with SOCKS4 servers actually use an extension to the protocol,
-called SOCKS4a, which may not be supported on all servers (SOCKS5 and http servers
-always support DNS). The default is True.
-
-`username` - For SOCKS5 servers, this allows simple username / password authentication
-with the server. For SOCKS4 servers, this parameter will be sent as the userid.
-This parameter is ignored if an HTTP server is being used. If it is not provided,
-authentication will not be used (servers may accept unauthenticated requests).
-
-`password` - This parameter is valid only for SOCKS5 servers and specifies the
-respective password for the username provided.
-
-Example of usage:
-
-    >>> s.set_proxy(socks.SOCKS5, "socks.example.com") # uses default port 1080
-    >>> s.set_proxy(socks.SOCKS4, "socks.test.com", 1081)
-
-After the set_proxy method has been called, simply call the connect method with the
-traditional parameters to establish a connection through the proxy:
-
-    >>> s.connect(("www.sourceforge.net", 80))
-    >>>
-
-Connection will take a bit longer to allow negotiation with the proxy server.
-Please note that calling connect without calling `set_proxy` earlier will connect
-without a proxy (just like a regular socket).
-
-Errors: Any errors in the connection process will trigger exceptions. The exception
-may either be generated by the underlying socket layer or may be custom module
-exceptions, whose details follow:
-
-class `ProxyError` - This is a base exception class. It is not raised directly but
-rather all other exception classes raised by this module are derived from it.
-This allows an easy way to catch all proxy-related errors. It descends from `IOError`.
-
-All `ProxyError` exceptions have an attribute `socket_err`, which will contain either a
-caught `socket.error` exception, or `None` if there wasn't any.
-
-class `GeneralProxyError` - When thrown, it indicates a problem which does not fall
-into another category.
-
-* `Sent invalid data` - This error means that unexpected data has been received from
-the server. The most common reason is that the server specified as the proxy is
-not really a SOCKS4/SOCKS5/HTTP proxy, or maybe the proxy type specified is wrong.
-
-* `Connection closed unexpectedly` - The proxy server unexpectedly closed the connection.
-This may indicate that the proxy server is experiencing network or software problems.
-
-* `Bad proxy type` - This will be raised if the type of the proxy supplied to the
-set_proxy function was not one of `SOCKS4`/`SOCKS5`/`HTTP`.
-
-* `Bad input` - This will be raised if the `connect()` method is called with bad input
-parameters.
-
-class `SOCKS5AuthError` - This indicates that the connection through a SOCKS5 server
-failed due to an authentication problem.
-
-* `Authentication is required` - This will happen if you use a SOCKS5 server which
-requires authentication without providing a username / password at all.
-
-* `All offered authentication methods were rejected` - This will happen if the proxy
-requires a special authentication method which is not supported by this module.
-
-* `Unknown username or invalid password` - Self descriptive.
-
-class `SOCKS5Error` - This will be raised for SOCKS5 errors which are not related to
-authentication.
-The parameter is a tuple containing a code, as given by the server,
-and a description of the
-error. The possible errors, according to the RFC, are:
-
-* `0x01` - General SOCKS server failure - If for any reason the proxy server is unable to
-fulfill your request (internal server error).
-* `0x02` - connection not allowed by ruleset - If the address you're trying to connect to
-is blacklisted on the server or requires authentication.
-* `0x03` - Network unreachable - The target could not be contacted. A router on the network
-had replied with a destination net unreachable error.
-* `0x04` - Host unreachable - The target could not be contacted. A router on the network
-had replied with a destination host unreachable error.
-* `0x05` - Connection refused - The target server has actively refused the connection
-(the requested port is closed).
-* `0x06` - TTL expired - The TTL value of the SYN packet from the proxy to the target server
-has expired. This usually means that there are network problems causing the packet
-to be caught in a router-to-router "ping-pong".
-* `0x07` - Command not supported - For instance if the server does not support UDP.
-* `0x08` - Address type not supported - The client has provided an invalid address type.
-When using this module, this error should not occur.
-
-class `SOCKS4Error` - This will be raised for SOCKS4 errors. The parameter is a tuple
-containing a code and a description of the error, as given by the server. The
-possible error, according to the specification are:
-
-* `0x5B` - Request rejected or failed - Will be raised in the event of an failure for any
-reason other then the two mentioned next.
-* `0x5C` - request rejected because SOCKS server cannot connect to identd on the client -
-The Socks server had tried an ident lookup on your computer and has failed. In this
-case you should run an identd server and/or configure your firewall to allow incoming
-connections to local port 113 from the remote server.
-* `0x5D` - request rejected because the client program and identd report different user-ids -
-The Socks server had performed an ident lookup on your computer and has received a
-different userid than the one you have provided. Change your userid (through the
-username parameter of the set_proxy method) to match and try again.
-
-class `HTTPError` - This will be raised for HTTP errors. The message will contain
-the HTTP status code and provided error message.
-
-After establishing the connection, the object behaves like a standard socket.
-
-Methods like `makefile()` and `settimeout()` should behave just like regular sockets.
-Call the `close()` method to close the connection.
-
-In addition to the `socksocket` class, an additional function worth mentioning is the
-`set_default_proxy` function. The parameters are the same as the `set_proxy` method.
-This function will set default proxy settings for newly created `socksocket` objects,
-in which the proxy settings haven't been changed via the `set_proxy` method.
-This is quite useful if you wish to force 3rd party modules to use a SOCKS proxy,
-by overriding the socket object.
-For example:
-
-    >>> socks.set_default_proxy(socks.SOCKS5, "socks.example.com")
-    >>> socket.socket = socks.socksocket
-    >>> urllib.urlopen("http://www.sourceforge.net/")
-
-
-PROBLEMS
----------
-
-Please open a GitHub issue at https://github.com/Anorov/PySocks
-
-

venv/Lib/site-packages/PySocks-1.7.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-PySocks-1.7.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-PySocks-1.7.1.dist-info/LICENSE,sha256=cCfiFOAU63i3rcwc7aWspxOnn8T2oMUsnaWz5wfm_-k,1401
-PySocks-1.7.1.dist-info/METADATA,sha256=zbQMizjPOOP4DhEiEX24XXjNrYuIxF9UGUpN0uFDB6Y,13235
-PySocks-1.7.1.dist-info/RECORD,,
-PySocks-1.7.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-PySocks-1.7.1.dist-info/WHEEL,sha256=t_MpApv386-8PVts2R6wsTifdIn0vbUDTVv61IbqFC8,92
-PySocks-1.7.1.dist-info/top_level.txt,sha256=TKSOIfCFBoK9EY8FBYbYqC3PWd3--G15ph9n8-QHPDk,19
-__pycache__/socks.cpython-314.pyc,,
-__pycache__/sockshandler.cpython-314.pyc,,
-socks.py,sha256=xOYn27t9IGrbTBzWsUUuPa0YBuplgiUykzkOB5V5iFY,31086
-sockshandler.py,sha256=2SYGj-pwt1kjgLoZAmyeaEXCeZDWRmfVS_QG6kErGtY,3966

venv/Lib/site-packages/PySocks-1.7.1.dist-info/WHEEL

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

venv/Lib/site-packages/PySocks-1.7.1.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-socks
-sockshandler

venv/Lib/site-packages/StrEnum-0.4.15.dist-info/INSTALLER

@@ -1 +0,0 @@
-pip

venv/Lib/site-packages/StrEnum-0.4.15.dist-info/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2019 James C Sinclair
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

venv/Lib/site-packages/StrEnum-0.4.15.dist-info/METADATA

@@ -1,211 +0,0 @@
-Metadata-Version: 2.1
-Name: StrEnum
-Version: 0.4.15
-Summary: An Enum that inherits from str.
-Home-page: https://github.com/irgeek/StrEnum
-Author: James Sinclair
-Author-email: james@nurfherder.com
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Provides-Extra: docs
-Requires-Dist: sphinx ; extra == 'docs'
-Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
-Requires-Dist: myst-parser[linkify] ; extra == 'docs'
-Provides-Extra: release
-Requires-Dist: twine ; extra == 'release'
-Provides-Extra: test
-Requires-Dist: pytest ; extra == 'test'
-Requires-Dist: pytest-black ; extra == 'test'
-Requires-Dist: pytest-cov ; extra == 'test'
-Requires-Dist: pytest-pylint ; extra == 'test'
-Requires-Dist: pylint ; extra == 'test'
-
-# StrEnum
-
-[![Build Status](https://github.com/irgeek/StrEnum/workflows/Python%20package/badge.svg)](https://github.com/irgeek/StrEnum/actions)
-
-StrEnum is a Python `enum.Enum` that inherits from `str` to complement
-`enum.IntEnum` in the standard library. Supports python 3.7+.
-
-## Installation
-
-You can use [pip](https://pip.pypa.io/en/stable/) to install.
-
-```bash
-pip install StrEnum
-```
-
-## Usage
-
-```python
-from enum import auto
-from strenum import StrEnum
-
-
-class HttpMethod(StrEnum):
-    GET = auto()
-    HEAD = auto()
-    POST = auto()
-    PUT = auto()
-    DELETE = auto()
-    CONNECT = auto()
-    OPTIONS = auto()
-    TRACE = auto()
-    PATCH = auto()
-
-
-assert HttpMethod.GET == "GET"
-
-# You can use StrEnum values just like strings:
-
-import urllib.request
-
-req = urllib.request.Request('https://www.python.org/', method=HttpMethod.HEAD)
-with urllib.request.urlopen(req) as response:
-    html = response.read()
-
-assert len(html) == 0  # HEAD requests do not (usually) include a body
-```
-
-There are classes whose `auto()` value folds each member name to upper or lower
-case:
-
-```python
-from enum import auto
-from strenum import LowercaseStrEnum, UppercaseStrEnum
-
-
-class Tag(LowercaseStrEnum):
-    Head = auto()
-    Body = auto()
-    Div = auto()
-
-
-assert Tag.Head == "head"
-assert Tag.Body == "body"
-assert Tag.Div == "div"
-
-
-class HttpMethod(UppercaseStrEnum):
-    Get = auto()
-    Head = auto()
-    Post = auto()
-
-
-assert HttpMethod.Get == "GET"
-assert HttpMethod.Head == "HEAD"
-assert HttpMethod.Post == "POST"
-```
-
-As well as classes whose `auto()` value converts each member name to camelCase,
-PascalCase, kebab-case, snake_case and MACRO_CASE:
-
-```python
-from enum import auto
-from strenum import CamelCaseStrEnum, PascalCaseStrEnum
-from strenum import KebabCaseStrEnum, SnakeCaseStrEnum
-from strenum import MacroCaseStrEnum
-
-
-class CamelTestEnum(CamelCaseStrEnum):
-    OneTwoThree = auto()
-
-
-class PascalTestEnum(PascalCaseStrEnum):
-    OneTwoThree = auto()
-
-
-class KebabTestEnum(KebabCaseStrEnum):
-    OneTwoThree = auto()
-
-
-class SnakeTestEnum(SnakeCaseStrEnum):
-    OneTwoThree = auto()
-
-
-class MacroTestEnum(MacroCaseStrEnum):
-    OneTwoThree = auto()
-
-
-assert CamelTestEnum.OneTwoThree == "oneTwoThree"
-assert PascalTestEnum.OneTwoThree == "OneTwoThree"
-assert KebabTestEnum.OneTwoThree == "one-two-three"
-assert SnakeTestEnum.OneTwoThree == "one_two_three"
-assert MacroTestEnum.OneTwoThree == "ONE_TWO_THREE"
-```
-
-As with any Enum you can, of course, manually assign values.
-
-```python
-from strenum import StrEnum
-
-
-class Shape(StrEnum):
-    CIRCLE = "Circle"
-
-
-assert Shape.CIRCLE == "Circle"
-```
-
-Doing this with the case-changing classes, though, won't manipulate
-values--whatever you assign is the value they end up with.
-
-```python
-from strenum import KebabCaseStrEnum
-
-
-class Shape(KebabCaseStrEnum):
-    CIRCLE = "Circle"
-
-
-# This will raise an AssertionError because the value wasn't converted to kebab-case.
-assert Shape.CIRCLE == "circle"
-```
-
-## Contributing
-
-Pull requests are welcome. For major changes, please open an issue first to
-discuss what you would like to change.
-
-Please ensure tests pass before submitting a PR. This repository uses
-[Black](https://black.readthedocs.io/en/stable/) and
-[Pylint](https://www.pylint.org/) for consistency. Both are run automatically
-as part of the test suite.
-
-## Running the tests
-
-Tests can be run using `make`:
-
-```
-make test
-```
-
-This will create a virutal environment, install the module and its test
-dependencies and run the tests. Alternatively you can do the same thing
-manually:
-
-```
-python3 -m venv .venv
-.venv/bin/pip install .[test]
-.venv/bin/pytest
-```
-
-## License
-
-[MIT](https://choosealicense.com/licenses/mit/)
-
-**N.B. Starting with Python 3.11, `enum.StrEnum` is available in the standard
-library. This implementation is _not_ a drop-in replacement for the standard
-library implementation. Specifically, the Python devs have decided to case fold
-name to lowercase by default when `auto()` is used which I think violates the
-principle of least surprise.**

venv/Lib/site-packages/StrEnum-0.4.15.dist-info/RECORD

@@ -1,18 +0,0 @@
-StrEnum-0.4.15.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-StrEnum-0.4.15.dist-info/LICENSE,sha256=vNcz0KRlIhYrldurYffNwcPjaGHfoSfWikQ1JA02rTY,1073
-StrEnum-0.4.15.dist-info/METADATA,sha256=xLhPNsn2ieV9BR8L-FvFTMMhG6x99Rj536PM2hf1KII,5290
-StrEnum-0.4.15.dist-info/RECORD,,
-StrEnum-0.4.15.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-StrEnum-0.4.15.dist-info/top_level.txt,sha256=lsVIlgvvAAG9MBoLNwpPgG5wMT33blIUUoJo215Y-N0,8
-strenum/__init__.py,sha256=oOsokqYYQVwTBbjrnXdR89RMcx8q6aGmWl--dlf2VCE,8530
-strenum/__init__.pyi,sha256=-qJs9THlVGY3_o_bVeE7jUevjWteU_zOy7cZkp3MGzA,1415
-strenum/__pycache__/__init__.cpython-314.pyc,,
-strenum/__pycache__/_name_mangler.cpython-314.pyc,,
-strenum/__pycache__/_version.cpython-314.pyc,,
-strenum/__pycache__/mixins.cpython-314.pyc,,
-strenum/_name_mangler.py,sha256=o11M5-bURW2RBvRTYXFQIPNeqLzburdoWLIqk8X3ydw,3397
-strenum/_name_mangler.pyi,sha256=91p30d_kMAFsX5r9pqvSeordIf4VONDymQhcEvot2XA,551
-strenum/_version.py,sha256=ylMBlzCLrUBhNvBnKtzTqGzDqHnEmoQkm3K6p5Gx5ms,498
-strenum/mixins.py,sha256=BtOEx1hrAZ1YhDURDjLTrunKVneVtezSfkBq3sZXqxE,2042
-strenum/mixins.pyi,sha256=lV6wiQAxZMvMSUUtnxzV1QSsyBDzgpobywiGCwRwm30,387
-strenum/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

venv/Lib/site-packages/StrEnum-0.4.15.dist-info/WHEEL

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

venv/Lib/site-packages/StrEnum-0.4.15.dist-info/top_level.txt

@@ -1 +0,0 @@
-strenum

venv/Lib/site-packages/_cffi_backend.cp314-win_amd64.pyd

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9e99b2184c60f21a88cafc374386ded3559e8694ed7cf111f2869e066d303334
-size 181248

venv/Lib/site-packages/_pytest/__init__.py

@@ -1,13 +0,0 @@
-from __future__ import annotations
-
-
-__all__ = ["__version__", "version_tuple"]
-
-try:
-    from ._version import version as __version__
-    from ._version import version_tuple
-except ImportError:  # pragma: no cover
-    # broken installation, we don't even try
-    # unknown only works because we do poor mans version compare
-    __version__ = "unknown"
-    version_tuple = (0, 0, "unknown")

venv/Lib/site-packages/_pytest/_argcomplete.py

@@ -1,117 +0,0 @@
-"""Allow bash-completion for argparse with argcomplete if installed.
-
-Needs argcomplete>=0.5.6 for python 3.2/3.3 (older versions fail
-to find the magic string, so _ARGCOMPLETE env. var is never set, and
-this does not need special code).
-
-Function try_argcomplete(parser) should be called directly before
-the call to ArgumentParser.parse_args().
-
-The filescompleter is what you normally would use on the positional
-arguments specification, in order to get "dirname/" after "dirn<TAB>"
-instead of the default "dirname ":
-
-   optparser.add_argument(Config._file_or_dir, nargs='*').completer=filescompleter
-
-Other, application specific, completers should go in the file
-doing the add_argument calls as they need to be specified as .completer
-attributes as well. (If argcomplete is not installed, the function the
-attribute points to will not be used).
-
-SPEEDUP
-=======
-
-The generic argcomplete script for bash-completion
-(/etc/bash_completion.d/python-argcomplete.sh)
-uses a python program to determine startup script generated by pip.
-You can speed up completion somewhat by changing this script to include
-  # PYTHON_ARGCOMPLETE_OK
-so the python-argcomplete-check-easy-install-script does not
-need to be called to find the entry point of the code and see if that is
-marked  with PYTHON_ARGCOMPLETE_OK.
-
-INSTALL/DEBUGGING
-=================
-
-To include this support in another application that has setup.py generated
-scripts:
-
-- Add the line:
-    # PYTHON_ARGCOMPLETE_OK
-  near the top of the main python entry point.
-
-- Include in the file calling parse_args():
-    from _argcomplete import try_argcomplete, filescompleter
-  Call try_argcomplete just before parse_args(), and optionally add
-  filescompleter to the positional arguments' add_argument().
-
-If things do not work right away:
-
-- Switch on argcomplete debugging with (also helpful when doing custom
-  completers):
-    export _ARC_DEBUG=1
-
-- Run:
-    python-argcomplete-check-easy-install-script $(which appname)
-    echo $?
-  will echo 0 if the magic line has been found, 1 if not.
-
-- Sometimes it helps to find early on errors using:
-    _ARGCOMPLETE=1 _ARC_DEBUG=1 appname
-  which should throw a KeyError: 'COMPLINE' (which is properly set by the
-  global argcomplete script).
-"""
-
-from __future__ import annotations
-
-import argparse
-from glob import glob
-import os
-import sys
-from typing import Any
-
-
-class FastFilesCompleter:
-    """Fast file completer class."""
-
-    def __init__(self, directories: bool = True) -> None:
-        self.directories = directories
-
-    def __call__(self, prefix: str, **kwargs: Any) -> list[str]:
-        # Only called on non option completions.
-        if os.sep in prefix[1:]:
-            prefix_dir = len(os.path.dirname(prefix) + os.sep)
-        else:
-            prefix_dir = 0
-        completion = []
-        globbed = []
-        if "*" not in prefix and "?" not in prefix:
-            # We are on unix, otherwise no bash.
-            if not prefix or prefix[-1] == os.sep:
-                globbed.extend(glob(prefix + ".*"))
-            prefix += "*"
-        globbed.extend(glob(prefix))
-        for x in sorted(globbed):
-            if os.path.isdir(x):
-                x += "/"
-            # Append stripping the prefix (like bash, not like compgen).
-            completion.append(x[prefix_dir:])
-        return completion
-
-
-if os.environ.get("_ARGCOMPLETE"):
-    try:
-        import argcomplete.completers
-    except ImportError:
-        sys.exit(-1)
-    filescompleter: FastFilesCompleter | None = FastFilesCompleter()
-
-    def try_argcomplete(parser: argparse.ArgumentParser) -> None:
-        argcomplete.autocomplete(parser, always_complete_options=False)
-
-else:
-
-    def try_argcomplete(parser: argparse.ArgumentParser) -> None:
-        pass
-
-    filescompleter = None

venv/Lib/site-packages/_pytest/_code/__init__.py

@@ -1,26 +0,0 @@
-"""Python inspection/code generation API."""
-
-from __future__ import annotations
-
-from .code import Code
-from .code import ExceptionInfo
-from .code import filter_traceback
-from .code import Frame
-from .code import getfslineno
-from .code import Traceback
-from .code import TracebackEntry
-from .source import getrawcode
-from .source import Source
-
-
-__all__ = [
-    "Code",
-    "ExceptionInfo",
-    "Frame",
-    "Source",
-    "Traceback",
-    "TracebackEntry",
-    "filter_traceback",
-    "getfslineno",
-    "getrawcode",
-]

venv/Lib/site-packages/_pytest/_code/code.py

@@ -1,1632 +0,0 @@
-# mypy: allow-untyped-defs
-from __future__ import annotations
-
-import ast
-from collections.abc import Callable
-from collections.abc import Iterable
-from collections.abc import Mapping
-from collections.abc import Sequence
-import dataclasses
-import inspect
-from io import StringIO
-import os
-from pathlib import Path
-import re
-import sys
-from traceback import extract_tb
-from traceback import format_exception
-from traceback import format_exception_only
-from traceback import FrameSummary
-from types import CodeType
-from types import FrameType
-from types import TracebackType
-from typing import Any
-from typing import ClassVar
-from typing import Final
-from typing import final
-from typing import Generic
-from typing import Literal
-from typing import overload
-from typing import SupportsIndex
-from typing import TypeAlias
-from typing import TypeVar
-
-import pluggy
-
-import _pytest
-from _pytest._code.source import findsource
-from _pytest._code.source import getrawcode
-from _pytest._code.source import getstatementrange_ast
-from _pytest._code.source import Source
-from _pytest._io import TerminalWriter
-from _pytest._io.saferepr import safeformat
-from _pytest._io.saferepr import saferepr
-from _pytest.compat import get_real_func
-from _pytest.deprecated import check_ispytest
-from _pytest.pathlib import absolutepath
-from _pytest.pathlib import bestrelpath
-
-
-if sys.version_info < (3, 11):
-    from exceptiongroup import BaseExceptionGroup
-
-TracebackStyle = Literal["long", "short", "line", "no", "native", "value", "auto"]
-
-EXCEPTION_OR_MORE = type[BaseException] | tuple[type[BaseException], ...]
-
-
-class Code:
-    """Wrapper around Python code objects."""
-
-    __slots__ = ("raw",)
-
-    def __init__(self, obj: CodeType) -> None:
-        self.raw = obj
-
-    @classmethod
-    def from_function(cls, obj: object) -> Code:
-        return cls(getrawcode(obj))
-
-    def __eq__(self, other):
-        return self.raw == other.raw
-
-    # Ignore type because of https://github.com/python/mypy/issues/4266.
-    __hash__ = None  # type: ignore
-
-    @property
-    def firstlineno(self) -> int:
-        return self.raw.co_firstlineno - 1
-
-    @property
-    def name(self) -> str:
-        return self.raw.co_name
-
-    @property
-    def path(self) -> Path | str:
-        """Return a path object pointing to source code, or an ``str`` in
-        case of ``OSError`` / non-existing file."""
-        filename = inspect.getfile(self.raw)
-        if not filename:
-            return ""
-        try:
-            p = absolutepath(filename)
-            # maybe don't try this checking
-            if not p.exists():
-                raise OSError("path check failed.")
-            return p
-        except OSError:
-            # XXX maybe try harder like the weird logic
-            # in the standard lib [linecache.updatecache] does?
-            return filename
-
-    @property
-    def fullsource(self) -> Source | None:
-        """Return a _pytest._code.Source object for the full source file of the code."""
-        full, _ = findsource(self.raw)
-        return full
-
-    def source(self) -> Source:
-        """Return a _pytest._code.Source object for the code object's source only."""
-        # return source only for that part of code
-        return Source(self.raw)
-
-    def getargs(self, var: bool = False) -> tuple[str, ...]:
-        """Return a tuple with the argument names for the code object.
-
-        If 'var' is set True also return the names of the variable and
-        keyword arguments when present.
-        """
-        # inspect.getargs merges positional and kwonly into a single list;
-        # co_argcount is needed to exclude kwonly when var=False.
-        args, varargs, varkw = inspect.getargs(self.raw)
-        if not var:
-            return tuple(args[: self.raw.co_argcount])
-        result = list(args)
-        if varargs is not None:
-            result.append(varargs)
-        if varkw is not None:
-            result.append(varkw)
-        return tuple(result)
-
-
-class Frame:
-    """Wrapper around a Python frame holding f_locals and f_globals
-    in which expressions can be evaluated."""
-
-    __slots__ = ("raw",)
-
-    def __init__(self, frame: FrameType) -> None:
-        self.raw = frame
-
-    @property
-    def lineno(self) -> int:
-        return self.raw.f_lineno - 1
-
-    @property
-    def f_globals(self) -> dict[str, Any]:
-        return self.raw.f_globals
-
-    @property
-    def f_locals(self) -> dict[str, Any]:
-        return self.raw.f_locals
-
-    @property
-    def code(self) -> Code:
-        return Code(self.raw.f_code)
-
-    @property
-    def statement(self) -> Source:
-        """Statement this frame is at."""
-        if self.code.fullsource is None:
-            return Source("")
-        return self.code.fullsource.getstatement(self.lineno)
-
-    def eval(self, code, **vars):
-        """Evaluate 'code' in the frame.
-
-        'vars' are optional additional local variables.
-
-        Returns the result of the evaluation.
-        """
-        f_locals = self.f_locals.copy()
-        f_locals.update(vars)
-        return eval(code, self.f_globals, f_locals)
-
-    def repr(self, object: object) -> str:
-        """Return a 'safe' (non-recursive, one-line) string repr for 'object'."""
-        return saferepr(object)
-
-    def getargs(self, var: bool = False):
-        """Return a list of tuples (name, value) for all arguments.
-
-        If 'var' is set True, also include the variable and keyword arguments
-        when present.
-        """
-        retval = []
-        for arg in self.code.getargs(var):
-            try:
-                retval.append((arg, self.f_locals[arg]))
-            except KeyError:
-                pass  # this can occur when using Psyco
-        return retval
-
-
-class TracebackEntry:
-    """A single entry in a Traceback."""
-
-    __slots__ = ("_rawentry", "_repr_style")
-
-    def __init__(
-        self,
-        rawentry: TracebackType,
-        repr_style: Literal["short", "long"] | None = None,
-    ) -> None:
-        self._rawentry: Final = rawentry
-        self._repr_style: Final = repr_style
-
-    def with_repr_style(
-        self, repr_style: Literal["short", "long"] | None
-    ) -> TracebackEntry:
-        return TracebackEntry(self._rawentry, repr_style)
-
-    @property
-    def lineno(self) -> int:
-        return self._rawentry.tb_lineno - 1
-
-    def get_python_framesummary(self) -> FrameSummary:
-        # Python's built-in traceback module implements all the nitty gritty
-        # details to get column numbers of out frames.
-        stack_summary = extract_tb(self._rawentry, limit=1)
-        return stack_summary[0]
-
-    # Column and end line numbers introduced in python 3.11
-    if sys.version_info < (3, 11):
-
-        @property
-        def end_lineno_relative(self) -> int | None:
-            return None
-
-        @property
-        def colno(self) -> int | None:
-            return None
-
-        @property
-        def end_colno(self) -> int | None:
-            return None
-    else:
-
-        @property
-        def end_lineno_relative(self) -> int | None:
-            frame_summary = self.get_python_framesummary()
-            if frame_summary.end_lineno is None:  # pragma: no cover
-                return None
-            return frame_summary.end_lineno - 1 - self.frame.code.firstlineno
-
-        @property
-        def colno(self) -> int | None:
-            """Starting byte offset of the expression in the traceback entry."""
-            return self.get_python_framesummary().colno
-
-        @property
-        def end_colno(self) -> int | None:
-            """Ending byte offset of the expression in the traceback entry."""
-            return self.get_python_framesummary().end_colno
-
-    @property
-    def frame(self) -> Frame:
-        return Frame(self._rawentry.tb_frame)
-
-    @property
-    def relline(self) -> int:
-        return self.lineno - self.frame.code.firstlineno
-
-    def __repr__(self) -> str:
-        return f"<TracebackEntry {self.frame.code.path}:{self.lineno + 1}>"
-
-    @property
-    def statement(self) -> Source:
-        """_pytest._code.Source object for the current statement."""
-        source = self.frame.code.fullsource
-        assert source is not None
-        return source.getstatement(self.lineno)
-
-    @property
-    def path(self) -> Path | str:
-        """Path to the source code."""
-        return self.frame.code.path
-
-    @property
-    def locals(self) -> dict[str, Any]:
-        """Locals of underlying frame."""
-        return self.frame.f_locals
-
-    def getfirstlinesource(self) -> int:
-        return self.frame.code.firstlineno
-
-    def getsource(
-        self, astcache: dict[str | Path, ast.AST] | None = None
-    ) -> Source | None:
-        """Return failing source code."""
-        # we use the passed in astcache to not reparse asttrees
-        # within exception info printing
-        source = self.frame.code.fullsource
-        if source is None:
-            return None
-        key = astnode = None
-        if astcache is not None:
-            key = self.frame.code.path
-            if key is not None:
-                astnode = astcache.get(key, None)
-        start = self.getfirstlinesource()
-        try:
-            astnode, _, end = getstatementrange_ast(
-                self.lineno, source, astnode=astnode
-            )
-        except SyntaxError:
-            end = self.lineno + 1
-        else:
-            if key is not None and astcache is not None:
-                astcache[key] = astnode
-        return source[start:end]
-
-    source = property(getsource)
-
-    def ishidden(self, excinfo: ExceptionInfo[BaseException] | None) -> bool:
-        """Return True if the current frame has a var __tracebackhide__
-        resolving to True.
-
-        If __tracebackhide__ is a callable, it gets called with the
-        ExceptionInfo instance and can decide whether to hide the traceback.
-
-        Mostly for internal use.
-        """
-        tbh: bool | Callable[[ExceptionInfo[BaseException] | None], bool] = False
-        for maybe_ns_dct in (self.frame.f_locals, self.frame.f_globals):
-            # in normal cases, f_locals and f_globals are dictionaries
-            # however via `exec(...)` / `eval(...)` they can be other types
-            # (even incorrect types!).
-            # as such, we suppress all exceptions while accessing __tracebackhide__
-            try:
-                tbh = maybe_ns_dct["__tracebackhide__"]
-            except Exception:
-                pass
-            else:
-                break
-        if tbh and callable(tbh):
-            return tbh(excinfo)
-        return tbh
-
-    def __str__(self) -> str:
-        name = self.frame.code.name
-        try:
-            line = str(self.statement).lstrip()
-        except KeyboardInterrupt:
-            raise
-        except BaseException:
-            line = "???"
-        # This output does not quite match Python's repr for traceback entries,
-        # but changing it to do so would break certain plugins.  See
-        # https://github.com/pytest-dev/pytest/pull/7535/ for details.
-        return f"  File '{self.path}':{self.lineno + 1} in {name}\n  {line}\n"
-
-    @property
-    def name(self) -> str:
-        """co_name of underlying code."""
-        return self.frame.code.raw.co_name
-
-
-class Traceback(list[TracebackEntry]):
-    """Traceback objects encapsulate and offer higher level access to Traceback entries."""
-
-    def __init__(
-        self,
-        tb: TracebackType | Iterable[TracebackEntry],
-    ) -> None:
-        """Initialize from given python traceback object and ExceptionInfo."""
-        if isinstance(tb, TracebackType):
-
-            def f(cur: TracebackType) -> Iterable[TracebackEntry]:
-                cur_: TracebackType | None = cur
-                while cur_ is not None:
-                    yield TracebackEntry(cur_)
-                    cur_ = cur_.tb_next
-
-            super().__init__(f(tb))
-        else:
-            super().__init__(tb)
-
-    def cut(
-        self,
-        path: os.PathLike[str] | str | None = None,
-        lineno: int | None = None,
-        firstlineno: int | None = None,
-        excludepath: os.PathLike[str] | None = None,
-    ) -> Traceback:
-        """Return a Traceback instance wrapping part of this Traceback.
-
-        By providing any combination of path, lineno and firstlineno, the
-        first frame to start the to-be-returned traceback is determined.
-
-        This allows cutting the first part of a Traceback instance e.g.
-        for formatting reasons (removing some uninteresting bits that deal
-        with handling of the exception/traceback).
-        """
-        path_ = None if path is None else os.fspath(path)
-        excludepath_ = None if excludepath is None else os.fspath(excludepath)
-        for x in self:
-            code = x.frame.code
-            codepath = code.path
-            if path is not None and str(codepath) != path_:
-                continue
-            if (
-                excludepath is not None
-                and isinstance(codepath, Path)
-                and excludepath_ in (str(p) for p in codepath.parents)  # type: ignore[operator]
-            ):
-                continue
-            if lineno is not None and x.lineno != lineno:
-                continue
-            if firstlineno is not None and x.frame.code.firstlineno != firstlineno:
-                continue
-            return Traceback(x._rawentry)
-        return self
-
-    @overload
-    def __getitem__(self, key: SupportsIndex) -> TracebackEntry: ...
-
-    @overload
-    def __getitem__(self, key: slice) -> Traceback: ...
-
-    def __getitem__(self, key: SupportsIndex | slice) -> TracebackEntry | Traceback:
-        if isinstance(key, slice):
-            return self.__class__(super().__getitem__(key))
-        else:
-            return super().__getitem__(key)
-
-    def filter(
-        self,
-        excinfo_or_fn: ExceptionInfo[BaseException] | Callable[[TracebackEntry], bool],
-        /,
-    ) -> Traceback:
-        """Return a Traceback instance with certain items removed.
-
-        If the filter is an `ExceptionInfo`, removes all the ``TracebackEntry``s
-        which are hidden (see ishidden() above).
-
-        Otherwise, the filter is a function that gets a single argument, a
-        ``TracebackEntry`` instance, and should return True when the item should
-        be added to the ``Traceback``, False when not.
-        """
-        if isinstance(excinfo_or_fn, ExceptionInfo):
-            fn = lambda x: not x.ishidden(excinfo_or_fn)  # noqa: E731
-        else:
-            fn = excinfo_or_fn
-        return Traceback(filter(fn, self))
-
-    def recursionindex(self) -> int | None:
-        """Return the index of the frame/TracebackEntry where recursion originates if
-        appropriate, None if no recursion occurred."""
-        cache: dict[tuple[Any, int, int], list[dict[str, Any]]] = {}
-        for i, entry in enumerate(self):
-            # id for the code.raw is needed to work around
-            # the strange metaprogramming in the decorator lib from pypi
-            # which generates code objects that have hash/value equality
-            # XXX needs a test
-            key = entry.frame.code.path, id(entry.frame.code.raw), entry.lineno
-            values = cache.setdefault(key, [])
-            # Since Python 3.13 f_locals is a proxy, freeze it.
-            loc = dict(entry.frame.f_locals)
-            if values:
-                for otherloc in values:
-                    if otherloc == loc:
-                        return i
-            values.append(loc)
-        return None
-
-
-def stringify_exception(
-    exc: BaseException, include_subexception_msg: bool = True
-) -> str:
-    try:
-        notes = getattr(exc, "__notes__", [])
-    except KeyError:
-        # Workaround for https://github.com/python/cpython/issues/98778 on
-        # some 3.10 and 3.11 patch versions.
-        HTTPError = getattr(sys.modules.get("urllib.error", None), "HTTPError", ())
-        if sys.version_info < (3, 12) and isinstance(exc, HTTPError):
-            notes = []
-        else:  # pragma: no cover
-            # exception not related to above bug, reraise
-            raise
-    if not include_subexception_msg and isinstance(exc, BaseExceptionGroup):
-        message = exc.message
-    else:
-        message = str(exc)
-
-    return "\n".join(
-        [
-            message,
-            *notes,
-        ]
-    )
-
-
-E = TypeVar("E", bound=BaseException, covariant=True)
-
-
-@final
-@dataclasses.dataclass
-class ExceptionInfo(Generic[E]):
-    """Wraps sys.exc_info() objects and offers help for navigating the traceback."""
-
-    _assert_start_repr: ClassVar = "AssertionError('assert "
-
-    _excinfo: tuple[type[E], E, TracebackType] | None
-    _striptext: str
-    _traceback: Traceback | None
-
-    def __init__(
-        self,
-        excinfo: tuple[type[E], E, TracebackType] | None,
-        striptext: str = "",
-        traceback: Traceback | None = None,
-        *,
-        _ispytest: bool = False,
-    ) -> None:
-        check_ispytest(_ispytest)
-        self._excinfo = excinfo
-        self._striptext = striptext
-        self._traceback = traceback
-
-    @classmethod
-    def from_exception(
-        cls,
-        # Ignoring error: "Cannot use a covariant type variable as a parameter".
-        # This is OK to ignore because this class is (conceptually) readonly.
-        # See https://github.com/python/mypy/issues/7049.
-        exception: E,  # type: ignore[misc]
-        exprinfo: str | None = None,
-    ) -> ExceptionInfo[E]:
-        """Return an ExceptionInfo for an existing exception.
-
-        The exception must have a non-``None`` ``__traceback__`` attribute,
-        otherwise this function fails with an assertion error. This means that
-        the exception must have been raised, or added a traceback with the
-        :py:meth:`~BaseException.with_traceback()` method.
-
-        :param exprinfo:
-            A text string helping to determine if we should strip
-            ``AssertionError`` from the output. Defaults to the exception
-            message/``__str__()``.
-
-        .. versionadded:: 7.4
-        """
-        assert exception.__traceback__, (
-            "Exceptions passed to ExcInfo.from_exception(...)"
-            " must have a non-None __traceback__."
-        )
-        exc_info = (type(exception), exception, exception.__traceback__)
-        return cls.from_exc_info(exc_info, exprinfo)
-
-    @classmethod
-    def from_exc_info(
-        cls,
-        exc_info: tuple[type[E], E, TracebackType],
-        exprinfo: str | None = None,
-    ) -> ExceptionInfo[E]:
-        """Like :func:`from_exception`, but using old-style exc_info tuple."""
-        _striptext = ""
-        if exprinfo is None and isinstance(exc_info[1], AssertionError):
-            exprinfo = getattr(exc_info[1], "msg", None)
-            if exprinfo is None:
-                exprinfo = saferepr(exc_info[1])
-            if exprinfo and exprinfo.startswith(cls._assert_start_repr):
-                _striptext = "AssertionError: "
-
-        return cls(exc_info, _striptext, _ispytest=True)
-
-    @classmethod
-    def from_current(cls, exprinfo: str | None = None) -> ExceptionInfo[BaseException]:
-        """Return an ExceptionInfo matching the current traceback.
-
-        .. warning::
-
-            Experimental API
-
-        :param exprinfo:
-            A text string helping to determine if we should strip
-            ``AssertionError`` from the output. Defaults to the exception
-            message/``__str__()``.
-        """
-        tup = sys.exc_info()
-        assert tup[0] is not None, "no current exception"
-        assert tup[1] is not None, "no current exception"
-        assert tup[2] is not None, "no current exception"
-        exc_info = (tup[0], tup[1], tup[2])
-        return ExceptionInfo.from_exc_info(exc_info, exprinfo)
-
-    @classmethod
-    def for_later(cls) -> ExceptionInfo[E]:
-        """Return an unfilled ExceptionInfo."""
-        return cls(None, _ispytest=True)
-
-    def fill_unfilled(self, exc_info: tuple[type[E], E, TracebackType]) -> None:
-        """Fill an unfilled ExceptionInfo created with ``for_later()``."""
-        assert self._excinfo is None, "ExceptionInfo was already filled"
-        self._excinfo = exc_info
-
-    @property
-    def type(self) -> type[E]:
-        """The exception class."""
-        assert self._excinfo is not None, (
-            ".type can only be used after the context manager exits"
-        )
-        return self._excinfo[0]
-
-    @property
-    def value(self) -> E:
-        """The exception value."""
-        assert self._excinfo is not None, (
-            ".value can only be used after the context manager exits"
-        )
-        return self._excinfo[1]
-
-    @property
-    def tb(self) -> TracebackType:
-        """The exception raw traceback."""
-        assert self._excinfo is not None, (
-            ".tb can only be used after the context manager exits"
-        )
-        return self._excinfo[2]
-
-    @property
-    def typename(self) -> str:
-        """The type name of the exception."""
-        assert self._excinfo is not None, (
-            ".typename can only be used after the context manager exits"
-        )
-        return self.type.__name__
-
-    @property
-    def traceback(self) -> Traceback:
-        """The traceback."""
-        if self._traceback is None:
-            self._traceback = Traceback(self.tb)
-        return self._traceback
-
-    @traceback.setter
-    def traceback(self, value: Traceback) -> None:
-        self._traceback = value
-
-    def __repr__(self) -> str:
-        if self._excinfo is None:
-            return "<ExceptionInfo for raises contextmanager>"
-        return f"<{self.__class__.__name__} {saferepr(self._excinfo[1])} tblen={len(self.traceback)}>"
-
-    def exconly(self, tryshort: bool = False) -> str:
-        """Return the exception as a string.
-
-        This is usually a single line "<exception type>: <exception str>", but
-        may also include additional lines for the exception notes, and detailed
-        information for SyntaxError's.
-
-        :param tryshort:
-            If true, and the exception is an AssertionError, strip
-            'AssertionError: ' from the beginning.
-        """
-
-        def _get_single_subexc(
-            eg: BaseExceptionGroup[BaseException],
-        ) -> BaseException | None:
-            if len(eg.exceptions) != 1:
-                return None
-            if isinstance(e := eg.exceptions[0], BaseExceptionGroup):
-                return _get_single_subexc(e)
-            return e
-
-        if (
-            tryshort
-            and isinstance(self.value, BaseExceptionGroup)
-            and (subexc := _get_single_subexc(self.value)) is not None
-        ):
-            return f"{subexc!r} [single exception in {type(self.value).__name__}]"
-
-        lines = format_exception_only(self.value)
-        # The lines already include line separators.
-        text = "".join(lines)
-        text = text.rstrip()
-        if tryshort:
-            if text.startswith(self._striptext):
-                text = text[len(self._striptext) :]
-        return text
-
-    def errisinstance(self, exc: EXCEPTION_OR_MORE) -> bool:
-        """Return True if the exception is an instance of exc.
-
-        Consider using ``isinstance(excinfo.value, exc)`` instead.
-        """
-        return isinstance(self.value, exc)
-
-    def _getreprcrash(self) -> ReprFileLocation | None:
-        # Find last non-hidden traceback entry that led to the exception of the
-        # traceback, or None if all hidden.
-        for i in range(-1, -len(self.traceback) - 1, -1):
-            entry = self.traceback[i]
-            if not entry.ishidden(self):
-                path, lineno = entry.frame.code.raw.co_filename, entry.lineno
-                exconly = self.exconly(tryshort=True)
-                return ReprFileLocation(path, lineno + 1, exconly)
-        return None
-
-    def getrepr(
-        self,
-        showlocals: bool = False,
-        style: TracebackStyle = "long",
-        abspath: bool = False,
-        tbfilter: bool | Callable[[ExceptionInfo[BaseException]], Traceback] = True,
-        funcargs: bool = False,
-        truncate_locals: bool = True,
-        truncate_args: bool = True,
-        chain: bool = True,
-    ) -> ReprExceptionInfo | ExceptionChainRepr:
-        """Return str()able representation of this exception info.
-
-        The formatting parameters are ineffective if ``style="native"``,
-        since in this case the native formatting is used.
-
-        :param bool showlocals:
-            Show locals per traceback entry.
-
-        :param str style:
-            long|short|line|no|native|value traceback style.
-
-        :param bool abspath:
-            If paths should be changed to absolute or left unchanged.
-
-        :param tbfilter:
-            A filter for traceback entries.
-
-            * If false, don't hide any entries.
-            * If true, hide internal entries and entries that contain a local
-              variable ``__tracebackhide__ = True``.
-            * If a callable, delegates the filtering to the callable.
-
-        :param bool funcargs:
-            Show function arguments per traceback entry.
-
-        :param bool truncate_locals:
-            Whether to show a size-limited `repr()` of locals, or a full
-            pretty-printing.
-
-        :param bool truncate_args:
-            Whether to show a size-limited truncated `repr()` of function
-            arguments, or a full pretty-printing.
-
-        :param bool chain:
-            If chained exceptions should be shown.
-
-        .. versionchanged:: 3.9
-
-            Added the ``chain`` parameter.
-        """
-        if style == "native":
-            return ReprExceptionInfo(
-                reprtraceback=ReprTracebackNative(
-                    format_exception(
-                        self.type,
-                        self.value,
-                        self.traceback[0]._rawentry if self.traceback else None,
-                    )
-                ),
-                reprcrash=self._getreprcrash(),
-            )
-
-        fmt = ExceptionInfoFormatter(
-            showlocals=showlocals,
-            style=style,
-            abspath=abspath,
-            tbfilter=tbfilter,
-            funcargs=funcargs,
-            truncate_locals=truncate_locals,
-            truncate_args=truncate_args,
-            chain=chain,
-        )
-        return fmt.repr_excinfo(self)
-
-    def match(self, regexp: str | re.Pattern[str]) -> Literal[True]:
-        """Check whether the regular expression `regexp` matches the string
-        representation of the exception using :func:`python:re.search`.
-
-        If it matches `True` is returned, otherwise an `AssertionError` is raised.
-        """
-        __tracebackhide__ = True
-        value = stringify_exception(self.value)
-        msg = (
-            f"Regex pattern did not match.\n"
-            f"  Expected regex: {regexp!r}\n"
-            f"  Actual message: {value!r}"
-        )
-        if regexp == value:
-            msg += "\n Did you mean to `re.escape()` the regex?"
-        assert re.search(regexp, value), msg
-        # Return True to allow for "assert excinfo.match()".
-        return True
-
-    def _group_contains(
-        self,
-        exc_group: BaseExceptionGroup[BaseException],
-        expected_exception: EXCEPTION_OR_MORE,
-        match: str | re.Pattern[str] | None,
-        target_depth: int | None = None,
-        current_depth: int = 1,
-    ) -> bool:
-        """Return `True` if a `BaseExceptionGroup` contains a matching exception."""
-        if (target_depth is not None) and (current_depth > target_depth):
-            # already descended past the target depth
-            return False
-        for exc in exc_group.exceptions:
-            if isinstance(exc, BaseExceptionGroup):
-                if self._group_contains(
-                    exc, expected_exception, match, target_depth, current_depth + 1
-                ):
-                    return True
-            if (target_depth is not None) and (current_depth != target_depth):
-                # not at the target depth, no match
-                continue
-            if not isinstance(exc, expected_exception):
-                continue
-            if match is not None:
-                value = stringify_exception(exc)
-                if not re.search(match, value):
-                    continue
-            return True
-        return False
-
-    def group_contains(
-        self,
-        expected_exception: EXCEPTION_OR_MORE,
-        *,
-        match: str | re.Pattern[str] | None = None,
-        depth: int | None = None,
-    ) -> bool:
-        """Check whether a captured exception group contains a matching exception.
-
-        :param Type[BaseException] | Tuple[Type[BaseException]] expected_exception:
-            The expected exception type, or a tuple if one of multiple possible
-            exception types are expected.
-
-        :param str | re.Pattern[str] | None match:
-            If specified, a string containing a regular expression,
-            or a regular expression object, that is tested against the string
-            representation of the exception and its `PEP-678 <https://peps.python.org/pep-0678/>` `__notes__`
-            using :func:`re.search`.
-
-            To match a literal string that may contain :ref:`special characters
-            <re-syntax>`, the pattern can first be escaped with :func:`re.escape`.
-
-        :param Optional[int] depth:
-            If `None`, will search for a matching exception at any nesting depth.
-            If >= 1, will only match an exception if it's at the specified depth (depth = 1 being
-            the exceptions contained within the topmost exception group).
-
-        .. versionadded:: 8.0
-
-        .. warning::
-           This helper makes it easy to check for the presence of specific exceptions,
-           but it is very bad for checking that the group does *not* contain
-           *any other exceptions*.
-           You should instead consider using :class:`pytest.RaisesGroup`
-
-        """
-        msg = "Captured exception is not an instance of `BaseExceptionGroup`"
-        assert isinstance(self.value, BaseExceptionGroup), msg
-        msg = "`depth` must be >= 1 if specified"
-        assert (depth is None) or (depth >= 1), msg
-        return self._group_contains(self.value, expected_exception, match, depth)
-
-
-# Type alias for the `tbfilter` setting:
-# bool: If True, it should be filtered using Traceback.filter()
-# callable: A callable that takes an ExceptionInfo and returns the filtered traceback.
-TracebackFilter: TypeAlias = bool | Callable[[ExceptionInfo[BaseException]], Traceback]
-
-
-@dataclasses.dataclass
-class ExceptionInfoFormatter:
-    """Helper object to format ExceptionInfo's and individual exception parts
-    into TerminalRepr's.
-
-    See :func:`ExceptionInfo.getrepr` for parameters.
-    """
-
-    # for traceback entries
-    flow_marker: ClassVar = ">"
-    fail_marker: ClassVar = "E"
-
-    showlocals: bool = False
-    # Note: "native" is handled outside of ExceptionInfoFormatter.
-    style: TracebackStyle = "long"
-    abspath: bool = True
-    tbfilter: TracebackFilter = True
-    funcargs: bool = False
-    truncate_locals: bool = True
-    truncate_args: bool = True
-    chain: bool = True
-
-    astcache: dict[str | Path, ast.AST] = dataclasses.field(
-        default_factory=dict, init=False, repr=False
-    )
-
-    def _getindent(self, source: Source) -> int:
-        # Figure out indent for the given source.
-        try:
-            s = str(source.getstatement(len(source) - 1))
-        except KeyboardInterrupt:
-            raise
-        except BaseException:
-            try:
-                s = str(source[-1])
-            except KeyboardInterrupt:
-                raise
-            except BaseException:
-                return 0
-        return 4 + (len(s) - len(s.lstrip()))
-
-    def _getentrysource(self, entry: TracebackEntry) -> Source | None:
-        source = entry.getsource(self.astcache)
-        if source is not None:
-            source = source.deindent()
-        return source
-
-    def repr_args(self, entry: TracebackEntry) -> ReprFuncArgs | None:
-        if self.funcargs:
-            args = []
-            for argname, argvalue in entry.frame.getargs(var=True):
-                if self.truncate_args:
-                    str_repr = saferepr(argvalue)
-                else:
-                    str_repr = saferepr(argvalue, maxsize=None)
-                args.append((argname, str_repr))
-            return ReprFuncArgs(args)
-        return None
-
-    def get_source(
-        self,
-        source: Source | None,
-        line_index: int = -1,
-        excinfo: ExceptionInfo[BaseException] | None = None,
-        short: bool = False,
-        end_line_index: int | None = None,
-        colno: int | None = None,
-        end_colno: int | None = None,
-    ) -> list[str]:
-        """Return formatted and marked up source lines."""
-        lines = []
-        if source is not None and line_index < 0:
-            line_index += len(source)
-        if source is None or line_index >= len(source.lines) or line_index < 0:
-            # `line_index` could still be outside `range(len(source.lines))` if
-            # we're processing AST with pathological position attributes.
-            source = Source("???")
-            line_index = 0
-        space_prefix = "    "
-        if short:
-            lines.append(space_prefix + source.lines[line_index].strip())
-            lines.extend(
-                self.get_highlight_arrows_for_line(
-                    raw_line=source.raw_lines[line_index],
-                    line=source.lines[line_index].strip(),
-                    lineno=line_index,
-                    end_lineno=end_line_index,
-                    colno=colno,
-                    end_colno=end_colno,
-                )
-            )
-        else:
-            for line in source.lines[:line_index]:
-                lines.append(space_prefix + line)
-            lines.append(self.flow_marker + "   " + source.lines[line_index])
-            lines.extend(
-                self.get_highlight_arrows_for_line(
-                    raw_line=source.raw_lines[line_index],
-                    line=source.lines[line_index],
-                    lineno=line_index,
-                    end_lineno=end_line_index,
-                    colno=colno,
-                    end_colno=end_colno,
-                )
-            )
-            for line in source.lines[line_index + 1 :]:
-                lines.append(space_prefix + line)
-        if excinfo is not None:
-            indent = 4 if short else self._getindent(source)
-            lines.extend(self.get_exconly(excinfo, indent=indent, markall=True))
-        return lines
-
-    def get_highlight_arrows_for_line(
-        self,
-        line: str,
-        raw_line: str,
-        lineno: int | None,
-        end_lineno: int | None,
-        colno: int | None,
-        end_colno: int | None,
-    ) -> list[str]:
-        """Return characters highlighting a source line.
-
-        Example with colno and end_colno pointing to the bar expression:
-                   "foo() + bar()"
-        returns    "        ^^^^^"
-        """
-        if lineno != end_lineno:
-            # Don't handle expressions that span multiple lines.
-            return []
-        if colno is None or end_colno is None:
-            # Can't do anything without column information.
-            return []
-
-        num_stripped_chars = len(raw_line) - len(line)
-
-        start_char_offset = _byte_offset_to_character_offset(raw_line, colno)
-        end_char_offset = _byte_offset_to_character_offset(raw_line, end_colno)
-        num_carets = end_char_offset - start_char_offset
-        # If the highlight would span the whole line, it is redundant, don't
-        # show it.
-        if num_carets >= len(line.strip()):
-            return []
-
-        highlights = "    "
-        highlights += " " * (start_char_offset - num_stripped_chars + 1)
-        highlights += "^" * num_carets
-        return [highlights]
-
-    def get_exconly(
-        self,
-        excinfo: ExceptionInfo[BaseException],
-        indent: int = 4,
-        markall: bool = False,
-    ) -> list[str]:
-        lines = []
-        indentstr = " " * indent
-        # Get the real exception information out.
-        exlines = excinfo.exconly(tryshort=True).split("\n")
-        failindent = self.fail_marker + indentstr[1:]
-        for line in exlines:
-            lines.append(failindent + line)
-            if not markall:
-                failindent = indentstr
-        return lines
-
-    def repr_locals(self, locals: Mapping[str, object]) -> ReprLocals | None:
-        if self.showlocals:
-            lines = []
-            # Variables starting with `@` are helpers injected by assertion
-            # rewriting, not user variables, so hide them.
-            keys = [loc for loc in locals if loc[0] != "@"]
-            keys.sort()
-            for name in keys:
-                value = locals[name]
-                if name == "__builtins__":
-                    lines.append("__builtins__ = <builtins>")
-                else:
-                    # This formatting could all be handled by the
-                    # _repr() function, which is only reprlib.Repr in
-                    # disguise, so is very configurable.
-                    if self.truncate_locals:
-                        str_repr = saferepr(value)
-                    else:
-                        str_repr = safeformat(value)
-                    # if len(str_repr) < 70 or not isinstance(value, (list, tuple, dict)):
-                    lines.append(f"{name:<10} = {str_repr}")
-                    # else:
-                    #    self._line("%-10s =\\" % (name,))
-                    #    # XXX
-                    #    pprint.pprint(value, stream=self.excinfowriter)
-            return ReprLocals(lines)
-        return None
-
-    def repr_traceback_entry(
-        self,
-        entry: TracebackEntry | None,
-        excinfo: ExceptionInfo[BaseException] | None = None,
-    ) -> ReprEntry:
-        lines: list[str] = []
-        style = (
-            entry._repr_style
-            if entry is not None and entry._repr_style is not None
-            else self.style
-        )
-        if style in ("short", "long") and entry is not None:
-            source = self._getentrysource(entry)
-            if source is None:
-                source = Source("???")
-                line_index = 0
-                end_line_index, colno, end_colno = None, None, None
-            else:
-                line_index = entry.relline
-                end_line_index = entry.end_lineno_relative
-                colno = entry.colno
-                end_colno = entry.end_colno
-            short = style == "short"
-            reprargs = self.repr_args(entry) if not short else None
-            s = self.get_source(
-                source=source,
-                line_index=line_index,
-                excinfo=excinfo,
-                short=short,
-                end_line_index=end_line_index,
-                colno=colno,
-                end_colno=end_colno,
-            )
-            lines.extend(s)
-            if short:
-                message = f"in {entry.name}"
-            else:
-                message = (excinfo and excinfo.typename) or ""
-            entry_path = entry.path
-            path = self._makepath(entry_path)
-            reprfileloc = ReprFileLocation(path, entry.lineno + 1, message)
-            localsrepr = self.repr_locals(entry.locals)
-            return ReprEntry(lines, reprargs, localsrepr, reprfileloc, style)
-        elif style == "value":
-            if excinfo:
-                lines.extend(str(excinfo.value).split("\n"))
-            return ReprEntry(lines, None, None, None, style)
-        else:
-            if excinfo:
-                lines.extend(self.get_exconly(excinfo, indent=4))
-            return ReprEntry(lines, None, None, None, style)
-
-    def _makepath(self, path: Path | str) -> str:
-        if not self.abspath and isinstance(path, Path):
-            try:
-                np = bestrelpath(Path.cwd(), path)
-            except OSError:
-                return str(path)
-            if len(np) < len(str(path)):
-                return np
-        return str(path)
-
-    def repr_traceback(self, excinfo: ExceptionInfo[BaseException]) -> ReprTraceback:
-        traceback = filter_excinfo_traceback(self.tbfilter, excinfo)
-
-        if isinstance(excinfo.value, RecursionError):
-            traceback, extraline = self._truncate_recursive_traceback(traceback)
-        else:
-            extraline = None
-
-        if not traceback:
-            if extraline is None:
-                extraline = "All traceback entries are hidden. Pass `--full-trace` to see hidden and internal frames."
-            entries = [self.repr_traceback_entry(None, excinfo)]
-            return ReprTraceback(entries, extraline, style=self.style)
-
-        last = traceback[-1]
-        if self.style == "value":
-            entries = [self.repr_traceback_entry(last, excinfo)]
-            return ReprTraceback(entries, None, style=self.style)
-
-        entries = [
-            self.repr_traceback_entry(entry, excinfo if last == entry else None)
-            for entry in traceback
-        ]
-        return ReprTraceback(entries, extraline, style=self.style)
-
-    def _truncate_recursive_traceback(
-        self, traceback: Traceback
-    ) -> tuple[Traceback, str | None]:
-        """Truncate the given recursive traceback trying to find the starting
-        point of the recursion.
-
-        The detection is done by going through each traceback entry and
-        finding the point in which the locals of the frame are equal to the
-        locals of a previous frame (see ``recursionindex()``).
-
-        Handle the situation where the recursion process might raise an
-        exception (for example comparing numpy arrays using equality raises a
-        TypeError), in which case we do our best to warn the user of the
-        error and show a limited traceback.
-        """
-        try:
-            recursionindex = traceback.recursionindex()
-        except Exception as e:
-            max_frames = 10
-            extraline: str | None = (
-                "!!! Recursion error detected, but an error occurred locating the origin of recursion.\n"
-                "  The following exception happened when comparing locals in the stack frame:\n"
-                f"    {type(e).__name__}: {e!s}\n"
-                f"  Displaying first and last {max_frames} stack frames out of {len(traceback)}."
-            )
-            # Type ignored because adding two instances of a List subtype
-            # currently incorrectly has type List instead of the subtype.
-            traceback = traceback[:max_frames] + traceback[-max_frames:]  # type: ignore
-        else:
-            if recursionindex is not None:
-                extraline = "!!! Recursion detected (same locals & position)"
-                traceback = traceback[: recursionindex + 1]
-            else:
-                extraline = None
-
-        return traceback, extraline
-
-    def repr_excinfo(self, excinfo: ExceptionInfo[BaseException]) -> ExceptionChainRepr:
-        repr_chain: list[tuple[ReprTraceback, ReprFileLocation | None, str | None]] = []
-        e: BaseException | None = excinfo.value
-        excinfo_: ExceptionInfo[BaseException] | None = excinfo
-        description = None
-        seen: set[int] = set()
-        while e is not None and id(e) not in seen:
-            seen.add(id(e))
-
-            if excinfo_:
-                # Fall back to native traceback as a temporary workaround until
-                # full support for exception groups added to ExceptionInfo.
-                # See https://github.com/pytest-dev/pytest/issues/9159
-                reprtraceback: ReprTraceback | ReprTracebackNative
-                if isinstance(e, BaseExceptionGroup):
-                    # don't filter any sub-exceptions since they shouldn't have any internal frames
-                    traceback = filter_excinfo_traceback(self.tbfilter, excinfo)
-                    extraline = (
-                        "All traceback entries are hidden. Pass `--full-trace` to see hidden and internal frames."
-                        if not traceback
-                        else None
-                    )
-                    reprtraceback = ReprTracebackNative(
-                        format_exception(
-                            type(excinfo.value),
-                            excinfo.value,
-                            traceback[0]._rawentry if traceback else None,
-                        ),
-                        extraline=extraline,
-                    )
-
-                else:
-                    reprtraceback = self.repr_traceback(excinfo_)
-                reprcrash = excinfo_._getreprcrash()
-            else:
-                # Fallback to native repr if the exception doesn't have a traceback:
-                # ExceptionInfo objects require a full traceback to work.
-                reprtraceback = ReprTracebackNative(format_exception(type(e), e, None))
-                reprcrash = None
-            repr_chain.append((reprtraceback, reprcrash, description))
-
-            if e.__cause__ is not None and self.chain:
-                e = e.__cause__
-                excinfo_ = ExceptionInfo.from_exception(e) if e.__traceback__ else None
-                description = "The above exception was the direct cause of the following exception:"
-            elif (
-                e.__context__ is not None and not e.__suppress_context__ and self.chain
-            ):
-                e = e.__context__
-                excinfo_ = ExceptionInfo.from_exception(e) if e.__traceback__ else None
-                description = "During handling of the above exception, another exception occurred:"
-            else:
-                e = None
-        repr_chain.reverse()
-        return ExceptionChainRepr(repr_chain)
-
-
-@dataclasses.dataclass(eq=False)
-class TerminalRepr:
-    """Base class for terminal representations -- pieces of data that display
-    themselves to a terminal."""
-
-    def __str__(self) -> str:
-        # FYI this is called from pytest-xdist's serialization of exception
-        # information.
-        io = StringIO()
-        tw = TerminalWriter(file=io)
-        self.toterminal(tw)
-        return io.getvalue().strip()
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__} instance at {id(self):0x}>"
-
-    def toterminal(self, tw: TerminalWriter) -> None:
-        raise NotImplementedError()
-
-
-@dataclasses.dataclass(eq=False)
-class ExceptionRepr(TerminalRepr):
-    """Base class for exception terminal representations.
-
-    The representation generally contains:
-    - The exception traceback (`reprtraceback`)
-    - The exception message and location (`reprcrash`)
-    - Separated, titled sections with additional data (pytest core doesn't use
-      this currently).
-    """
-
-    reprtraceback: ReprTraceback
-    reprcrash: ReprFileLocation | None
-    sections: list[tuple[str, str, str]] = dataclasses.field(
-        init=False, default_factory=list
-    )
-
-    def addsection(self, name: str, content: str, sep: str = "-") -> None:
-        self.sections.append((name, content, sep))
-
-    def toterminal(self, tw: TerminalWriter) -> None:
-        for name, content, sep in self.sections:
-            tw.sep(sep, name)
-            tw.line(content)
-
-
-@dataclasses.dataclass(eq=False)
-class ExceptionChainRepr(ExceptionRepr):
-    """A chain of exceptions, separated by descriptions (e.g. "The above
-    exception was the direct cause of the following exception")."""
-
-    chain: Sequence[tuple[ReprTraceback, ReprFileLocation | None, str | None]]
-
-    def __init__(
-        self,
-        chain: Sequence[tuple[ReprTraceback, ReprFileLocation | None, str | None]],
-    ) -> None:
-        # reprcrash and reprtraceback of the outermost (the newest) exception
-        # in the chain.
-        super().__init__(
-            reprtraceback=chain[-1][0],
-            reprcrash=chain[-1][1],
-        )
-        self.chain = chain
-
-    def toterminal(self, tw: TerminalWriter) -> None:
-        for reprtraceback, reprcrash, description in self.chain:
-            reprtraceback.toterminal(tw)
-            if description is not None:
-                tw.line("")
-                tw.line(description, yellow=True)
-        super().toterminal(tw)
-
-
-@dataclasses.dataclass(eq=False)
-class ReprExceptionInfo(ExceptionRepr):
-    """A single exception with optional extra details (function arguments,
-    function locals, file location) and possible extra line and sections emitted
-    at the end."""
-
-    def toterminal(self, tw: TerminalWriter) -> None:
-        self.reprtraceback.toterminal(tw)
-        super().toterminal(tw)
-
-
-@dataclasses.dataclass(eq=False)
-class ReprTraceback(TerminalRepr):
-    """A traceback with optional extra details (function arguments, function
-    locals, file location) and possible extra line emitted at the end."""
-
-    reprentries: Sequence[ReprEntry | ReprEntryNative]
-    extraline: str | None
-    style: TracebackStyle
-
-    entrysep: ClassVar = "_ "
-
-    def toterminal(self, tw: TerminalWriter) -> None:
-        # The entries might have different styles.
-        for i, entry in enumerate(self.reprentries):
-            if entry.style == "long":
-                tw.line("")
-            entry.toterminal(tw)
-            if i < len(self.reprentries) - 1:
-                next_entry = self.reprentries[i + 1]
-                if entry.style == "long" or (
-                    entry.style == "short" and next_entry.style == "long"
-                ):
-                    tw.sep(self.entrysep)
-
-        if self.extraline:
-            tw.line(self.extraline)
-
-
-class ReprTracebackNative(ReprTraceback):
-    """A traceback in native style.
-
-    The lines are emitted as is; uses a single entry for the entire native
-    traceback.
-    """
-
-    def __init__(self, tblines: Sequence[str], *, extraline: str | None = None) -> None:
-        self.reprentries = [ReprEntryNative(tblines)]
-        self.extraline = extraline
-        self.style = "native"
-
-
-@dataclasses.dataclass(eq=False)
-class ReprEntryNative(TerminalRepr):
-    """An entry in a traceback in native style.
-
-    Emits the lines as is. The lines are assumed to include the line separators.
-
-    [Note that we currently use a single "entry" for the entire native
-    traceback, so this is a bit misleading, but there's no point trying to parse
-    or split a native traceback.]
-    """
-
-    lines: Sequence[str]
-
-    style: ClassVar[TracebackStyle] = "native"
-
-    def toterminal(self, tw: TerminalWriter) -> None:
-        tw.write("".join(self.lines))
-
-
-@dataclasses.dataclass(eq=False)
-class ReprEntry(TerminalRepr):
-    """An entry in a traceback with possible extra details (function arguments,
-    function locals, source snippet, function's file and line)."""
-
-    lines: Sequence[str]
-    reprfuncargs: ReprFuncArgs | None
-    reprlocals: ReprLocals | None
-    reprfileloc: ReprFileLocation | None
-    style: TracebackStyle
-
-    def _write_entry_lines(self, tw: TerminalWriter) -> None:
-        """Write the source code portions of a list of traceback entries with syntax highlighting.
-
-        Usually entries are lines like these:
-
-            "     x = 1"
-            ">    assert x == 2"
-            "E    assert 1 == 2"
-
-        This function takes care of rendering the "source" portions of it (the lines without
-        the "E" prefix) using syntax highlighting, taking care to not highlighting the ">"
-        character, as doing so might break line continuations.
-        """
-        if not self.lines:
-            return
-
-        if self.style == "value":
-            # Using tw.write instead of tw.line for testing purposes due to TWMock implementation;
-            # lines written with TWMock.line and TWMock._write_source cannot be distinguished
-            # from each other, whereas lines written with TWMock.write are marked with TWMock.WRITE
-            for line in self.lines:
-                tw.write(line)
-                tw.write("\n")
-            return
-
-        # separate indents and source lines that are not failures: we want to
-        # highlight the code but not the indentation, which may contain markers
-        # such as ">   assert 0"
-        fail_marker = f"{ExceptionInfoFormatter.fail_marker}   "
-        indent_size = len(fail_marker)
-        indents: list[str] = []
-        source_lines: list[str] = []
-        failure_lines: list[str] = []
-        for index, line in enumerate(self.lines):
-            is_failure_line = line.startswith(fail_marker)
-            if is_failure_line:
-                # from this point on all lines are considered part of the failure
-                failure_lines.extend(self.lines[index:])
-                break
-            else:
-                indents.append(line[:indent_size])
-                source_lines.append(line[indent_size:])
-
-        tw._write_source(source_lines, indents)
-
-        # failure lines are always completely red and bold
-        for line in failure_lines:
-            tw.line(line, bold=True, red=True)
-
-    def toterminal(self, tw: TerminalWriter) -> None:
-        if self.style == "short":
-            if self.reprfileloc:
-                self.reprfileloc.toterminal(tw)
-            self._write_entry_lines(tw)
-            if self.reprlocals:
-                self.reprlocals.toterminal(tw, indent=" " * 8)
-            return
-
-        if self.reprfuncargs:
-            self.reprfuncargs.toterminal(tw)
-
-        self._write_entry_lines(tw)
-
-        if self.reprlocals:
-            tw.line("")
-            self.reprlocals.toterminal(tw)
-        if self.reprfileloc:
-            if self.lines:
-                tw.line("")
-            self.reprfileloc.toterminal(tw)
-
-    def __str__(self) -> str:
-        return "{}\n{}\n{}".format(
-            "\n".join(self.lines), self.reprlocals, self.reprfileloc
-        )
-
-
-@dataclasses.dataclass(eq=False)
-class ReprFileLocation(TerminalRepr):
-    """A message at a file location, using the `<path>:<lineno>: <message>`
-    format that most editors understand.
-
-    Only the first line of the message is emitted.
-    """
-
-    path: str
-    lineno: int
-    message: str
-
-    def __post_init__(self) -> None:
-        self.path = str(self.path)
-
-    def toterminal(self, tw: TerminalWriter) -> None:
-        msg = self.message
-        i = msg.find("\n")
-        if i != -1:
-            msg = msg[:i]
-        tw.write(self.path, bold=True, red=True)
-        tw.line(f":{self.lineno}: {msg}")
-
-
-@dataclasses.dataclass(eq=False)
-class ReprLocals(TerminalRepr):
-    """Function local variables (pre-formatted)."""
-
-    lines: Sequence[str]
-
-    def toterminal(self, tw: TerminalWriter, indent: str = "") -> None:
-        for line in self.lines:
-            tw.line(indent + line)
-
-
-@dataclasses.dataclass(eq=False)
-class ReprFuncArgs(TerminalRepr):
-    """Function arguments - name = value, comma separated."""
-
-    args: Sequence[tuple[str, object]]
-
-    def toterminal(self, tw: TerminalWriter) -> None:
-        if self.args:
-            linesofar = ""
-            for name, value in self.args:
-                ns = f"{name} = {value}"
-                if len(ns) + len(linesofar) + 2 > tw.fullwidth:
-                    if linesofar:
-                        tw.line(linesofar)
-                    linesofar = ns
-                else:
-                    if linesofar:
-                        linesofar += ", " + ns
-                    else:
-                        linesofar = ns
-            if linesofar:
-                tw.line(linesofar)
-            tw.line("")
-
-
-def getfslineno(obj: object) -> tuple[str | Path, int]:
-    """Return source location (path, lineno) for the given object.
-
-    If the source cannot be determined return ("", -1).
-
-    The line number is 0-based.
-    """
-    # xxx let decorators etc specify a sane ordering
-    # NOTE: this used to be done in _pytest.compat.getfslineno, initially added
-    #       in 6ec13a2b9.  It ("place_as") appears to be something very custom.
-    obj = get_real_func(obj)
-    if hasattr(obj, "place_as"):
-        obj = obj.place_as
-
-    try:
-        code = Code.from_function(obj)
-    except TypeError:
-        try:
-            fn = inspect.getsourcefile(obj) or inspect.getfile(obj)  # type: ignore[arg-type]
-        except TypeError:
-            return "", -1
-
-        fspath = (fn and absolutepath(fn)) or ""
-        lineno = -1
-        if fspath:
-            try:
-                _, lineno = findsource(obj)
-            except OSError:
-                pass
-        return fspath, lineno
-
-    return code.path, code.firstlineno
-
-
-def _byte_offset_to_character_offset(str, offset):
-    """Converts a byte based offset in a string to a code-point."""
-    as_utf8 = str.encode("utf-8")
-    return len(as_utf8[:offset].decode("utf-8", errors="replace"))
-
-
-# Relative paths that we use to filter traceback entries from appearing to the user;
-# see filter_traceback.
-# note: if we need to add more paths than what we have now we should probably use a list
-# for better maintenance.
-
-_PLUGGY_DIR = Path(pluggy.__file__.rstrip("oc"))
-# pluggy is either a package or a single module depending on the version
-if _PLUGGY_DIR.name == "__init__.py":
-    _PLUGGY_DIR = _PLUGGY_DIR.parent
-_PYTEST_DIR = Path(_pytest.__file__).parent
-
-
-def filter_traceback(entry: TracebackEntry) -> bool:
-    """Return True if a TracebackEntry instance should be included in tracebacks.
-
-    We hide traceback entries of:
-
-    * dynamically generated code (no code to show up for it);
-    * internal traceback from pytest or its internal libraries, py and pluggy.
-    """
-    # entry.path might sometimes return a str object when the entry
-    # points to dynamically generated code.
-    # See https://bitbucket.org/pytest-dev/py/issues/71.
-    raw_filename = entry.frame.code.raw.co_filename
-    is_generated = "<" in raw_filename and ">" in raw_filename
-    if is_generated:
-        return False
-
-    # entry.path might point to a non-existing file, in which case it will
-    # also return a str object. See #1133.
-    p = Path(entry.path)
-
-    parents = p.parents
-    if _PLUGGY_DIR in parents:
-        return False
-    if _PYTEST_DIR in parents:
-        return False
-
-    return True
-
-
-def filter_excinfo_traceback(
-    tbfilter: TracebackFilter, excinfo: ExceptionInfo[BaseException]
-) -> Traceback:
-    """Filter the exception traceback in ``excinfo`` according to ``tbfilter``."""
-    if callable(tbfilter):
-        return tbfilter(excinfo)
-    elif tbfilter:
-        return excinfo.traceback.filter(excinfo)
-    else:
-        return excinfo.traceback

venv/Lib/site-packages/_pytest/_code/source.py

@@ -1,228 +0,0 @@
-# mypy: allow-untyped-defs
-from __future__ import annotations
-
-import ast
-from bisect import bisect_right
-from collections.abc import Iterable
-from collections.abc import Iterator
-import inspect
-import textwrap
-import tokenize
-import types
-from typing import overload
-import warnings
-
-
-class Source:
-    """An immutable object holding a source code fragment.
-
-    When using Source(...), the source lines are deindented.
-    """
-
-    def __init__(self, obj: object = None) -> None:
-        if not obj:
-            self.lines: list[str] = []
-            self.raw_lines: list[str] = []
-        elif isinstance(obj, Source):
-            self.lines = obj.lines
-            self.raw_lines = obj.raw_lines
-        elif isinstance(obj, tuple | list):
-            self.lines = deindent(x.rstrip("\n") for x in obj)
-            self.raw_lines = list(x.rstrip("\n") for x in obj)
-        elif isinstance(obj, str):
-            self.lines = deindent(obj.split("\n"))
-            self.raw_lines = obj.split("\n")
-        else:
-            try:
-                rawcode = getrawcode(obj)
-                src = inspect.getsource(rawcode)
-            except TypeError:
-                src = inspect.getsource(obj)  # type: ignore[arg-type]
-            self.lines = deindent(src.split("\n"))
-            self.raw_lines = src.split("\n")
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Source):
-            return NotImplemented
-        return self.lines == other.lines
-
-    # Ignore type because of https://github.com/python/mypy/issues/4266.
-    __hash__ = None  # type: ignore
-
-    @overload
-    def __getitem__(self, key: int) -> str: ...
-
-    @overload
-    def __getitem__(self, key: slice) -> Source: ...
-
-    def __getitem__(self, key: int | slice) -> str | Source:
-        if isinstance(key, int):
-            return self.lines[key]
-        else:
-            if key.step not in (None, 1):
-                raise IndexError("cannot slice a Source with a step")
-            newsource = Source()
-            newsource.lines = self.lines[key.start : key.stop]
-            newsource.raw_lines = self.raw_lines[key.start : key.stop]
-            return newsource
-
-    def __iter__(self) -> Iterator[str]:
-        return iter(self.lines)
-
-    def __len__(self) -> int:
-        return len(self.lines)
-
-    def strip(self) -> Source:
-        """Return new Source object with trailing and leading blank lines removed."""
-        start, end = 0, len(self)
-        while start < end and not self.lines[start].strip():
-            start += 1
-        while end > start and not self.lines[end - 1].strip():
-            end -= 1
-        source = Source()
-        source.raw_lines = self.raw_lines
-        source.lines[:] = self.lines[start:end]
-        return source
-
-    def indent(self, indent: str = " " * 4) -> Source:
-        """Return a copy of the source object with all lines indented by the
-        given indent-string."""
-        newsource = Source()
-        newsource.raw_lines = self.raw_lines
-        newsource.lines = [(indent + line) for line in self.lines]
-        return newsource
-
-    def getstatement(self, lineno: int) -> Source:
-        """Return Source statement which contains the given linenumber
-        (counted from 0)."""
-        start, end = self.getstatementrange(lineno)
-        return self[start:end]
-
-    def getstatementrange(self, lineno: int) -> tuple[int, int]:
-        """Return (start, end) tuple which spans the minimal statement region
-        which containing the given lineno."""
-        if not (0 <= lineno < len(self)):
-            raise IndexError("lineno out of range")
-        _ast, start, end = getstatementrange_ast(lineno, self)
-        return start, end
-
-    def deindent(self) -> Source:
-        """Return a new Source object deindented."""
-        newsource = Source()
-        newsource.lines[:] = deindent(self.lines)
-        newsource.raw_lines = self.raw_lines
-        return newsource
-
-    def __str__(self) -> str:
-        return "\n".join(self.lines)
-
-
-#
-# helper functions
-#
-
-
-def findsource(obj) -> tuple[Source | None, int]:
-    try:
-        sourcelines, lineno = inspect.findsource(obj)
-    except Exception:
-        return None, -1
-    source = Source()
-    source.lines = [line.rstrip() for line in sourcelines]
-    source.raw_lines = sourcelines
-    return source, lineno
-
-
-def getrawcode(obj: object, trycall: bool = True) -> types.CodeType:
-    """Return code object for given function."""
-    try:
-        return obj.__code__  # type: ignore[attr-defined,no-any-return]
-    except AttributeError:
-        pass
-    if trycall:
-        call = getattr(obj, "__call__", None)
-        if call and not isinstance(obj, type):
-            return getrawcode(call, trycall=False)
-    raise TypeError(f"could not get code object for {obj!r}")
-
-
-def deindent(lines: Iterable[str]) -> list[str]:
-    return textwrap.dedent("\n".join(lines)).splitlines()
-
-
-def get_statement_startend2(lineno: int, node: ast.AST) -> tuple[int, int | None]:
-    # Flatten all statements and except handlers into one lineno-list.
-    # AST's line numbers start indexing at 1.
-    values: list[int] = []
-    for x in ast.walk(node):
-        if isinstance(x, ast.stmt | ast.ExceptHandler):
-            # The lineno points to the class/def, so need to include the decorators.
-            if isinstance(x, ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef):
-                for d in x.decorator_list:
-                    values.append(d.lineno - 1)
-            values.append(x.lineno - 1)
-            for name in ("finalbody", "orelse"):
-                val: list[ast.stmt] | None = getattr(x, name, None)
-                if val:
-                    # Treat the finally/orelse part as its own statement.
-                    values.append(val[0].lineno - 1 - 1)
-    values.sort()
-    insert_index = bisect_right(values, lineno)
-    if insert_index == 0:
-        return 0, None
-    start = values[insert_index - 1]
-    if insert_index >= len(values):
-        end = None
-    else:
-        end = values[insert_index]
-    return start, end
-
-
-def getstatementrange_ast(
-    lineno: int,
-    source: Source,
-    assertion: bool = False,
-    astnode: ast.AST | None = None,
-) -> tuple[ast.AST, int, int]:
-    if astnode is None:
-        content = str(source)
-        # See #4260:
-        # Don't produce duplicate warnings when compiling source to find AST.
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            astnode = ast.parse(content, "source", "exec")
-
-    start, end = get_statement_startend2(lineno, astnode)
-    # We need to correct the end:
-    # - ast-parsing strips comments
-    # - there might be empty lines
-    # - we might have lesser indented code blocks at the end
-    if end is None:
-        end = len(source.lines)
-
-    if end > start + 1:
-        # Make sure we don't span differently indented code blocks
-        # by using the BlockFinder helper used which inspect.getsource() uses itself.
-        block_finder = inspect.BlockFinder()
-        # If we start with an indented line, put blockfinder to "started" mode.
-        block_finder.started = (
-            bool(source.lines[start]) and source.lines[start][0].isspace()
-        )
-        it = ((x + "\n") for x in source.lines[start:end])
-        try:
-            for tok in tokenize.generate_tokens(lambda: next(it)):
-                block_finder.tokeneater(*tok)
-        except (inspect.EndOfBlock, IndentationError):
-            end = block_finder.last + start
-        except Exception:
-            pass
-
-    # The end might still point to a comment or empty line, correct it.
-    end = min(end, len(source.lines))
-    while end:
-        line = source.lines[end - 1].lstrip()
-        if line.startswith("#") or not line:
-            end -= 1
-        else:
-            break
-    return astnode, start, end

venv/Lib/site-packages/_pytest/_io/__init__.py

@@ -1,10 +0,0 @@
-from __future__ import annotations
-
-from .terminalwriter import get_terminal_width
-from .terminalwriter import TerminalWriter
-
-
-__all__ = [
-    "TerminalWriter",
-    "get_terminal_width",
-]

venv/Lib/site-packages/_pytest/_io/pprint.py

@@ -1,673 +0,0 @@
-# mypy: allow-untyped-defs
-# This module was imported from the cpython standard library
-# (https://github.com/python/cpython/) at commit
-# c5140945c723ae6c4b7ee81ff720ac8ea4b52cfd (python3.12).
-#
-#
-#  Original Author:      Fred L. Drake, Jr.
-#                        fdrake@acm.org
-#
-#  This is a simple little module I wrote to make life easier.  I didn't
-#  see anything quite like it in the library, though I may have overlooked
-#  something.  I wrote this when I was trying to read some heavily nested
-#  tuples with fairly non-descriptive content.  This is modeled very much
-#  after Lisp/Scheme - style pretty-printing of lists.  If you find it
-#  useful, thank small children who sleep at night.
-from __future__ import annotations
-
-import collections as _collections
-from collections.abc import Callable
-from collections.abc import Iterator
-import dataclasses as _dataclasses
-from io import StringIO as _StringIO
-import re
-import types as _types
-from typing import Any
-from typing import IO
-
-
-class _safe_key:
-    """Helper function for key functions when sorting unorderable objects.
-
-    The wrapped-object will fallback to a Py2.x style comparison for
-    unorderable types (sorting first comparing the type name and then by
-    the obj ids).  Does not work recursively, so dict.items() must have
-    _safe_key applied to both the key and the value.
-
-    """
-
-    __slots__ = ["obj"]
-
-    def __init__(self, obj):
-        self.obj = obj
-
-    def __lt__(self, other):
-        try:
-            return self.obj < other.obj
-        except TypeError:
-            return (str(type(self.obj)), id(self.obj)) < (
-                str(type(other.obj)),
-                id(other.obj),
-            )
-
-
-def _safe_tuple(t):
-    """Helper function for comparing 2-tuples"""
-    return _safe_key(t[0]), _safe_key(t[1])
-
-
-class PrettyPrinter:
-    def __init__(
-        self,
-        indent: int = 4,
-        width: int = 80,
-        depth: int | None = None,
-    ) -> None:
-        """Handle pretty printing operations onto a stream using a set of
-        configured parameters.
-
-        indent
-            Number of spaces to indent for each level of nesting.
-
-        width
-            Attempted maximum number of columns in the output.
-
-        depth
-            The maximum depth to print out nested structures.
-
-        """
-        if indent < 0:
-            raise ValueError("indent must be >= 0")
-        if depth is not None and depth <= 0:
-            raise ValueError("depth must be > 0")
-        if not width:
-            raise ValueError("width must be != 0")
-        self._depth = depth
-        self._indent_per_level = indent
-        self._width = width
-
-    def pformat(self, object: Any) -> str:
-        sio = _StringIO()
-        self._format(object, sio, 0, 0, set(), 0)
-        return sio.getvalue()
-
-    def _format(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        objid = id(object)
-        if objid in context:
-            stream.write(_recursion(object))
-            return
-
-        p = self._dispatch.get(type(object).__repr__, None)
-        if p is not None:
-            context.add(objid)
-            p(self, object, stream, indent, allowance, context, level + 1)
-            context.remove(objid)
-        elif (
-            _dataclasses.is_dataclass(object)
-            and not isinstance(object, type)
-            and object.__dataclass_params__.repr  # type:ignore[attr-defined]
-            and
-            # Check dataclass has generated repr method.
-            hasattr(object.__repr__, "__wrapped__")
-            and "__create_fn__" in object.__repr__.__wrapped__.__qualname__
-        ):
-            context.add(objid)
-            self._pprint_dataclass(
-                object, stream, indent, allowance, context, level + 1
-            )
-            context.remove(objid)
-        else:
-            stream.write(self._repr(object, context, level))
-
-    def _pprint_dataclass(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        cls_name = object.__class__.__name__
-        items = [
-            (f.name, getattr(object, f.name))
-            for f in _dataclasses.fields(object)
-            if f.repr
-        ]
-        stream.write(cls_name + "(")
-        self._format_namespace_items(items, stream, indent, allowance, context, level)
-        stream.write(")")
-
-    _dispatch: dict[
-        Callable[..., str],
-        Callable[[PrettyPrinter, Any, IO[str], int, int, set[int], int], None],
-    ] = {}
-
-    def _pprint_dict(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        write = stream.write
-        write("{")
-        items = object.items()
-        self._format_dict_items(items, stream, indent, allowance, context, level)
-        write("}")
-
-    _dispatch[dict.__repr__] = _pprint_dict
-
-    def _pprint_ordered_dict(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        if not len(object):
-            stream.write(repr(object))
-            return
-        cls = object.__class__
-        stream.write(cls.__name__ + "(")
-        self._pprint_dict(object, stream, indent, allowance, context, level)
-        stream.write(")")
-
-    _dispatch[_collections.OrderedDict.__repr__] = _pprint_ordered_dict
-
-    def _pprint_list(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        stream.write("[")
-        self._format_items(object, stream, indent, allowance, context, level)
-        stream.write("]")
-
-    _dispatch[list.__repr__] = _pprint_list
-
-    def _pprint_tuple(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        stream.write("(")
-        self._format_items(object, stream, indent, allowance, context, level)
-        stream.write(")")
-
-    _dispatch[tuple.__repr__] = _pprint_tuple
-
-    def _pprint_set(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        if not len(object):
-            stream.write(repr(object))
-            return
-        typ = object.__class__
-        if typ is set:
-            stream.write("{")
-            endchar = "}"
-        else:
-            stream.write(typ.__name__ + "({")
-            endchar = "})"
-        object = sorted(object, key=_safe_key)
-        self._format_items(object, stream, indent, allowance, context, level)
-        stream.write(endchar)
-
-    _dispatch[set.__repr__] = _pprint_set
-    _dispatch[frozenset.__repr__] = _pprint_set
-
-    def _pprint_str(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        write = stream.write
-        if not len(object):
-            write(repr(object))
-            return
-        chunks = []
-        lines = object.splitlines(True)
-        if level == 1:
-            indent += 1
-            allowance += 1
-        max_width1 = max_width = self._width - indent
-        for i, line in enumerate(lines):
-            rep = repr(line)
-            if i == len(lines) - 1:
-                max_width1 -= allowance
-            if len(rep) <= max_width1:
-                chunks.append(rep)
-            else:
-                # A list of alternating (non-space, space) strings
-                parts = re.findall(r"\S*\s*", line)
-                assert parts
-                assert not parts[-1]
-                parts.pop()  # drop empty last part
-                max_width2 = max_width
-                current = ""
-                for j, part in enumerate(parts):
-                    candidate = current + part
-                    if j == len(parts) - 1 and i == len(lines) - 1:
-                        max_width2 -= allowance
-                    if len(repr(candidate)) > max_width2:
-                        if current:
-                            chunks.append(repr(current))
-                        current = part
-                    else:
-                        current = candidate
-                if current:
-                    chunks.append(repr(current))
-        if len(chunks) == 1:
-            write(rep)
-            return
-        if level == 1:
-            write("(")
-        for i, rep in enumerate(chunks):
-            if i > 0:
-                write("\n" + " " * indent)
-            write(rep)
-        if level == 1:
-            write(")")
-
-    _dispatch[str.__repr__] = _pprint_str
-
-    def _pprint_bytes(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        write = stream.write
-        if len(object) <= 4:
-            write(repr(object))
-            return
-        parens = level == 1
-        if parens:
-            indent += 1
-            allowance += 1
-            write("(")
-        delim = ""
-        for rep in _wrap_bytes_repr(object, self._width - indent, allowance):
-            write(delim)
-            write(rep)
-            if not delim:
-                delim = "\n" + " " * indent
-        if parens:
-            write(")")
-
-    _dispatch[bytes.__repr__] = _pprint_bytes
-
-    def _pprint_bytearray(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        write = stream.write
-        write("bytearray(")
-        self._pprint_bytes(
-            bytes(object), stream, indent + 10, allowance + 1, context, level + 1
-        )
-        write(")")
-
-    _dispatch[bytearray.__repr__] = _pprint_bytearray
-
-    def _pprint_mappingproxy(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        stream.write("mappingproxy(")
-        self._format(object.copy(), stream, indent, allowance, context, level)
-        stream.write(")")
-
-    _dispatch[_types.MappingProxyType.__repr__] = _pprint_mappingproxy
-
-    def _pprint_simplenamespace(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        if type(object) is _types.SimpleNamespace:
-            # The SimpleNamespace repr is "namespace" instead of the class
-            # name, so we do the same here. For subclasses; use the class name.
-            cls_name = "namespace"
-        else:
-            cls_name = object.__class__.__name__
-        items = object.__dict__.items()
-        stream.write(cls_name + "(")
-        self._format_namespace_items(items, stream, indent, allowance, context, level)
-        stream.write(")")
-
-    _dispatch[_types.SimpleNamespace.__repr__] = _pprint_simplenamespace
-
-    def _format_dict_items(
-        self,
-        items: list[tuple[Any, Any]],
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        if not items:
-            return
-
-        write = stream.write
-        item_indent = indent + self._indent_per_level
-        delimnl = "\n" + " " * item_indent
-        for key, ent in items:
-            write(delimnl)
-            write(self._repr(key, context, level))
-            write(": ")
-            self._format(ent, stream, item_indent, 1, context, level)
-            write(",")
-
-        write("\n" + " " * indent)
-
-    def _format_namespace_items(
-        self,
-        items: list[tuple[Any, Any]],
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        if not items:
-            return
-
-        write = stream.write
-        item_indent = indent + self._indent_per_level
-        delimnl = "\n" + " " * item_indent
-        for key, ent in items:
-            write(delimnl)
-            write(key)
-            write("=")
-            if id(ent) in context:
-                # Special-case representation of recursion to match standard
-                # recursive dataclass repr.
-                write("...")
-            else:
-                self._format(
-                    ent,
-                    stream,
-                    item_indent + len(key) + 1,
-                    1,
-                    context,
-                    level,
-                )
-
-            write(",")
-
-        write("\n" + " " * indent)
-
-    def _format_items(
-        self,
-        items: list[Any],
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        if not items:
-            return
-
-        write = stream.write
-        item_indent = indent + self._indent_per_level
-        delimnl = "\n" + " " * item_indent
-
-        for item in items:
-            write(delimnl)
-            self._format(item, stream, item_indent, 1, context, level)
-            write(",")
-
-        write("\n" + " " * indent)
-
-    def _repr(self, object: Any, context: set[int], level: int) -> str:
-        return self._safe_repr(object, context.copy(), self._depth, level)
-
-    def _pprint_default_dict(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        rdf = self._repr(object.default_factory, context, level)
-        stream.write(f"{object.__class__.__name__}({rdf}, ")
-        self._pprint_dict(object, stream, indent, allowance, context, level)
-        stream.write(")")
-
-    _dispatch[_collections.defaultdict.__repr__] = _pprint_default_dict
-
-    def _pprint_counter(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        stream.write(object.__class__.__name__ + "(")
-
-        if object:
-            stream.write("{")
-            items = object.most_common()
-            self._format_dict_items(items, stream, indent, allowance, context, level)
-            stream.write("}")
-
-        stream.write(")")
-
-    _dispatch[_collections.Counter.__repr__] = _pprint_counter
-
-    def _pprint_chain_map(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        if not len(object.maps) or (len(object.maps) == 1 and not len(object.maps[0])):
-            stream.write(repr(object))
-            return
-
-        stream.write(object.__class__.__name__ + "(")
-        self._format_items(object.maps, stream, indent, allowance, context, level)
-        stream.write(")")
-
-    _dispatch[_collections.ChainMap.__repr__] = _pprint_chain_map
-
-    def _pprint_deque(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        stream.write(object.__class__.__name__ + "(")
-        if object.maxlen is not None:
-            stream.write(f"maxlen={object.maxlen}, ")
-        stream.write("[")
-
-        self._format_items(object, stream, indent, allowance + 1, context, level)
-        stream.write("])")
-
-    _dispatch[_collections.deque.__repr__] = _pprint_deque
-
-    def _pprint_user_dict(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        self._format(object.data, stream, indent, allowance, context, level - 1)
-
-    _dispatch[_collections.UserDict.__repr__] = _pprint_user_dict
-
-    def _pprint_user_list(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        self._format(object.data, stream, indent, allowance, context, level - 1)
-
-    _dispatch[_collections.UserList.__repr__] = _pprint_user_list
-
-    def _pprint_user_string(
-        self,
-        object: Any,
-        stream: IO[str],
-        indent: int,
-        allowance: int,
-        context: set[int],
-        level: int,
-    ) -> None:
-        self._format(object.data, stream, indent, allowance, context, level - 1)
-
-    _dispatch[_collections.UserString.__repr__] = _pprint_user_string
-
-    def _safe_repr(
-        self, object: Any, context: set[int], maxlevels: int | None, level: int
-    ) -> str:
-        typ = type(object)
-        if typ in _builtin_scalars:
-            return repr(object)
-
-        r = getattr(typ, "__repr__", None)
-
-        if issubclass(typ, dict) and r is dict.__repr__:
-            if not object:
-                return "{}"
-            objid = id(object)
-            if maxlevels and level >= maxlevels:
-                return "{...}"
-            if objid in context:
-                return _recursion(object)
-            context.add(objid)
-            components: list[str] = []
-            append = components.append
-            level += 1
-            for k, v in object.items():
-                krepr = self._safe_repr(k, context, maxlevels, level)
-                vrepr = self._safe_repr(v, context, maxlevels, level)
-                append(f"{krepr}: {vrepr}")
-            context.remove(objid)
-            return "{{{}}}".format(", ".join(components))
-
-        if (issubclass(typ, list) and r is list.__repr__) or (
-            issubclass(typ, tuple) and r is tuple.__repr__
-        ):
-            if issubclass(typ, list):
-                if not object:
-                    return "[]"
-                format = "[%s]"
-            elif len(object) == 1:
-                format = "(%s,)"
-            else:
-                if not object:
-                    return "()"
-                format = "(%s)"
-            objid = id(object)
-            if maxlevels and level >= maxlevels:
-                return format % "..."
-            if objid in context:
-                return _recursion(object)
-            context.add(objid)
-            components = []
-            append = components.append
-            level += 1
-            for o in object:
-                orepr = self._safe_repr(o, context, maxlevels, level)
-                append(orepr)
-            context.remove(objid)
-            return format % ", ".join(components)
-
-        return repr(object)
-
-
-_builtin_scalars = frozenset(
-    {str, bytes, bytearray, float, complex, bool, type(None), int}
-)
-
-
-def _recursion(object: Any) -> str:
-    return f"<Recursion on {type(object).__name__} with id={id(object)}>"
-
-
-def _wrap_bytes_repr(object: Any, width: int, allowance: int) -> Iterator[str]:
-    current = b""
-    last = len(object) // 4 * 4
-    for i in range(0, len(object), 4):
-        part = object[i : i + 4]
-        candidate = current + part
-        if i == last:
-            width -= allowance
-        if len(repr(candidate)) > width:
-            if current:
-                yield repr(current)
-            current = part
-        else:
-            current = candidate
-    if current:
-        yield repr(current)

venv/Lib/site-packages/_pytest/_io/saferepr.py

@@ -1,155 +0,0 @@
-from __future__ import annotations
-
-from itertools import islice
-import pprint
-import reprlib
-
-
-def _try_repr_or_str(obj: object) -> str:
-    try:
-        return repr(obj)
-    except (KeyboardInterrupt, SystemExit):
-        raise
-    except BaseException:
-        return f'{type(obj).__name__}("{obj}")'
-
-
-def _format_repr_exception(exc: BaseException, obj: object) -> str:
-    try:
-        exc_info = _try_repr_or_str(exc)
-    except (KeyboardInterrupt, SystemExit):
-        raise
-    except BaseException as inner_exc:
-        exc_info = f"unpresentable exception ({_try_repr_or_str(inner_exc)})"
-    return (
-        f"<[{exc_info} raised in repr()] {type(obj).__name__} object at 0x{id(obj):x}>"
-    )
-
-
-def _ellipsize(s: str, maxsize: int) -> str:
-    if len(s) > maxsize:
-        i = max(0, (maxsize - 3) // 2)
-        j = max(0, maxsize - 3 - i)
-        return s[:i] + "..." + s[len(s) - j :]
-    return s
-
-
-class SafeRepr(reprlib.Repr):
-    """
-    repr.Repr that limits the resulting size of repr() and includes
-    information on exceptions raised during the call.
-    """
-
-    def __init__(self, maxsize: int | None, use_ascii: bool = False) -> None:
-        """
-        :param maxsize:
-            If not None, will truncate the resulting repr to that specific size, using ellipsis
-            somewhere in the middle to hide the extra text.
-            If None, will not impose any size limits on the returning repr.
-        """
-        super().__init__()
-        # ``maxstring`` is used by the superclass, and needs to be an int; using a
-        # very large number in case maxsize is None, meaning we want to disable
-        # truncation.
-        self.maxstring = maxsize if maxsize is not None else 1_000_000_000
-        self.maxsize = maxsize
-        self.use_ascii = use_ascii
-
-    def repr(self, x: object) -> str:
-        try:
-            if self.use_ascii:
-                s = ascii(x)
-            else:
-                s = super().repr(x)
-        except (KeyboardInterrupt, SystemExit):
-            raise
-        except BaseException as exc:
-            s = _format_repr_exception(exc, x)
-        if self.maxsize is not None:
-            s = _ellipsize(s, self.maxsize)
-        return s
-
-    def repr_instance(self, x: object, level: int) -> str:
-        try:
-            s = repr(x)
-        except (KeyboardInterrupt, SystemExit):
-            raise
-        except BaseException as exc:
-            s = _format_repr_exception(exc, x)
-        if self.maxsize is not None:
-            s = _ellipsize(s, self.maxsize)
-
-        return s
-
-    def repr_dict(self, x: dict[object, object], level: int) -> str:
-        """Represent a dict while preserving its insertion order.
-
-        Differs from ``reprlib.Repr.repr_dict`` by iterating directly over ``x``
-        rather than using the stdlib's sorting helper.
-        """
-        fillvalue = "..."
-        n = len(x)
-        if n == 0:
-            return "{}"
-        if level <= 0:
-            return "{" + fillvalue + "}"
-        newlevel = level - 1
-        repr1 = self.repr1
-        pieces = []
-        for key in islice(x, self.maxdict):
-            keyrepr = repr1(key, newlevel)
-            valrepr = repr1(x[key], newlevel)
-            pieces.append(f"{keyrepr}: {valrepr}")
-        if n > self.maxdict:
-            pieces.append(fillvalue)
-        return "{" + ", ".join(pieces) + "}"
-
-
-def safeformat(obj: object) -> str:
-    """Return a pretty printed string for the given object.
-
-    Failing __repr__ functions of user instances will be represented
-    with a short exception info.
-    """
-    try:
-        return pprint.pformat(obj)
-    except Exception as exc:
-        return _format_repr_exception(exc, obj)
-
-
-# Maximum size of overall repr of objects to display during assertion errors.
-DEFAULT_REPR_MAX_SIZE = 240
-
-
-def saferepr(
-    obj: object, maxsize: int | None = DEFAULT_REPR_MAX_SIZE, use_ascii: bool = False
-) -> str:
-    """Return a size-limited safe repr-string for the given object.
-
-    Failing __repr__ functions of user instances will be represented
-    with a short exception info and 'saferepr' generally takes
-    care to never raise exceptions itself.
-
-    This function is a wrapper around the Repr/reprlib functionality of the
-    stdlib.
-    """
-    return SafeRepr(maxsize, use_ascii).repr(obj)
-
-
-def saferepr_unlimited(obj: object, use_ascii: bool = True) -> str:
-    """Return an unlimited-size safe repr-string for the given object.
-
-    As with saferepr, failing __repr__ functions of user instances
-    will be represented with a short exception info.
-
-    This function is a wrapper around simple repr.
-
-    Note: a cleaner solution would be to alter ``saferepr``this way
-    when maxsize=None, but that might affect some other code.
-    """
-    try:
-        if use_ascii:
-            return ascii(obj)
-        return repr(obj)
-    except Exception as exc:
-        return _format_repr_exception(exc, obj)

venv/Lib/site-packages/_pytest/_io/terminalwriter.py

@@ -1,258 +0,0 @@
-"""Helper functions for writing to terminals and files."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-import os
-import shutil
-import sys
-from typing import final
-from typing import Literal
-from typing import TextIO
-
-import pygments
-from pygments.formatters.terminal import TerminalFormatter
-from pygments.lexer import Lexer
-from pygments.lexers.diff import DiffLexer
-from pygments.lexers.python import PythonLexer
-
-from ..compat import assert_never
-from .wcwidth import wcswidth
-
-
-# This code was initially copied from py 1.8.1, file _io/terminalwriter.py.
-
-
-def get_terminal_width() -> int:
-    width, _ = shutil.get_terminal_size(fallback=(80, 24))
-
-    # The Windows get_terminal_size may be bogus, let's sanify a bit.
-    if width < 40:
-        width = 80
-
-    return width
-
-
-def should_do_markup(file: TextIO) -> bool:
-    if os.environ.get("PY_COLORS") == "1":
-        return True
-    if os.environ.get("PY_COLORS") == "0":
-        return False
-    if os.environ.get("NO_COLOR"):
-        return False
-    if os.environ.get("FORCE_COLOR"):
-        return True
-    return (
-        hasattr(file, "isatty") and file.isatty() and os.environ.get("TERM") != "dumb"
-    )
-
-
-@final
-class TerminalWriter:
-    _esctable = dict(
-        black=30,
-        red=31,
-        green=32,
-        yellow=33,
-        blue=34,
-        purple=35,
-        cyan=36,
-        white=37,
-        Black=40,
-        Red=41,
-        Green=42,
-        Yellow=43,
-        Blue=44,
-        Purple=45,
-        Cyan=46,
-        White=47,
-        bold=1,
-        light=2,
-        blink=5,
-        invert=7,
-    )
-
-    def __init__(self, file: TextIO | None = None) -> None:
-        if file is None:
-            file = sys.stdout
-        if hasattr(file, "isatty") and file.isatty() and sys.platform == "win32":
-            try:
-                import colorama
-            except ImportError:
-                pass
-            else:
-                file = colorama.AnsiToWin32(file).stream
-                assert file is not None
-        self._file = file
-        self.hasmarkup = should_do_markup(file)
-        self._current_line = ""
-        self._terminal_width: int | None = None
-        self.code_highlight = True
-
-    @property
-    def fullwidth(self) -> int:
-        if self._terminal_width is not None:
-            return self._terminal_width
-        return get_terminal_width()
-
-    @fullwidth.setter
-    def fullwidth(self, value: int) -> None:
-        self._terminal_width = value
-
-    @property
-    def width_of_current_line(self) -> int:
-        """Return an estimate of the width so far in the current line."""
-        return wcswidth(self._current_line)
-
-    def markup(self, text: str, **markup: bool) -> str:
-        for name in markup:
-            if name not in self._esctable:
-                raise ValueError(f"unknown markup: {name!r}")
-        if self.hasmarkup:
-            esc = [self._esctable[name] for name, on in markup.items() if on]
-            if esc:
-                text = "".join(f"\x1b[{cod}m" for cod in esc) + text + "\x1b[0m"
-        return text
-
-    def sep(
-        self,
-        sepchar: str,
-        title: str | None = None,
-        fullwidth: int | None = None,
-        **markup: bool,
-    ) -> None:
-        if fullwidth is None:
-            fullwidth = self.fullwidth
-        # The goal is to have the line be as long as possible
-        # under the condition that len(line) <= fullwidth.
-        if sys.platform == "win32":
-            # If we print in the last column on windows we are on a
-            # new line but there is no way to verify/neutralize this
-            # (we may not know the exact line width).
-            # So let's be defensive to avoid empty lines in the output.
-            fullwidth -= 1
-        if title is not None:
-            # we want 2 + 2*len(fill) + len(title) <= fullwidth
-            # i.e.    2 + 2*len(sepchar)*N + len(title) <= fullwidth
-            #         2*len(sepchar)*N <= fullwidth - len(title) - 2
-            #         N <= (fullwidth - len(title) - 2) // (2*len(sepchar))
-            N = max((fullwidth - len(title) - 2) // (2 * len(sepchar)), 1)
-            fill = sepchar * N
-            line = f"{fill} {title} {fill}"
-        else:
-            # we want len(sepchar)*N <= fullwidth
-            # i.e.    N <= fullwidth // len(sepchar)
-            line = sepchar * (fullwidth // len(sepchar))
-        # In some situations there is room for an extra sepchar at the right,
-        # in particular if we consider that with a sepchar like "_ " the
-        # trailing space is not important at the end of the line.
-        if len(line) + len(sepchar.rstrip()) <= fullwidth:
-            line += sepchar.rstrip()
-
-        self.line(line, **markup)
-
-    def write(self, msg: str, *, flush: bool = False, **markup: bool) -> None:
-        if msg:
-            current_line = msg.rsplit("\n", 1)[-1]
-            if "\n" in msg:
-                self._current_line = current_line
-            else:
-                self._current_line += current_line
-
-            msg = self.markup(msg, **markup)
-
-            self.write_raw(msg, flush=flush)
-
-    def write_raw(self, msg: str, *, flush: bool = False) -> None:
-        try:
-            self._file.write(msg)
-        except UnicodeEncodeError:
-            # Some environments don't support printing general Unicode
-            # strings, due to misconfiguration or otherwise; in that case,
-            # print the string escaped to ASCII.
-            # When the Unicode situation improves we should consider
-            # letting the error propagate instead of masking it (see #7475
-            # for one brief attempt).
-            msg = msg.encode("unicode-escape").decode("ascii")
-            self._file.write(msg)
-
-        if flush:
-            self.flush()
-
-    def line(self, s: str = "", **markup: bool) -> None:
-        self.write(s, **markup)
-        self.write("\n")
-
-    def flush(self) -> None:
-        self._file.flush()
-
-    def _write_source(self, lines: Sequence[str], indents: Sequence[str] = ()) -> None:
-        """Write lines of source code possibly highlighted.
-
-        Keeping this private for now because the API is clunky. We should discuss how
-        to evolve the terminal writer so we can have more precise color support, for example
-        being able to write part of a line in one color and the rest in another, and so on.
-        """
-        if indents and len(indents) != len(lines):
-            raise ValueError(
-                f"indents size ({len(indents)}) should have same size as lines ({len(lines)})"
-            )
-        if not indents:
-            indents = [""] * len(lines)
-        source = "\n".join(lines)
-        new_lines = self._highlight(source).splitlines()
-        # Would be better to strict=True but that fails some CI jobs.
-        for indent, new_line in zip(indents, new_lines, strict=False):
-            self.line(indent + new_line)
-
-    def _get_pygments_lexer(self, lexer: Literal["python", "diff"]) -> Lexer:
-        if lexer == "python":
-            return PythonLexer()
-        elif lexer == "diff":
-            return DiffLexer()
-        else:
-            assert_never(lexer)
-
-    def _get_pygments_formatter(self) -> TerminalFormatter:
-        from _pytest.config.exceptions import UsageError
-
-        theme = os.getenv("PYTEST_THEME")
-        theme_mode = os.getenv("PYTEST_THEME_MODE", "dark")
-
-        try:
-            return TerminalFormatter(bg=theme_mode, style=theme)
-        except pygments.util.ClassNotFound as e:
-            raise UsageError(
-                f"PYTEST_THEME environment variable has an invalid value: '{theme}'. "
-                "Hint: See available pygments styles with `pygmentize -L styles`."
-            ) from e
-        except pygments.util.OptionError as e:
-            raise UsageError(
-                f"PYTEST_THEME_MODE environment variable has an invalid value: '{theme_mode}'. "
-                "The allowed values are 'dark' (default) and 'light'."
-            ) from e
-
-    def _highlight(
-        self, source: str, lexer: Literal["diff", "python"] = "python"
-    ) -> str:
-        """Highlight the given source if we have markup support."""
-        if not source or not self.hasmarkup or not self.code_highlight:
-            return source
-
-        pygments_lexer = self._get_pygments_lexer(lexer)
-        pygments_formatter = self._get_pygments_formatter()
-
-        highlighted: str = pygments.highlight(
-            source, pygments_lexer, pygments_formatter
-        )
-        # pygments terminal formatter may add a newline when there wasn't one.
-        # We don't want this, remove.
-        if highlighted[-1] == "\n" and source[-1] != "\n":
-            highlighted = highlighted[:-1]
-
-        # Some lexers will not set the initial color explicitly
-        # which may lead to the previous color being propagated to the
-        # start of the expression, so reset first.
-        highlighted = "\x1b[0m" + highlighted
-
-        return highlighted

venv/Lib/site-packages/_pytest/_io/wcwidth.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-from functools import lru_cache
-import unicodedata
-
-
-@lru_cache(100)
-def wcwidth(c: str) -> int:
-    """Determine how many columns are needed to display a character in a terminal.
-
-    Returns -1 if the character is not printable.
-    Returns 0, 1 or 2 for other characters.
-    """
-    o = ord(c)
-
-    # ASCII fast path.
-    if 0x20 <= o < 0x07F:
-        return 1
-
-    # Some Cf/Zp/Zl characters which should be zero-width.
-    if (
-        o == 0x0000
-        or 0x200B <= o <= 0x200F
-        or 0x2028 <= o <= 0x202E
-        or 0x2060 <= o <= 0x2063
-    ):
-        return 0
-
-    category = unicodedata.category(c)
-
-    # Control characters.
-    if category == "Cc":
-        return -1
-
-    # Combining characters with zero width.
-    if category in ("Me", "Mn"):
-        return 0
-
-    # Full/Wide east asian characters.
-    if unicodedata.east_asian_width(c) in ("F", "W"):
-        return 2
-
-    return 1
-
-
-def wcswidth(s: str) -> int:
-    """Determine how many columns are needed to display a string in a terminal.
-
-    Returns -1 if the string contains non-printable characters.
-    """
-    width = 0
-    for c in unicodedata.normalize("NFC", s):
-        wc = wcwidth(c)
-        if wc < 0:
-            return -1
-        width += wc
-    return width

venv/Lib/site-packages/_pytest/_py/error.py

@@ -1,119 +0,0 @@
-"""create errno-specific classes for IO or os calls."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-import errno
-import os
-import sys
-from typing import TYPE_CHECKING
-from typing import TypeVar
-
-
-if TYPE_CHECKING:
-    from typing_extensions import ParamSpec
-
-    P = ParamSpec("P")
-
-R = TypeVar("R")
-
-
-class Error(EnvironmentError):
-    def __repr__(self) -> str:
-        return "{}.{} {!r}: {} ".format(
-            self.__class__.__module__,
-            self.__class__.__name__,
-            self.__class__.__doc__,
-            " ".join(map(str, self.args)),
-            # repr(self.args)
-        )
-
-    def __str__(self) -> str:
-        s = "[{}]: {}".format(
-            self.__class__.__doc__,
-            " ".join(map(str, self.args)),
-        )
-        return s
-
-
-_winerrnomap = {
-    2: errno.ENOENT,
-    3: errno.ENOENT,
-    17: errno.EEXIST,
-    18: errno.EXDEV,
-    13: errno.EBUSY,  # empty cd drive, but ENOMEDIUM seems unavailable
-    22: errno.ENOTDIR,
-    20: errno.ENOTDIR,
-    267: errno.ENOTDIR,
-    5: errno.EACCES,  # anything better?
-}
-
-
-class ErrorMaker:
-    """lazily provides Exception classes for each possible POSIX errno
-    (as defined per the 'errno' module).  All such instances
-    subclass EnvironmentError.
-    """
-
-    _errno2class: dict[int, type[Error]] = {}
-
-    def __getattr__(self, name: str) -> type[Error]:
-        if name[0] == "_":
-            raise AttributeError(name)
-        eno = getattr(errno, name)
-        cls = self._geterrnoclass(eno)
-        setattr(self, name, cls)
-        return cls
-
-    def _geterrnoclass(self, eno: int) -> type[Error]:
-        try:
-            return self._errno2class[eno]
-        except KeyError:
-            clsname = errno.errorcode.get(eno, f"UnknownErrno{eno}")
-            errorcls = type(
-                clsname,
-                (Error,),
-                {"__module__": "py.error", "__doc__": os.strerror(eno)},
-            )
-            self._errno2class[eno] = errorcls
-            return errorcls
-
-    def checked_call(
-        self, func: Callable[P, R], *args: P.args, **kwargs: P.kwargs
-    ) -> R:
-        """Call a function and raise an errno-exception if applicable."""
-        __tracebackhide__ = True
-        try:
-            return func(*args, **kwargs)
-        except Error:
-            raise
-        except OSError as value:
-            if not hasattr(value, "errno"):
-                raise
-            if sys.platform == "win32":
-                try:
-                    # error: Invalid index type "Optional[int]" for "dict[int, int]"; expected type "int"  [index]
-                    # OK to ignore because we catch the KeyError below.
-                    cls = self._geterrnoclass(_winerrnomap[value.errno])  # type:ignore[index]
-                except KeyError:
-                    raise value
-            else:
-                # we are not on Windows, or we got a proper OSError
-                if value.errno is None:
-                    cls = type(
-                        "UnknownErrnoNone",
-                        (Error,),
-                        {"__module__": "py.error", "__doc__": None},
-                    )
-                else:
-                    cls = self._geterrnoclass(value.errno)
-
-            raise cls(f"{func.__name__}{args!r}")
-
-
-_error_maker = ErrorMaker()
-checked_call = _error_maker.checked_call
-
-
-def __getattr__(attr: str) -> type[Error]:
-    return getattr(_error_maker, attr)  # type: ignore[no-any-return]

venv/Lib/site-packages/_pytest/_py/path.py

@@ -1,1475 +0,0 @@
-# mypy: allow-untyped-defs
-"""local path implementation."""
-
-from __future__ import annotations
-
-import atexit
-from collections.abc import Callable
-from contextlib import contextmanager
-import fnmatch
-import importlib.util
-import io
-import os
-from os.path import abspath
-from os.path import dirname
-from os.path import exists
-from os.path import isabs
-from os.path import isdir
-from os.path import isfile
-from os.path import islink
-from os.path import normpath
-import posixpath
-from stat import S_ISDIR
-from stat import S_ISLNK
-from stat import S_ISREG
-import sys
-from typing import Any
-from typing import cast
-from typing import Literal
-from typing import overload
-from typing import TYPE_CHECKING
-import uuid
-import warnings
-
-from . import error
-
-
-# Moved from local.py.
-iswin32 = sys.platform == "win32" or (getattr(os, "_name", False) == "nt")
-
-
-class Checkers:
-    _depend_on_existence = "exists", "link", "dir", "file"
-
-    def __init__(self, path):
-        self.path = path
-
-    def dotfile(self):
-        return self.path.basename.startswith(".")
-
-    def ext(self, arg):
-        if not arg.startswith("."):
-            arg = "." + arg
-        return self.path.ext == arg
-
-    def basename(self, arg):
-        return self.path.basename == arg
-
-    def basestarts(self, arg):
-        return self.path.basename.startswith(arg)
-
-    def relto(self, arg):
-        return self.path.relto(arg)
-
-    def fnmatch(self, arg):
-        return self.path.fnmatch(arg)
-
-    def endswith(self, arg):
-        return str(self.path).endswith(arg)
-
-    def _evaluate(self, kw):
-        from .._code.source import getrawcode
-
-        for name, value in kw.items():
-            invert = False
-            meth = None
-            try:
-                meth = getattr(self, name)
-            except AttributeError:
-                if name[:3] == "not":
-                    invert = True
-                    try:
-                        meth = getattr(self, name[3:])
-                    except AttributeError:
-                        pass
-            if meth is None:
-                raise TypeError(f"no {name!r} checker available for {self.path!r}")
-            try:
-                if getrawcode(meth).co_argcount > 1:
-                    if (not meth(value)) ^ invert:
-                        return False
-                else:
-                    if bool(value) ^ bool(meth()) ^ invert:
-                        return False
-            except (error.ENOENT, error.ENOTDIR, error.EBUSY):
-                # EBUSY feels not entirely correct,
-                # but its kind of necessary since ENOMEDIUM
-                # is not accessible in python
-                for name in self._depend_on_existence:
-                    if name in kw:
-                        if kw.get(name):
-                            return False
-                    name = "not" + name
-                    if name in kw:
-                        if not kw.get(name):
-                            return False
-        return True
-
-    _statcache: Stat
-
-    def _stat(self) -> Stat:
-        try:
-            return self._statcache
-        except AttributeError:
-            try:
-                self._statcache = self.path.stat()
-            except error.ELOOP:
-                self._statcache = self.path.lstat()
-            return self._statcache
-
-    def dir(self):
-        return S_ISDIR(self._stat().mode)
-
-    def file(self):
-        return S_ISREG(self._stat().mode)
-
-    def exists(self):
-        return self._stat()
-
-    def link(self):
-        st = self.path.lstat()
-        return S_ISLNK(st.mode)
-
-
-class NeverRaised(Exception):
-    pass
-
-
-class Visitor:
-    def __init__(self, fil, rec, ignore, bf, sort):
-        if isinstance(fil, (str, bytes)):
-            fil = FNMatcher(fil)
-        if isinstance(rec, str):
-            self.rec: Callable[[LocalPath], bool] = FNMatcher(rec)
-        elif not hasattr(rec, "__call__") and rec:
-            self.rec = lambda path: True
-        else:
-            self.rec = rec
-        self.fil = fil
-        self.ignore = ignore
-        self.breadthfirst = bf
-        self.optsort = cast(Callable[[Any], Any], sorted) if sort else (lambda x: x)
-
-    def gen(self, path):
-        try:
-            entries = path.listdir()
-        except self.ignore:
-            return
-        rec = self.rec
-        dirs = self.optsort(
-            [p for p in entries if p.check(dir=1) and (rec is None or rec(p))]
-        )
-        if not self.breadthfirst:
-            for subdir in dirs:
-                yield from self.gen(subdir)
-        for p in self.optsort(entries):
-            if self.fil is None or self.fil(p):
-                yield p
-        if self.breadthfirst:
-            for subdir in dirs:
-                yield from self.gen(subdir)
-
-
-class FNMatcher:
-    def __init__(self, pattern):
-        self.pattern = pattern
-
-    def __call__(self, path):
-        pattern = self.pattern
-
-        if (
-            pattern.find(path.sep) == -1
-            and iswin32
-            and pattern.find(posixpath.sep) != -1
-        ):
-            # Running on Windows, the pattern has no Windows path separators,
-            # and the pattern has one or more Posix path separators. Replace
-            # the Posix path separators with the Windows path separator.
-            pattern = pattern.replace(posixpath.sep, path.sep)
-
-        if pattern.find(path.sep) == -1:
-            name = path.basename
-        else:
-            name = str(path)  # path.strpath # XXX svn?
-            if not os.path.isabs(pattern):
-                pattern = "*" + path.sep + pattern
-        return fnmatch.fnmatch(name, pattern)
-
-
-def map_as_list(func, iter):
-    return list(map(func, iter))
-
-
-class Stat:
-    if TYPE_CHECKING:
-
-        @property
-        def size(self) -> int: ...
-
-        @property
-        def mtime(self) -> float: ...
-
-    def __getattr__(self, name: str) -> Any:
-        return getattr(self._osstatresult, "st_" + name)
-
-    def __init__(self, path, osstatresult):
-        self.path = path
-        self._osstatresult = osstatresult
-
-    @property
-    def owner(self):
-        if iswin32:
-            raise NotImplementedError("XXX win32")
-        import pwd
-
-        entry = error.checked_call(pwd.getpwuid, self.uid)  # type:ignore[attr-defined,unused-ignore]
-        return entry[0]
-
-    @property
-    def group(self):
-        """Return group name of file."""
-        if iswin32:
-            raise NotImplementedError("XXX win32")
-        import grp
-
-        entry = error.checked_call(grp.getgrgid, self.gid)  # type:ignore[attr-defined,unused-ignore]
-        return entry[0]
-
-    def isdir(self):
-        return S_ISDIR(self._osstatresult.st_mode)
-
-    def isfile(self):
-        return S_ISREG(self._osstatresult.st_mode)
-
-    def islink(self):
-        self.path.lstat()
-        return S_ISLNK(self._osstatresult.st_mode)
-
-
-def getuserid(user):
-    import pwd
-
-    if not isinstance(user, int):
-        user = pwd.getpwnam(user)[2]  # type:ignore[attr-defined,unused-ignore]
-    return user
-
-
-def getgroupid(group):
-    import grp
-
-    if not isinstance(group, int):
-        group = grp.getgrnam(group)[2]  # type:ignore[attr-defined,unused-ignore]
-    return group
-
-
-class LocalPath:
-    """Object oriented interface to os.path and other local filesystem
-    related information.
-    """
-
-    class ImportMismatchError(ImportError):
-        """raised on pyimport() if there is a mismatch of __file__'s"""
-
-    sep = os.sep
-
-    def __init__(self, path=None, expanduser=False):
-        """Initialize and return a local Path instance.
-
-        Path can be relative to the current directory.
-        If path is None it defaults to the current working directory.
-        If expanduser is True, tilde-expansion is performed.
-        Note that Path instances always carry an absolute path.
-        Note also that passing in a local path object will simply return
-        the exact same path object. Use new() to get a new copy.
-        """
-        if path is None:
-            self.strpath = error.checked_call(os.getcwd)
-        else:
-            try:
-                path = os.fspath(path)
-            except TypeError:
-                raise ValueError(
-                    "can only pass None, Path instances "
-                    "or non-empty strings to LocalPath"
-                )
-            if expanduser:
-                path = os.path.expanduser(path)
-            self.strpath = abspath(path)
-
-    if sys.platform != "win32":
-
-        def chown(self, user, group, rec=0):
-            """Change ownership to the given user and group.
-            user and group may be specified by a number or
-            by a name.  if rec is True change ownership
-            recursively.
-            """
-            uid = getuserid(user)
-            gid = getgroupid(group)
-            if rec:
-                for x in self.visit(rec=lambda x: x.check(link=0)):
-                    if x.check(link=0):
-                        error.checked_call(os.chown, str(x), uid, gid)
-            error.checked_call(os.chown, str(self), uid, gid)
-
-        def readlink(self) -> str:
-            """Return value of a symbolic link."""
-            # https://github.com/python/mypy/issues/12278
-            return error.checked_call(os.readlink, self.strpath)  # type: ignore[arg-type,return-value,unused-ignore]
-
-        def mklinkto(self, oldname):
-            """Posix style hard link to another name."""
-            error.checked_call(os.link, str(oldname), str(self))
-
-        def mksymlinkto(self, value, absolute=1):
-            """Create a symbolic link with the given value (pointing to another name)."""
-            if absolute:
-                error.checked_call(os.symlink, str(value), self.strpath)
-            else:
-                base = self.common(value)
-                # with posix local paths '/' is always a common base
-                relsource = self.__class__(value).relto(base)
-                reldest = self.relto(base)
-                n = reldest.count(self.sep)
-                target = self.sep.join(("..",) * n + (relsource,))
-                error.checked_call(os.symlink, target, self.strpath)
-
-    def __div__(self, other):
-        return self.join(os.fspath(other))
-
-    __truediv__ = __div__  # py3k
-
-    @property
-    def basename(self):
-        """Basename part of path."""
-        return self._getbyspec("basename")[0]
-
-    @property
-    def dirname(self):
-        """Dirname part of path."""
-        return self._getbyspec("dirname")[0]
-
-    @property
-    def purebasename(self):
-        """Pure base name of the path."""
-        return self._getbyspec("purebasename")[0]
-
-    @property
-    def ext(self):
-        """Extension of the path (including the '.')."""
-        return self._getbyspec("ext")[0]
-
-    def read_binary(self):
-        """Read and return a bytestring from reading the path."""
-        with self.open("rb") as f:
-            return f.read()
-
-    def read_text(self, encoding):
-        """Read and return a Unicode string from reading the path."""
-        with self.open("r", encoding=encoding) as f:
-            return f.read()
-
-    def read(self, mode="r"):
-        """Read and return a bytestring from reading the path."""
-        with self.open(mode) as f:
-            return f.read()
-
-    def readlines(self, cr=1):
-        """Read and return a list of lines from the path. if cr is False, the
-        newline will be removed from the end of each line."""
-        mode = "r"
-
-        if not cr:
-            content = self.read(mode)
-            return content.split("\n")
-        else:
-            f = self.open(mode)
-            try:
-                return f.readlines()
-            finally:
-                f.close()
-
-    def load(self):
-        """(deprecated) return object unpickled from self.read()"""
-        f = self.open("rb")
-        try:
-            import pickle
-
-            return error.checked_call(pickle.load, f)
-        finally:
-            f.close()
-
-    def move(self, target):
-        """Move this path to target."""
-        if target.relto(self):
-            raise error.EINVAL(target, "cannot move path into a subdirectory of itself")
-        try:
-            self.rename(target)
-        except error.EXDEV:  # invalid cross-device link
-            self.copy(target)
-            self.remove()
-
-    def fnmatch(self, pattern):
-        """Return true if the basename/fullname matches the glob-'pattern'.
-
-        valid pattern characters::
-
-            *       matches everything
-            ?       matches any single character
-            [seq]   matches any character in seq
-            [!seq]  matches any char not in seq
-
-        If the pattern contains a path-separator then the full path
-        is used for pattern matching and a '*' is prepended to the
-        pattern.
-
-        if the pattern doesn't contain a path-separator the pattern
-        is only matched against the basename.
-        """
-        return FNMatcher(pattern)(self)
-
-    def relto(self, relpath):
-        """Return a string which is the relative part of the path
-        to the given 'relpath'.
-        """
-        if not isinstance(relpath, str | LocalPath):
-            raise TypeError(f"{relpath!r}: not a string or path object")
-        strrelpath = str(relpath)
-        if strrelpath and strrelpath[-1] != self.sep:
-            strrelpath += self.sep
-        # assert strrelpath[-1] == self.sep
-        # assert strrelpath[-2] != self.sep
-        strself = self.strpath
-        if sys.platform == "win32" or getattr(os, "_name", None) == "nt":
-            if os.path.normcase(strself).startswith(os.path.normcase(strrelpath)):
-                return strself[len(strrelpath) :]
-        elif strself.startswith(strrelpath):
-            return strself[len(strrelpath) :]
-        return ""
-
-    def ensure_dir(self, *args):
-        """Ensure the path joined with args is a directory."""
-        return self.ensure(*args, dir=True)
-
-    def bestrelpath(self, dest):
-        """Return a string which is a relative path from self
-        (assumed to be a directory) to dest such that
-        self.join(bestrelpath) == dest and if not such
-        path can be determined return dest.
-        """
-        try:
-            if self == dest:
-                return os.curdir
-            base = self.common(dest)
-            if not base:  # can be the case on windows
-                return str(dest)
-            self2base = self.relto(base)
-            reldest = dest.relto(base)
-            if self2base:
-                n = self2base.count(self.sep) + 1
-            else:
-                n = 0
-            lst = [os.pardir] * n
-            if reldest:
-                lst.append(reldest)
-            target = dest.sep.join(lst)
-            return target
-        except AttributeError:
-            return str(dest)
-
-    def exists(self):
-        return self.check()
-
-    def isdir(self):
-        return self.check(dir=1)
-
-    def isfile(self):
-        return self.check(file=1)
-
-    def parts(self, reverse=False):
-        """Return a root-first list of all ancestor directories
-        plus the path itself.
-        """
-        current = self
-        lst = [self]
-        while 1:
-            last = current
-            current = current.dirpath()
-            if last == current:
-                break
-            lst.append(current)
-        if not reverse:
-            lst.reverse()
-        return lst
-
-    def common(self, other):
-        """Return the common part shared with the other path
-        or None if there is no common part.
-        """
-        last = None
-        for x, y in zip(self.parts(), other.parts()):
-            if x != y:
-                return last
-            last = x
-        return last
-
-    def __add__(self, other):
-        """Return new path object with 'other' added to the basename"""
-        return self.new(basename=self.basename + str(other))
-
-    def visit(self, fil=None, rec=None, ignore=NeverRaised, bf=False, sort=False):
-        """Yields all paths below the current one
-
-        fil is a filter (glob pattern or callable), if not matching the
-        path will not be yielded, defaulting to None (everything is
-        returned)
-
-        rec is a filter (glob pattern or callable) that controls whether
-        a node is descended, defaulting to None
-
-        ignore is an Exception class that is ignoredwhen calling dirlist()
-        on any of the paths (by default, all exceptions are reported)
-
-        bf if True will cause a breadthfirst search instead of the
-        default depthfirst. Default: False
-
-        sort if True will sort entries within each directory level.
-        """
-        yield from Visitor(fil, rec, ignore, bf, sort).gen(self)
-
-    def _sortlist(self, res, sort):
-        if sort:
-            if hasattr(sort, "__call__"):
-                warnings.warn(
-                    DeprecationWarning(
-                        "listdir(sort=callable) is deprecated and breaks on python3"
-                    ),
-                    stacklevel=3,
-                )
-                res.sort(sort)
-            else:
-                res.sort()
-
-    def __fspath__(self):
-        return self.strpath
-
-    def __hash__(self):
-        s = self.strpath
-        if iswin32:
-            s = s.lower()
-        return hash(s)
-
-    def __eq__(self, other):
-        s1 = os.fspath(self)
-        try:
-            s2 = os.fspath(other)
-        except TypeError:
-            return False
-        if iswin32:
-            s1 = s1.lower()
-            try:
-                s2 = s2.lower()
-            except AttributeError:
-                return False
-        return s1 == s2
-
-    def __ne__(self, other):
-        return not (self == other)
-
-    def __lt__(self, other):
-        return os.fspath(self) < os.fspath(other)
-
-    def __gt__(self, other):
-        return os.fspath(self) > os.fspath(other)
-
-    def samefile(self, other):
-        """Return True if 'other' references the same file as 'self'."""
-        other = os.fspath(other)
-        if not isabs(other):
-            other = abspath(other)
-        if self == other:
-            return True
-        if not hasattr(os.path, "samefile"):
-            return False
-        return error.checked_call(os.path.samefile, self.strpath, other)
-
-    def remove(self, rec=1, ignore_errors=False):
-        """Remove a file or directory (or a directory tree if rec=1).
-        if ignore_errors is True, errors while removing directories will
-        be ignored.
-        """
-        if self.check(dir=1, link=0):
-            if rec:
-                # force remove of readonly files on windows
-                if iswin32:
-                    self.chmod(0o700, rec=1)
-                import shutil
-
-                error.checked_call(
-                    shutil.rmtree, self.strpath, ignore_errors=ignore_errors
-                )
-            else:
-                error.checked_call(os.rmdir, self.strpath)
-        else:
-            if iswin32:
-                self.chmod(0o700)
-            error.checked_call(os.remove, self.strpath)
-
-    def computehash(self, hashtype="md5", chunksize=524288):
-        """Return hexdigest of hashvalue for this file."""
-        try:
-            try:
-                import hashlib as mod
-            except ImportError:
-                if hashtype == "sha1":
-                    hashtype = "sha"
-                mod = __import__(hashtype)
-            hash = getattr(mod, hashtype)()
-        except (AttributeError, ImportError):
-            raise ValueError(f"Don't know how to compute {hashtype!r} hash")
-        f = self.open("rb")
-        try:
-            while 1:
-                buf = f.read(chunksize)
-                if not buf:
-                    return hash.hexdigest()
-                hash.update(buf)
-        finally:
-            f.close()
-
-    def new(self, **kw):
-        """Create a modified version of this path.
-        the following keyword arguments modify various path parts::
-
-          a:/some/path/to/a/file.ext
-          xx                           drive
-          xxxxxxxxxxxxxxxxx            dirname
-                            xxxxxxxx   basename
-                            xxxx       purebasename
-                                 xxx   ext
-        """
-        obj = object.__new__(self.__class__)
-        if not kw:
-            obj.strpath = self.strpath
-            return obj
-        drive, dirname, _basename, purebasename, ext = self._getbyspec(
-            "drive,dirname,basename,purebasename,ext"
-        )
-        if "basename" in kw:
-            if "purebasename" in kw or "ext" in kw:
-                raise ValueError(f"invalid specification {kw!r}")
-        else:
-            pb = kw.setdefault("purebasename", purebasename)
-            try:
-                ext = kw["ext"]
-            except KeyError:
-                pass
-            else:
-                if ext and not ext.startswith("."):
-                    ext = "." + ext
-            kw["basename"] = pb + ext
-
-        if "dirname" in kw and not kw["dirname"]:
-            kw["dirname"] = drive
-        else:
-            kw.setdefault("dirname", dirname)
-        kw.setdefault("sep", self.sep)
-        obj.strpath = normpath("{dirname}{sep}{basename}".format(**kw))
-        return obj
-
-    def _getbyspec(self, spec: str) -> list[str]:
-        """See new for what 'spec' can be."""
-        res = []
-        parts = self.strpath.split(self.sep)
-
-        args = filter(None, spec.split(","))
-        for name in args:
-            if name == "drive":
-                res.append(parts[0])
-            elif name == "dirname":
-                res.append(self.sep.join(parts[:-1]))
-            else:
-                basename = parts[-1]
-                if name == "basename":
-                    res.append(basename)
-                else:
-                    i = basename.rfind(".")
-                    if i == -1:
-                        purebasename, ext = basename, ""
-                    else:
-                        purebasename, ext = basename[:i], basename[i:]
-                    if name == "purebasename":
-                        res.append(purebasename)
-                    elif name == "ext":
-                        res.append(ext)
-                    else:
-                        raise ValueError(f"invalid part specification {name!r}")
-        return res
-
-    def dirpath(self, *args, **kwargs):
-        """Return the directory path joined with any given path arguments."""
-        if not kwargs:
-            path = object.__new__(self.__class__)
-            path.strpath = dirname(self.strpath)
-            if args:
-                path = path.join(*args)
-            return path
-        return self.new(basename="").join(*args, **kwargs)
-
-    def join(self, *args: os.PathLike[str], abs: bool = False) -> LocalPath:
-        """Return a new path by appending all 'args' as path
-        components.  if abs=1 is used restart from root if any
-        of the args is an absolute path.
-        """
-        sep = self.sep
-        strargs = [os.fspath(arg) for arg in args]
-        strpath = self.strpath
-        if abs:
-            newargs: list[str] = []
-            for arg in reversed(strargs):
-                if isabs(arg):
-                    strpath = arg
-                    strargs = newargs
-                    break
-                newargs.insert(0, arg)
-        # special case for when we have e.g. strpath == "/"
-        actual_sep = "" if strpath.endswith(sep) else sep
-        for arg in strargs:
-            arg = arg.strip(sep)
-            if iswin32:
-                # allow unix style paths even on windows.
-                arg = arg.strip("/")
-                arg = arg.replace("/", sep)
-            strpath = strpath + actual_sep + arg
-            actual_sep = sep
-        obj = object.__new__(self.__class__)
-        obj.strpath = normpath(strpath)
-        return obj
-
-    def open(self, mode="r", ensure=False, encoding=None):
-        """Return an opened file with the given mode.
-
-        If ensure is True, create parent directories if needed.
-        """
-        if ensure:
-            self.dirpath().ensure(dir=1)
-        if encoding:
-            return error.checked_call(
-                io.open,
-                self.strpath,
-                mode,
-                encoding=encoding,
-            )
-        return error.checked_call(open, self.strpath, mode)
-
-    def _fastjoin(self, name):
-        child = object.__new__(self.__class__)
-        child.strpath = self.strpath + self.sep + name
-        return child
-
-    def islink(self):
-        return islink(self.strpath)
-
-    def check(self, **kw):
-        """Check a path for existence and properties.
-
-        Without arguments, return True if the path exists, otherwise False.
-
-        valid checkers::
-
-            file = 1  # is a file
-            file = 0  # is not a file (may not even exist)
-            dir = 1  # is a dir
-            link = 1  # is a link
-            exists = 1  # exists
-
-        You can specify multiple checker definitions, for example::
-
-            path.check(file=1, link=1)  # a link pointing to a file
-        """
-        if not kw:
-            return exists(self.strpath)
-        if len(kw) == 1:
-            if "dir" in kw:
-                return not kw["dir"] ^ isdir(self.strpath)
-            if "file" in kw:
-                return not kw["file"] ^ isfile(self.strpath)
-        if not kw:
-            kw = {"exists": 1}
-        return Checkers(self)._evaluate(kw)
-
-    _patternchars = set("*?[" + os.sep)
-
-    def listdir(self, fil=None, sort=None):
-        """List directory contents, possibly filter by the given fil func
-        and possibly sorted.
-        """
-        if fil is None and sort is None:
-            names = error.checked_call(os.listdir, self.strpath)
-            return map_as_list(self._fastjoin, names)
-        if isinstance(fil, str):
-            if not self._patternchars.intersection(fil):
-                child = self._fastjoin(fil)
-                if exists(child.strpath):
-                    return [child]
-                return []
-            fil = FNMatcher(fil)
-        names = error.checked_call(os.listdir, self.strpath)
-        res = []
-        for name in names:
-            child = self._fastjoin(name)
-            if fil is None or fil(child):
-                res.append(child)
-        self._sortlist(res, sort)
-        return res
-
-    def size(self) -> int:
-        """Return size of the underlying file object"""
-        return self.stat().size
-
-    def mtime(self) -> float:
-        """Return last modification time of the path."""
-        return self.stat().mtime
-
-    def copy(self, target, mode=False, stat=False):
-        """Copy path to target.
-
-        If mode is True, will copy permission from path to target.
-        If stat is True, copy permission, last modification
-        time, last access time, and flags from path to target.
-        """
-        if self.check(file=1):
-            if target.check(dir=1):
-                target = target.join(self.basename)
-            assert self != target
-            copychunked(self, target)
-            if mode:
-                copymode(self.strpath, target.strpath)
-            if stat:
-                copystat(self, target)
-        else:
-
-            def rec(p):
-                return p.check(link=0)
-
-            for x in self.visit(rec=rec):
-                relpath = x.relto(self)
-                newx = target.join(relpath)
-                newx.dirpath().ensure(dir=1)
-                if x.check(link=1):
-                    newx.mksymlinkto(x.readlink())
-                    continue
-                elif x.check(file=1):
-                    copychunked(x, newx)
-                elif x.check(dir=1):
-                    newx.ensure(dir=1)
-                if mode:
-                    copymode(x.strpath, newx.strpath)
-                if stat:
-                    copystat(x, newx)
-
-    def rename(self, target):
-        """Rename this path to target."""
-        target = os.fspath(target)
-        return error.checked_call(os.rename, self.strpath, target)
-
-    def dump(self, obj, bin=1):
-        """Pickle object into path location"""
-        f = self.open("wb")
-        import pickle
-
-        try:
-            error.checked_call(pickle.dump, obj, f, bin)
-        finally:
-            f.close()
-
-    def mkdir(self, *args):
-        """Create & return the directory joined with args."""
-        p = self.join(*args)
-        error.checked_call(os.mkdir, os.fspath(p))
-        return p
-
-    def write_binary(self, data, ensure=False):
-        """Write binary data into path.   If ensure is True create
-        missing parent directories.
-        """
-        if ensure:
-            self.dirpath().ensure(dir=1)
-        with self.open("wb") as f:
-            f.write(data)
-
-    def write_text(self, data, encoding, ensure=False):
-        """Write text data into path using the specified encoding.
-        If ensure is True create missing parent directories.
-        """
-        if ensure:
-            self.dirpath().ensure(dir=1)
-        with self.open("w", encoding=encoding) as f:
-            f.write(data)
-
-    def write(self, data, mode="w", ensure=False):
-        """Write data into path.   If ensure is True create
-        missing parent directories.
-        """
-        if ensure:
-            self.dirpath().ensure(dir=1)
-        if "b" in mode:
-            if not isinstance(data, bytes):
-                raise ValueError("can only process bytes")
-        else:
-            if not isinstance(data, str):
-                if not isinstance(data, bytes):
-                    data = str(data)
-                else:
-                    data = data.decode(sys.getdefaultencoding())
-        f = self.open(mode)
-        try:
-            f.write(data)
-        finally:
-            f.close()
-
-    def _ensuredirs(self):
-        parent = self.dirpath()
-        if parent == self:
-            return self
-        if parent.check(dir=0):
-            parent._ensuredirs()
-        if self.check(dir=0):
-            try:
-                self.mkdir()
-            except error.EEXIST:
-                # race condition: file/dir created by another thread/process.
-                # complain if it is not a dir
-                if self.check(dir=0):
-                    raise
-        return self
-
-    def ensure(self, *args, **kwargs):
-        """Ensure that an args-joined path exists (by default as
-        a file). if you specify a keyword argument 'dir=True'
-        then the path is forced to be a directory path.
-        """
-        p = self.join(*args)
-        if kwargs.get("dir", 0):
-            return p._ensuredirs()
-        else:
-            p.dirpath()._ensuredirs()
-            if not p.check(file=1):
-                p.open("wb").close()
-            return p
-
-    @overload
-    def stat(self, raising: Literal[True] = ...) -> Stat: ...
-
-    @overload
-    def stat(self, raising: Literal[False]) -> Stat | None: ...
-
-    def stat(self, raising: bool = True) -> Stat | None:
-        """Return an os.stat() tuple."""
-        if raising:
-            return Stat(self, error.checked_call(os.stat, self.strpath))
-        try:
-            return Stat(self, os.stat(self.strpath))
-        except KeyboardInterrupt:
-            raise
-        except Exception:
-            return None
-
-    def lstat(self) -> Stat:
-        """Return an os.lstat() tuple."""
-        return Stat(self, error.checked_call(os.lstat, self.strpath))
-
-    def setmtime(self, mtime=None):
-        """Set modification time for the given path.  if 'mtime' is None
-        (the default) then the file's mtime is set to current time.
-
-        Note that the resolution for 'mtime' is platform dependent.
-        """
-        if mtime is None:
-            return error.checked_call(os.utime, self.strpath, mtime)
-        try:
-            return error.checked_call(os.utime, self.strpath, (-1, mtime))
-        except error.EINVAL:
-            return error.checked_call(os.utime, self.strpath, (self.atime(), mtime))
-
-    def chdir(self):
-        """Change directory to self and return old current directory"""
-        try:
-            old = self.__class__()
-        except error.ENOENT:
-            old = None
-        error.checked_call(os.chdir, self.strpath)
-        return old
-
-    @contextmanager
-    def as_cwd(self):
-        """
-        Return a context manager, which changes to the path's dir during the
-        managed "with" context.
-        On __enter__ it returns the old dir, which might be ``None``.
-        """
-        old = self.chdir()
-        try:
-            yield old
-        finally:
-            if old is not None:
-                old.chdir()
-
-    def realpath(self):
-        """Return a new path which contains no symbolic links."""
-        return self.__class__(os.path.realpath(self.strpath))
-
-    def atime(self):
-        """Return last access time of the path."""
-        return self.stat().atime
-
-    def __repr__(self):
-        return f"local({self.strpath!r})"
-
-    def __str__(self):
-        """Return string representation of the Path."""
-        return self.strpath
-
-    def chmod(self, mode, rec=0):
-        """Change permissions to the given mode. If mode is an
-        integer it directly encodes the os-specific modes.
-        if rec is True perform recursively.
-        """
-        if not isinstance(mode, int):
-            raise TypeError(f"mode {mode!r} must be an integer")
-        if rec:
-            for x in self.visit(rec=rec):
-                error.checked_call(os.chmod, str(x), mode)
-        error.checked_call(os.chmod, self.strpath, mode)
-
-    def pypkgpath(self):
-        """Return the Python package path by looking for the last
-        directory upwards which still contains an __init__.py.
-        Return None if a pkgpath cannot be determined.
-        """
-        pkgpath = None
-        for parent in self.parts(reverse=True):
-            if parent.isdir():
-                if not parent.join("__init__.py").exists():
-                    break
-                if not isimportable(parent.basename):
-                    break
-                pkgpath = parent
-        return pkgpath
-
-    def _ensuresyspath(self, ensuremode, path):
-        if ensuremode:
-            s = str(path)
-            if ensuremode == "append":
-                if s not in sys.path:
-                    sys.path.append(s)
-            else:
-                if s != sys.path[0]:
-                    sys.path.insert(0, s)
-
-    def pyimport(self, modname=None, ensuresyspath=True):
-        """Return path as an imported python module.
-
-        If modname is None, look for the containing package
-        and construct an according module name.
-        The module will be put/looked up in sys.modules.
-        if ensuresyspath is True then the root dir for importing
-        the file (taking __init__.py files into account) will
-        be prepended to sys.path if it isn't there already.
-        If ensuresyspath=="append" the root dir will be appended
-        if it isn't already contained in sys.path.
-        if ensuresyspath is False no modification of syspath happens.
-
-        Special value of ensuresyspath=="importlib" is intended
-        purely for using in pytest, it is capable only of importing
-        separate .py files outside packages, e.g. for test suite
-        without any __init__.py file. It effectively allows having
-        same-named test modules in different places and offers
-        mild opt-in via this option. Note that it works only in
-        recent versions of python.
-        """
-        if not self.check():
-            raise error.ENOENT(self)
-
-        if ensuresyspath == "importlib":
-            if modname is None:
-                modname = self.purebasename
-            spec = importlib.util.spec_from_file_location(modname, str(self))
-            if spec is None or spec.loader is None:
-                raise ImportError(f"Can't find module {modname} at location {self!s}")
-            mod = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(mod)
-            return mod
-
-        pkgpath = None
-        if modname is None:
-            pkgpath = self.pypkgpath()
-            if pkgpath is not None:
-                pkgroot = pkgpath.dirpath()
-                names = self.new(ext="").relto(pkgroot).split(self.sep)
-                if names[-1] == "__init__":
-                    names.pop()
-                modname = ".".join(names)
-            else:
-                pkgroot = self.dirpath()
-                modname = self.purebasename
-
-            self._ensuresyspath(ensuresyspath, pkgroot)
-            __import__(modname)
-            mod = sys.modules[modname]
-            if self.basename == "__init__.py":
-                return mod  # we don't check anything as we might
-                # be in a namespace package ... too icky to check
-            modfile = mod.__file__
-            assert modfile is not None
-            if modfile[-4:] in (".pyc", ".pyo"):
-                modfile = modfile[:-1]
-            elif modfile.endswith("$py.class"):
-                modfile = modfile[:-9] + ".py"
-            if modfile.endswith(os.sep + "__init__.py"):
-                if self.basename != "__init__.py":
-                    modfile = modfile[:-12]
-            try:
-                issame = self.samefile(modfile)
-            except error.ENOENT:
-                issame = False
-            if not issame:
-                ignore = os.getenv("PY_IGNORE_IMPORTMISMATCH")
-                if ignore != "1":
-                    raise self.ImportMismatchError(modname, modfile, self)
-            return mod
-        else:
-            try:
-                return sys.modules[modname]
-            except KeyError:
-                # we have a custom modname, do a pseudo-import
-                import types
-
-                mod = types.ModuleType(modname)
-                mod.__file__ = str(self)
-                sys.modules[modname] = mod
-                try:
-                    with open(str(self), "rb") as f:
-                        exec(f.read(), mod.__dict__)
-                except BaseException:
-                    del sys.modules[modname]
-                    raise
-                return mod
-
-    def sysexec(self, *argv: os.PathLike[str], **popen_opts: Any) -> str:
-        """Return stdout text from executing a system child process,
-        where the 'self' path points to executable.
-        The process is directly invoked and not through a system shell.
-        """
-        from subprocess import PIPE
-        from subprocess import Popen
-
-        popen_opts.pop("stdout", None)
-        popen_opts.pop("stderr", None)
-        proc = Popen(
-            [str(self)] + [str(arg) for arg in argv],
-            **popen_opts,
-            stdout=PIPE,
-            stderr=PIPE,
-        )
-        stdout: str | bytes
-        stdout, stderr = proc.communicate()
-        ret = proc.wait()
-        if isinstance(stdout, bytes):
-            stdout = stdout.decode(sys.getdefaultencoding())
-        if ret != 0:
-            if isinstance(stderr, bytes):
-                stderr = stderr.decode(sys.getdefaultencoding())
-            raise RuntimeError(
-                ret,
-                ret,
-                str(self),
-                stdout,
-                stderr,
-            )
-        return stdout
-
-    @classmethod
-    def sysfind(cls, name, checker=None, paths=None):
-        """Return a path object found by looking at the systems
-        underlying PATH specification. If the checker is not None
-        it will be invoked to filter matching paths.  If a binary
-        cannot be found, None is returned
-        Note: This is probably not working on plain win32 systems
-        but may work on cygwin.
-        """
-        if isabs(name):
-            p = local(name)
-            if p.check(file=1):
-                return p
-        else:
-            if paths is None:
-                if iswin32:
-                    paths = os.environ["Path"].split(";")
-                    if "" not in paths and "." not in paths:
-                        paths.append(".")
-                    try:
-                        systemroot = os.environ["SYSTEMROOT"]
-                    except KeyError:
-                        pass
-                    else:
-                        paths = [
-                            path.replace("%SystemRoot%", systemroot) for path in paths
-                        ]
-                else:
-                    paths = os.environ["PATH"].split(":")
-            tryadd = []
-            if iswin32:
-                tryadd += os.environ["PATHEXT"].split(os.pathsep)
-            tryadd.append("")
-
-            for x in paths:
-                for addext in tryadd:
-                    p = local(x).join(name, abs=True) + addext
-                    try:
-                        if p.check(file=1):
-                            if checker:
-                                if not checker(p):
-                                    continue
-                            return p
-                    except error.EACCES:
-                        pass
-        return None
-
-    @classmethod
-    def _gethomedir(cls):
-        try:
-            x = os.environ["HOME"]
-        except KeyError:
-            try:
-                x = os.environ["HOMEDRIVE"] + os.environ["HOMEPATH"]
-            except KeyError:
-                return None
-        return cls(x)
-
-    # """
-    # special class constructors for local filesystem paths
-    # """
-    @classmethod
-    def get_temproot(cls):
-        """Return the system's temporary directory
-        (where tempfiles are usually created in)
-        """
-        import tempfile
-
-        return local(tempfile.gettempdir())
-
-    @classmethod
-    def mkdtemp(cls, rootdir=None):
-        """Return a Path object pointing to a fresh new temporary directory
-        (which we created ourselves).
-        """
-        import tempfile
-
-        if rootdir is None:
-            rootdir = cls.get_temproot()
-        path = error.checked_call(tempfile.mkdtemp, dir=str(rootdir))
-        return cls(path)
-
-    @classmethod
-    def make_numbered_dir(
-        cls, prefix="session-", rootdir=None, keep=3, lock_timeout=172800
-    ):  # two days
-        """Return unique directory with a number greater than the current
-        maximum one.  The number is assumed to start directly after prefix.
-        if keep is true directories with a number less than (maxnum-keep)
-        will be removed. If .lock files are used (lock_timeout non-zero),
-        algorithm is multi-process safe.
-        """
-        if rootdir is None:
-            rootdir = cls.get_temproot()
-
-        nprefix = prefix.lower()
-
-        def parse_num(path):
-            """Parse the number out of a path (if it matches the prefix)"""
-            nbasename = path.basename.lower()
-            if nbasename.startswith(nprefix):
-                try:
-                    return int(nbasename[len(nprefix) :])
-                except ValueError:
-                    pass
-
-        def create_lockfile(path):
-            """Exclusively create lockfile. Throws when failed"""
-            mypid = os.getpid()
-            lockfile = path.join(".lock")
-            if hasattr(lockfile, "mksymlinkto"):
-                lockfile.mksymlinkto(str(mypid))
-            else:
-                fd = error.checked_call(
-                    os.open, str(lockfile), os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644
-                )
-                with os.fdopen(fd, "w") as f:
-                    f.write(str(mypid))
-            return lockfile
-
-        def atexit_remove_lockfile(lockfile):
-            """Ensure lockfile is removed at process exit"""
-            mypid = os.getpid()
-
-            def try_remove_lockfile():
-                # in a fork() situation, only the last process should
-                # remove the .lock, otherwise the other processes run the
-                # risk of seeing their temporary dir disappear.  For now
-                # we remove the .lock in the parent only (i.e. we assume
-                # that the children finish before the parent).
-                if os.getpid() != mypid:
-                    return
-                try:
-                    lockfile.remove()
-                except error.Error:
-                    pass
-
-            atexit.register(try_remove_lockfile)
-
-        # compute the maximum number currently in use with the prefix
-        lastmax = None
-        while True:
-            maxnum = -1
-            for path in rootdir.listdir():
-                num = parse_num(path)
-                if num is not None:
-                    maxnum = max(maxnum, num)
-
-            # make the new directory
-            try:
-                udir = rootdir.mkdir(prefix + str(maxnum + 1))
-                if lock_timeout:
-                    lockfile = create_lockfile(udir)
-                    atexit_remove_lockfile(lockfile)
-            except (error.EEXIST, error.ENOENT, error.EBUSY):
-                # race condition (1): another thread/process created the dir
-                #                     in the meantime - try again
-                # race condition (2): another thread/process spuriously acquired
-                #                     lock treating empty directory as candidate
-                #                     for removal - try again
-                # race condition (3): another thread/process tried to create the lock at
-                #                     the same time (happened in Python 3.3 on Windows)
-                # https://ci.appveyor.com/project/pytestbot/py/build/1.0.21/job/ffi85j4c0lqwsfwa
-                if lastmax == maxnum:
-                    raise
-                lastmax = maxnum
-                continue
-            break
-
-        def get_mtime(path):
-            """Read file modification time"""
-            try:
-                return path.lstat().mtime
-            except error.Error:
-                pass
-
-        garbage_prefix = prefix + "garbage-"
-
-        def is_garbage(path):
-            """Check if path denotes directory scheduled for removal"""
-            bn = path.basename
-            return bn.startswith(garbage_prefix)
-
-        # prune old directories
-        udir_time = get_mtime(udir)
-        if keep and udir_time:
-            for path in rootdir.listdir():
-                num = parse_num(path)
-                if num is not None and num <= (maxnum - keep):
-                    try:
-                        # try acquiring lock to remove directory as exclusive user
-                        if lock_timeout:
-                            create_lockfile(path)
-                    except (error.EEXIST, error.ENOENT, error.EBUSY):
-                        path_time = get_mtime(path)
-                        if not path_time:
-                            # assume directory doesn't exist now
-                            continue
-                        if abs(udir_time - path_time) < lock_timeout:
-                            # assume directory with lockfile exists
-                            # and lock timeout hasn't expired yet
-                            continue
-
-                    # path dir locked for exclusive use
-                    # and scheduled for removal to avoid another thread/process
-                    # treating it as a new directory or removal candidate
-                    garbage_path = rootdir.join(garbage_prefix + str(uuid.uuid4()))
-                    try:
-                        path.rename(garbage_path)
-                        garbage_path.remove(rec=1)
-                    except KeyboardInterrupt:
-                        raise
-                    except Exception:  # this might be error.Error, WindowsError ...
-                        pass
-                if is_garbage(path):
-                    try:
-                        path.remove(rec=1)
-                    except KeyboardInterrupt:
-                        raise
-                    except Exception:  # this might be error.Error, WindowsError ...
-                        pass
-
-        # make link...
-        try:
-            username = os.environ["USER"]  # linux, et al
-        except KeyError:
-            try:
-                username = os.environ["USERNAME"]  # windows
-            except KeyError:
-                username = "current"
-
-        src = str(udir)
-        dest = src[: src.rfind("-")] + "-" + username
-        try:
-            os.unlink(dest)
-        except OSError:
-            pass
-        try:
-            os.symlink(src, dest)
-        except (OSError, AttributeError, NotImplementedError):
-            pass
-
-        return udir
-
-
-def copymode(src, dest):
-    """Copy permission from src to dst."""
-    import shutil
-
-    shutil.copymode(src, dest)
-
-
-def copystat(src, dest):
-    """Copy permission,  last modification time,
-    last access time, and flags from src to dst."""
-    import shutil
-
-    shutil.copystat(str(src), str(dest))
-
-
-def copychunked(src, dest):
-    chunksize = 524288  # half a meg of bytes
-    fsrc = src.open("rb")
-    try:
-        fdest = dest.open("wb")
-        try:
-            while 1:
-                buf = fsrc.read(chunksize)
-                if not buf:
-                    break
-                fdest.write(buf)
-        finally:
-            fdest.close()
-    finally:
-        fsrc.close()
-
-
-def isimportable(name):
-    if name and (name[0].isalpha() or name[0] == "_"):
-        name = name.replace("_", "")
-        return not name or name.isalnum()
-
-
-local = LocalPath

venv/Lib/site-packages/_pytest/_version.py

@@ -1,24 +0,0 @@
-# file generated by vcs-versioning
-# don't change, don't track in version control
-from __future__ import annotations
-
-__all__ = [
-    "__version__",
-    "__version_tuple__",
-    "version",
-    "version_tuple",
-    "__commit_id__",
-    "commit_id",
-]
-
-version: str
-__version__: str
-__version_tuple__: tuple[int | str, ...]
-version_tuple: tuple[int | str, ...]
-commit_id: str | None
-__commit_id__: str | None
-
-__version__ = version = '9.1.1'
-__version_tuple__ = version_tuple = (9, 1, 1)
-
-__commit_id__ = commit_id = None

venv/Lib/site-packages/_pytest/assertion/__init__.py

@@ -1,236 +0,0 @@
-# mypy: allow-untyped-defs
-"""Support for presenting detailed information in failing assertions."""
-
-from __future__ import annotations
-
-from collections.abc import Generator
-import sys
-from typing import Any
-from typing import Protocol
-from typing import TYPE_CHECKING
-
-from _pytest.assertion import rewrite
-from _pytest.assertion import truncate
-from _pytest.assertion import util
-from _pytest.assertion.rewrite import assertstate_key
-from _pytest.config import Config
-from _pytest.config import hookimpl
-from _pytest.config.argparsing import Parser
-from _pytest.nodes import Item
-
-
-if TYPE_CHECKING:
-    from _pytest.main import Session
-
-
-def pytest_addoption(parser: Parser) -> None:
-    group = parser.getgroup("debugconfig")
-    group.addoption(
-        "--assert",
-        action="store",
-        dest="assertmode",
-        choices=("rewrite", "plain"),
-        default="rewrite",
-        metavar="MODE",
-        help=(
-            "Control assertion debugging tools.\n"
-            "'plain' performs no assertion debugging.\n"
-            "'rewrite' (the default) rewrites assert statements in test modules"
-            " on import to provide assert expression information."
-        ),
-    )
-    parser.addini(
-        "enable_assertion_pass_hook",
-        type="bool",
-        default=False,
-        help="Enables the pytest_assertion_pass hook. "
-        "Make sure to delete any previously generated pyc cache files.",
-    )
-
-    parser.addini(
-        "truncation_limit_lines",
-        default=None,
-        help="Set threshold of LINES after which truncation will take effect",
-    )
-    parser.addini(
-        "truncation_limit_chars",
-        default=None,
-        help=("Set threshold of CHARS after which truncation will take effect"),
-    )
-    parser.addini(
-        "assertion_text_diff_style",
-        default=util.ASSERTION_TEXT_DIFF_STYLE_NDIFF,
-        help=(
-            "Choose how pytest renders diffs for string equality assertions: "
-            f"{util.ASSERTION_TEXT_DIFF_STYLE_NDIFF} or "
-            f"{util.ASSERTION_TEXT_DIFF_STYLE_BLOCK}"
-        ),
-    )
-
-    Config._add_verbosity_ini(
-        parser,
-        Config.VERBOSITY_ASSERTIONS,
-        help=(
-            "Specify a verbosity level for assertions, overriding the main level. "
-            "Higher levels will provide more detailed explanation when an assertion fails."
-        ),
-    )
-
-
-def pytest_configure(config: Config) -> None:
-    util.validate_assertion_text_diff_style(config)
-
-
-def register_assert_rewrite(*names: str) -> None:
-    """Register one or more module names to be rewritten on import.
-
-    This function will make sure that this module or all modules inside
-    the package will get their assert statements rewritten.
-    Thus you should make sure to call this before the module is
-    actually imported, usually in your __init__.py if you are a plugin
-    using a package.
-
-    :param names: The module names to register.
-    """
-    for name in names:
-        if not isinstance(name, str):
-            msg = "expected module names as *args, got {0} instead"  # type: ignore[unreachable]
-            raise TypeError(msg.format(repr(names)))
-    rewrite_hook: RewriteHook
-    for hook in sys.meta_path:
-        if isinstance(hook, rewrite.AssertionRewritingHook):
-            rewrite_hook = hook
-            break
-    else:
-        rewrite_hook = DummyRewriteHook()
-    rewrite_hook.mark_rewrite(*names)
-
-
-class RewriteHook(Protocol):
-    def mark_rewrite(self, *names: str) -> None: ...
-
-
-class DummyRewriteHook:
-    """A no-op import hook for when rewriting is disabled."""
-
-    def mark_rewrite(self, *names: str) -> None:
-        pass
-
-
-class AssertionState:
-    """State for the assertion plugin."""
-
-    def __init__(self, config: Config, mode) -> None:
-        self.mode = mode
-        self.trace = config.trace.root.get("assertion")
-        self.hook: rewrite.AssertionRewritingHook | None = None
-
-
-def install_importhook(config: Config) -> rewrite.AssertionRewritingHook:
-    """Try to install the rewrite hook, raise SystemError if it fails."""
-    config.stash[assertstate_key] = AssertionState(config, "rewrite")
-    config.stash[assertstate_key].hook = hook = rewrite.AssertionRewritingHook(config)
-    sys.meta_path.insert(0, hook)
-    config.stash[assertstate_key].trace("installed rewrite import hook")
-
-    def undo() -> None:
-        hook = config.stash[assertstate_key].hook
-        if hook is not None and hook in sys.meta_path:
-            sys.meta_path.remove(hook)
-
-    config.add_cleanup(undo)
-    return hook
-
-
-def pytest_collection(session: Session) -> None:
-    # This hook is only called when test modules are collected
-    # so for example not in the managing process of pytest-xdist
-    # (which does not collect test modules).
-    assertstate = session.config.stash.get(assertstate_key, None)
-    if assertstate:
-        if assertstate.hook is not None:
-            assertstate.hook.set_session(session)
-
-
-@hookimpl(wrapper=True, tryfirst=True)
-def pytest_runtest_protocol(item: Item) -> Generator[None, object, object]:
-    """Setup the pytest_assertrepr_compare and pytest_assertion_pass hooks.
-
-    The rewrite module will use util._reprcompare if it exists to use custom
-    reporting via the pytest_assertrepr_compare hook.  This sets up this custom
-    comparison for the test.
-    """
-    ihook = item.ihook
-
-    def callbinrepr(op, left: object, right: object) -> str | None:
-        """Call the pytest_assertrepr_compare hook and prepare the result.
-
-        This uses the first result from the hook and then ensures the
-        following:
-        * Overly verbose explanations are truncated unless configured otherwise
-          (eg. if running in verbose mode).
-        * Embedded newlines are escaped to help util.format_explanation()
-          later.
-        * If the rewrite mode is used embedded %-characters are replaced
-          to protect later % formatting.
-
-        The result can be formatted by util.format_explanation() for
-        pretty printing.
-        """
-        hook_result = ihook.pytest_assertrepr_compare(
-            config=item.config, op=op, left=left, right=right
-        )
-        for new_expl in hook_result:
-            if new_expl:
-                new_expl = truncate.truncate_if_required(new_expl, item)
-                new_expl = [line.replace("\n", "\\n") for line in new_expl]
-                res = "\n~".join(new_expl)
-                if item.config.getvalue("assertmode") == "rewrite":
-                    res = res.replace("%", "%%")
-                return res
-        return None
-
-    saved_assert_hooks = util._reprcompare, util._assertion_pass
-    util._reprcompare = callbinrepr
-    util._config = item.config
-
-    if ihook.pytest_assertion_pass.get_hookimpls():
-
-        def call_assertion_pass_hook(lineno: int, orig: str, expl: str) -> None:
-            ihook.pytest_assertion_pass(item=item, lineno=lineno, orig=orig, expl=expl)
-
-        util._assertion_pass = call_assertion_pass_hook
-
-    try:
-        return (yield)
-    finally:
-        util._reprcompare, util._assertion_pass = saved_assert_hooks
-        util._config = None
-
-
-def pytest_sessionfinish(session: Session) -> None:
-    assertstate = session.config.stash.get(assertstate_key, None)
-    if assertstate:
-        if assertstate.hook is not None:
-            assertstate.hook.set_session(None)
-
-
-def pytest_assertrepr_compare(
-    config: Config, op: str, left: Any, right: Any
-) -> list[str] | None:
-    if config.pluginmanager.has_plugin("terminalreporter"):
-        highlighter = config.get_terminal_writer()._highlight
-    else:
-        # Keep it plaintext when not using terminalrepoterer (#14377).
-        highlighter = util.dummy_highlighter
-    explanation = list(
-        util.assertrepr_compare(
-            op=op,
-            left=left,
-            right=right,
-            verbose=config.get_verbosity(Config.VERBOSITY_ASSERTIONS),
-            highlighter=highlighter,
-            assertion_text_diff_style=util.get_assertion_text_diff_style(config),
-        )
-    )
-    return explanation or None

venv/Lib/site-packages/_pytest/assertion/_compare_any.py

@@ -1,131 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterator
-import dataclasses
-import pprint
-
-from _pytest.assertion._compare_mapping import _compare_eq_mapping
-from _pytest.assertion._compare_sequence import _compare_eq_iterable
-from _pytest.assertion._compare_sequence import _compare_eq_sequence
-from _pytest.assertion._compare_set import _compare_eq_set
-from _pytest.assertion._guards import has_default_eq
-from _pytest.assertion._guards import isattrs
-from _pytest.assertion._guards import isdatacls
-from _pytest.assertion._guards import isiterable
-from _pytest.assertion._guards import ismapping
-from _pytest.assertion._guards import isnamedtuple
-from _pytest.assertion._guards import issequence
-from _pytest.assertion._guards import isset
-from _pytest.assertion._guards import istext
-from _pytest.assertion._typing import _AssertionTextDiffStyle
-from _pytest.assertion._typing import _HighlightFunc
-from _pytest.assertion.compare_text import _compare_eq_text
-
-
-def _compare_eq_any(
-    left: object,
-    right: object,
-    highlighter: _HighlightFunc,
-    verbose: int,
-    assertion_text_diff_style: _AssertionTextDiffStyle,
-) -> Iterator[str]:
-    """Yield the per-line explanation for ``left == right`` (without summary).
-
-    Yields nothing when no specialised explanation applies, so consumers
-    can stream the output and bail out early (e.g. for truncation) without
-    materialising the entire diff first.
-    """
-    if istext(left) and istext(right):
-        yield from _compare_eq_text(
-            left,
-            right,
-            highlighter,
-            verbose,
-            assertion_text_diff_style,
-        )
-    else:
-        from _pytest.python_api import ApproxBase
-
-        # Although the common order should be obtained == approx(...), allow both ways.
-        if isinstance(right, ApproxBase):
-            yield from right._repr_compare(left)
-        elif isinstance(left, ApproxBase):
-            yield from left._repr_compare(right)
-        elif type(left) is type(right) and (
-            isdatacls(left) or isattrs(left) or isnamedtuple(left)
-        ):
-            # Note: unlike dataclasses/attrs, namedtuples compare only the
-            # field values, not the type or field names. But this branch
-            # intentionally only handles the same-type case, which was often
-            # used in older code bases before dataclasses/attrs were available.
-            yield from _compare_eq_cls(
-                left,
-                right,
-                highlighter,
-                verbose,
-                assertion_text_diff_style,
-            )
-        elif issequence(left) and issequence(right):
-            yield from _compare_eq_sequence(left, right, highlighter, verbose)
-        elif isset(left) and isset(right):
-            yield from _compare_eq_set(left, right, highlighter, verbose)
-        elif ismapping(left) and ismapping(right):
-            yield from _compare_eq_mapping(left, right, highlighter, verbose)
-
-        if isiterable(left) and isiterable(right):
-            yield from _compare_eq_iterable(left, right, highlighter, verbose)
-
-
-def _compare_eq_cls(
-    left: object,
-    right: object,
-    highlighter: _HighlightFunc,
-    verbose: int,
-    assertion_text_diff_style: _AssertionTextDiffStyle,
-) -> Iterator[str]:
-    if not has_default_eq(left):
-        return
-    if isdatacls(left):
-        all_fields = dataclasses.fields(left)
-        fields_to_check = [info.name for info in all_fields if info.compare]
-    elif isattrs(left):
-        all_fields = left.__attrs_attrs__  # type: ignore[attr-defined]
-        fields_to_check = [field.name for field in all_fields if getattr(field, "eq")]
-    elif isnamedtuple(left):
-        fields_to_check = left._fields  # type: ignore[attr-defined]
-    else:
-        assert False
-
-    indent = "  "
-    same = []
-    diff = []
-    for field in fields_to_check:
-        if getattr(left, field) == getattr(right, field):
-            same.append(field)
-        else:
-            diff.append(field)
-
-    if same or diff:
-        yield ""
-    if same and verbose < 2:
-        yield f"Omitting {len(same)} identical items, use -vv to show"
-    elif same:
-        yield "Matching attributes:"
-        yield from highlighter(pprint.pformat(same)).splitlines()
-    if diff:
-        yield "Differing attributes:"
-        yield from highlighter(pprint.pformat(diff)).splitlines()
-        for field in diff:
-            field_left = getattr(left, field)
-            field_right = getattr(right, field)
-            yield ""
-            yield f"Drill down into differing attribute {field}:"
-            yield f"{indent}{field}: {highlighter(repr(field_left))} != {highlighter(repr(field_right))}"
-            for line in _compare_eq_any(
-                field_left,
-                field_right,
-                highlighter,
-                verbose,
-                assertion_text_diff_style,
-            ):
-                yield indent + line

venv/Lib/site-packages/_pytest/assertion/_compare_mapping.py

@@ -1,48 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterator
-from collections.abc import Mapping
-import pprint
-
-from _pytest._io.saferepr import saferepr
-from _pytest.assertion._typing import _HighlightFunc
-
-
-def _compare_eq_mapping(
-    left: Mapping[object, object],
-    right: Mapping[object, object],
-    highlighter: _HighlightFunc,
-    verbose: int = 0,
-) -> Iterator[str]:
-    set_left = set(left)
-    set_right = set(right)
-    common = set_left.intersection(set_right)
-    same = {k: left[k] for k in common if left[k] == right[k]}
-    if same and verbose < 2:
-        yield f"Omitting {len(same)} identical items, use -vv to show"
-    elif same:
-        yield "Common items:"
-        yield from highlighter(pprint.pformat(same)).splitlines()
-    diff = {k for k in common if left[k] != right[k]}
-    if diff:
-        yield "Differing items:"
-        for k in diff:
-            yield (
-                highlighter(saferepr({k: left[k]}))
-                + " != "
-                + highlighter(saferepr({k: right[k]}))
-            )
-    extra_left = set_left - set_right
-    len_extra_left = len(extra_left)
-    if len_extra_left:
-        yield f"Left contains {len_extra_left} more item{'' if len_extra_left == 1 else 's'}:"
-        yield from highlighter(
-            pprint.pformat({k: left[k] for k in extra_left})
-        ).splitlines()
-    extra_right = set_right - set_left
-    len_extra_right = len(extra_right)
-    if len_extra_right:
-        yield f"Right contains {len_extra_right} more item{'' if len_extra_right == 1 else 's'}:"
-        yield from highlighter(
-            pprint.pformat({k: right[k] for k in extra_right})
-        ).splitlines()

venv/Lib/site-packages/_pytest/assertion/_compare_sequence.py

@@ -1,90 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterable
-from collections.abc import Iterator
-from collections.abc import Sequence
-
-from _pytest._io.pprint import PrettyPrinter
-from _pytest._io.saferepr import saferepr
-from _pytest.assertion._typing import _HighlightFunc
-from _pytest.compat import running_on_ci
-
-
-def _compare_eq_iterable(
-    left: Iterable[object],
-    right: Iterable[object],
-    highlighter: _HighlightFunc,
-    verbose: int = 0,
-) -> Iterator[str]:
-    if verbose <= 0 and not running_on_ci():
-        yield "Use -v to get more diff"
-        return
-    # dynamic import to speedup pytest
-    import difflib
-
-    left_formatting = PrettyPrinter().pformat(left).splitlines()
-    right_formatting = PrettyPrinter().pformat(right).splitlines()
-
-    yield ""
-    yield "Full diff:"
-    # "right" is the expected base against which we compare "left",
-    # see https://github.com/pytest-dev/pytest/issues/3333
-    yield from highlighter(
-        "\n".join(
-            line.rstrip() for line in difflib.ndiff(right_formatting, left_formatting)
-        ),
-        lexer="diff",
-    ).splitlines()
-
-
-def _compare_eq_sequence(
-    left: Sequence[object],
-    right: Sequence[object],
-    highlighter: _HighlightFunc,
-    verbose: int = 0,
-) -> Iterator[str]:
-    comparing_bytes = isinstance(left, bytes) and isinstance(right, bytes)
-    len_left = len(left)
-    len_right = len(right)
-    for i in range(min(len_left, len_right)):
-        if left[i] != right[i]:
-            if comparing_bytes:
-                # when comparing bytes, we want to see their ascii representation
-                # instead of their numeric values (#5260)
-                # using a slice gives us the ascii representation:
-                # >>> s = b'foo'
-                # >>> s[0]
-                # 102
-                # >>> s[0:1]
-                # b'f'
-                left_value: object = left[i : i + 1]
-                right_value: object = right[i : i + 1]
-            else:
-                left_value = left[i]
-                right_value = right[i]
-
-            yield (
-                f"At index {i} diff:"
-                f" {highlighter(repr(left_value))} != {highlighter(repr(right_value))}"
-            )
-            break
-
-    if comparing_bytes:
-        # when comparing bytes, it doesn't help to show the "sides contain one or more
-        # items" longer explanation, so skip it
-        return
-
-    len_diff = len_left - len_right
-    if len_diff:
-        if len_diff > 0:
-            dir_with_more = "Left"
-            extra = saferepr(left[len_right])
-        else:
-            len_diff = 0 - len_diff
-            dir_with_more = "Right"
-            extra = saferepr(right[len_left])
-
-        if len_diff == 1:
-            yield f"{dir_with_more} contains one more item: {highlighter(extra)}"
-        else:
-            yield f"{dir_with_more} contains {len_diff} more items, first extra item: {highlighter(extra)}"

venv/Lib/site-packages/_pytest/assertion/_compare_set.py

@@ -1,101 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Callable
-from collections.abc import Iterator
-from collections.abc import Set as AbstractSet
-from typing import TypeAlias
-
-from _pytest._io.saferepr import saferepr
-from _pytest.assertion._typing import _HighlightFunc
-
-
-def _set_one_sided_diff(
-    posn: str,
-    set1: AbstractSet[object],
-    set2: AbstractSet[object],
-    highlighter: _HighlightFunc,
-) -> Iterator[str]:
-    diff = set1 - set2
-    if diff:
-        yield f"Extra items in the {posn} set:"
-        for item in diff:
-            yield highlighter(saferepr(item))
-
-
-def _compare_eq_set(
-    left: AbstractSet[object],
-    right: AbstractSet[object],
-    highlighter: _HighlightFunc,
-    verbose: int = 0,
-) -> Iterator[str]:
-    yield from _set_one_sided_diff("left", left, right, highlighter)
-    yield from _set_one_sided_diff("right", right, left, highlighter)
-
-
-def _compare_gte_set(
-    left: AbstractSet[object],
-    right: AbstractSet[object],
-    highlighter: _HighlightFunc,
-    verbose: int = 0,
-) -> Iterator[str]:
-    yield from _set_one_sided_diff("right", right, left, highlighter)
-
-
-def _compare_lte_set(
-    left: AbstractSet[object],
-    right: AbstractSet[object],
-    highlighter: _HighlightFunc,
-    verbose: int = 0,
-) -> Iterator[str]:
-    yield from _set_one_sided_diff("left", left, right, highlighter)
-
-
-def _compare_gt_set(
-    left: AbstractSet[object],
-    right: AbstractSet[object],
-    highlighter: _HighlightFunc,
-    verbose: int = 0,
-) -> Iterator[str]:
-    if left == right:
-        yield "Both sets are equal"
-    else:
-        yield from _set_one_sided_diff("right", right, left, highlighter)
-
-
-def _compare_lt_set(
-    left: AbstractSet[object],
-    right: AbstractSet[object],
-    highlighter: _HighlightFunc,
-    verbose: int = 0,
-) -> Iterator[str]:
-    if left == right:
-        yield "Both sets are equal"
-    else:
-        yield from _set_one_sided_diff("left", left, right, highlighter)
-
-
-SetComparisonFunction: TypeAlias = Callable[
-    [AbstractSet[object], AbstractSet[object], _HighlightFunc, int],
-    Iterator[str],
-]
-
-
-def _both_sets_are_equal(
-    left: AbstractSet[object],
-    right: AbstractSet[object],
-    highlighter: _HighlightFunc,
-    verbose: int = 0,
-) -> Iterator[str]:
-    yield "Both sets are equal"
-
-
-SET_COMPARISON_FUNCTIONS: dict[str, SetComparisonFunction] = {
-    # == can't be done here without a prior refactor because there's an additional
-    # explanation for iterable in _compare_eq_any
-    # "==": _compare_eq_set,
-    "!=": _both_sets_are_equal,
-    ">=": _compare_gte_set,
-    "<=": _compare_lte_set,
-    ">": _compare_gt_set,
-    "<": _compare_lt_set,
-}

venv/Lib/site-packages/_pytest/assertion/_guards.py

@@ -1,60 +0,0 @@
-from __future__ import annotations
-
-import collections.abc
-from collections.abc import Mapping
-import dataclasses
-from typing import TypeGuard
-
-
-def issequence(x: object) -> TypeGuard[collections.abc.Sequence[object]]:
-    return isinstance(x, collections.abc.Sequence) and not isinstance(x, str)
-
-
-def istext(x: object) -> TypeGuard[str]:
-    return isinstance(x, str)
-
-
-def ismapping(x: object) -> TypeGuard[Mapping[object, object]]:
-    return isinstance(x, Mapping)
-
-
-def isset(x: object) -> TypeGuard[set[object] | frozenset[object]]:
-    return isinstance(x, set | frozenset)
-
-
-def isnamedtuple(obj: object) -> bool:
-    return isinstance(obj, tuple) and getattr(obj, "_fields", None) is not None
-
-
-isdatacls = dataclasses.is_dataclass
-
-
-def isattrs(obj: object) -> bool:
-    return getattr(obj, "__attrs_attrs__", None) is not None
-
-
-def isiterable(obj: object) -> TypeGuard[collections.abc.Iterable[object]]:
-    try:
-        iter(obj)  # type: ignore[call-overload]
-        return not istext(obj)
-    except Exception:
-        return False
-
-
-def has_default_eq(obj: object) -> bool:
-    """Check if an instance of an object contains the default eq
-
-    First, we check if the object's __eq__ attribute has __code__,
-    if so, we check the equally of the method code filename (__code__.co_filename)
-    to the default one generated by the dataclass and attr module
-    for dataclasses the default co_filename is <string>, for attrs class, the __eq__ should contain "attrs eq generated"
-    """
-    # inspired from https://github.com/willmcgugan/rich/blob/07d51ffc1aee6f16bd2e5a25b4e82850fb9ed778/rich/pretty.py#L68
-    if hasattr(obj.__eq__, "__code__") and hasattr(obj.__eq__.__code__, "co_filename"):
-        code_filename = obj.__eq__.__code__.co_filename
-
-        if isattrs(obj):
-            return "attrs generated " in code_filename
-
-        return code_filename == "<string>"  # data class
-    return True

venv/Lib/site-packages/_pytest/assertion/_typing.py

@@ -1,12 +0,0 @@
-from __future__ import annotations
-
-from typing import Literal
-from typing import Protocol
-
-
-_AssertionTextDiffStyle = Literal["ndiff", "block"]
-
-
-class _HighlightFunc(Protocol):  # noqa: PYI046
-    def __call__(self, source: str, lexer: Literal["diff", "python"] = "python") -> str:
-        """Apply highlighting to the given source."""

venv/Lib/site-packages/_pytest/assertion/compare_text.py

@@ -1,104 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterator
-
-from _pytest._io.saferepr import saferepr
-from _pytest.assertion._typing import _AssertionTextDiffStyle
-from _pytest.assertion._typing import _HighlightFunc
-from _pytest.assertion.highlight import dummy_highlighter
-from _pytest.compat import assert_never
-
-
-def _compare_eq_text(
-    left: str,
-    right: str,
-    highlighter: _HighlightFunc,
-    verbose: int,
-    assertion_text_diff_style: _AssertionTextDiffStyle,
-) -> Iterator[str]:
-    match assertion_text_diff_style:
-        case "block":
-            yield from _diff_text_block(left, right)
-        case "ndiff":
-            yield from _diff_text(left, right, highlighter, verbose)
-        case unreachable:
-            assert_never(unreachable)
-
-
-def _diff_text_block(left: str, right: str) -> Iterator[str]:
-    yield "Left:"
-    yield from _format_text_block_lines(left)
-    yield ""
-    yield "Right:"
-    yield from _format_text_block_lines(right)
-
-
-def _format_text_block_lines(text: str) -> Iterator[str]:
-    for line in text.split("\n"):
-        yield f"  {line}"
-
-
-def _diff_text(
-    left: str, right: str, highlighter: _HighlightFunc, verbose: int = 0
-) -> Iterator[str]:
-    """Yield the explanation for the diff between text.
-
-    Unless --verbose is used this will skip leading and trailing
-    characters which are identical to keep the diff minimal.
-    """
-    from difflib import ndiff
-
-    if verbose < 1:
-        i = 0  # just in case left or right has zero length
-        for i in range(min(len(left), len(right))):
-            if left[i] != right[i]:
-                break
-        if i > 42:
-            i -= 10  # Provide some context
-            yield f"Skipping {i} identical leading characters in diff, use -v to show"
-            left = left[i:]
-            right = right[i:]
-        if len(left) == len(right):
-            for i in range(len(left)):
-                if left[-i] != right[-i]:
-                    break
-            if i > 42:
-                i -= 10  # Provide some context
-                yield (
-                    f"Skipping {i} identical trailing "
-                    "characters in diff, use -v to show"
-                )
-                left = left[:-i]
-                right = right[:-i]
-    keepends = True
-    if left.isspace() or right.isspace():
-        left = repr(str(left))
-        right = repr(str(right))
-        yield "Strings contain only whitespace, escaping them using repr()"
-    # "right" is the expected base against which we compare "left",
-    # see https://github.com/pytest-dev/pytest/issues/3333
-    yield from highlighter(
-        "\n".join(
-            line.strip("\n")
-            for line in ndiff(right.splitlines(keepends), left.splitlines(keepends))
-        ),
-        lexer="diff",
-    ).splitlines()
-
-
-def _notin_text(term: str, text: str, verbose: int = 0) -> Iterator[str]:
-    index = text.find(term)
-    head = text[:index]
-    tail = text[index + len(term) :]
-    correct_text = head + tail
-    diff = _diff_text(text, correct_text, dummy_highlighter, verbose)
-    yield f"{saferepr(term, maxsize=42)} is contained here:"
-    for line in diff:
-        if line.startswith("Skipping"):
-            continue
-        if line.startswith("- "):
-            continue
-        if line.startswith("+ "):
-            yield "  " + line[2:]
-        else:
-            yield line

venv/Lib/site-packages/_pytest/assertion/highlight.py

@@ -1,11 +0,0 @@
-from __future__ import annotations
-
-from typing import Literal
-
-
-def dummy_highlighter(source: str, lexer: Literal["diff", "python"] = "python") -> str:
-    """Dummy highlighter that returns the text unprocessed.
-
-    Needed for _notin_text, as the diff gets post-processed to only show the "+" part.
-    """
-    return source

venv/Lib/site-packages/_pytest/assertion/rewrite.py

@@ -1,1193 +0,0 @@
-"""Rewrite assertion AST to produce nice error messages."""
-
-from __future__ import annotations
-
-import ast
-from collections import defaultdict
-from collections.abc import Callable
-from collections.abc import Iterable
-from collections.abc import Iterator
-from collections.abc import Sequence
-import errno
-import functools
-import importlib.abc
-import importlib.machinery
-import importlib.util
-import io
-import itertools
-import marshal
-import os
-from pathlib import Path
-from pathlib import PurePath
-import struct
-import sys
-import tokenize
-import types
-from typing import IO
-from typing import TYPE_CHECKING
-
-
-if sys.version_info >= (3, 12):
-    from importlib.resources.abc import TraversableResources
-else:
-    from importlib.abc import TraversableResources
-if sys.version_info < (3, 11):
-    from importlib.readers import FileReader
-else:
-    from importlib.resources.readers import FileReader
-
-
-from _pytest._io.saferepr import DEFAULT_REPR_MAX_SIZE
-from _pytest._io.saferepr import saferepr
-from _pytest._io.saferepr import saferepr_unlimited
-from _pytest._version import version
-from _pytest.assertion import util
-from _pytest.config import Config
-from _pytest.fixtures import FixtureFunctionDefinition
-from _pytest.main import Session
-from _pytest.pathlib import absolutepath
-from _pytest.pathlib import fnmatch_ex
-from _pytest.stash import StashKey
-
-
-# fmt: off
-from _pytest.assertion.util import format_explanation as _format_explanation  # noqa:F401, isort:skip
-# fmt:on
-
-if TYPE_CHECKING:
-    from _pytest.assertion import AssertionState
-
-
-class Sentinel:
-    pass
-
-
-assertstate_key = StashKey["AssertionState"]()
-
-# pytest caches rewritten pycs in pycache dirs
-PYTEST_TAG = f"{sys.implementation.cache_tag}-pytest-{version}"
-PYC_EXT = ".py" + ((__debug__ and "c") or "o")
-PYC_TAIL = "." + PYTEST_TAG + PYC_EXT
-
-# Special marker that denotes we have just left a scope definition
-_SCOPE_END_MARKER = Sentinel()
-
-
-class AssertionRewritingHook(importlib.abc.MetaPathFinder, importlib.abc.Loader):
-    """PEP302/PEP451 import hook which rewrites asserts."""
-
-    def __init__(self, config: Config) -> None:
-        self.config = config
-        try:
-            self.fnpats = config.getini("python_files")
-        except ValueError:
-            self.fnpats = ["test_*.py", "*_test.py"]
-        self.session: Session | None = None
-        self._rewritten_names: dict[str, Path] = {}
-        self._must_rewrite: set[str] = set()
-        # flag to guard against trying to rewrite a pyc file while we are already writing another pyc file,
-        # which might result in infinite recursion (#3506)
-        self._writing_pyc = False
-        self._basenames_to_check_rewrite = {"conftest"}
-        self._marked_for_rewrite_cache: dict[str, bool] = {}
-        self._session_paths_checked = False
-
-    def set_session(self, session: Session | None) -> None:
-        self.session = session
-        self._session_paths_checked = False
-
-    # Indirection so we can mock calls to find_spec originated from the hook during testing
-    _find_spec = importlib.machinery.PathFinder.find_spec
-
-    def find_spec(
-        self,
-        name: str,
-        path: Sequence[str | bytes] | None = None,
-        target: types.ModuleType | None = None,
-    ) -> importlib.machinery.ModuleSpec | None:
-        if self._writing_pyc:
-            return None
-        state = self.config.stash[assertstate_key]
-        if self._early_rewrite_bailout(name, state):
-            return None
-        state.trace(f"find_module called for: {name}")
-
-        # Type ignored because mypy is confused about the `self` binding here.
-        spec = self._find_spec(name, path)  # type: ignore
-
-        if (
-            # the import machinery could not find a file to import
-            spec is None
-            # this is a namespace package (without `__init__.py`)
-            # there's nothing to rewrite there
-            or spec.origin is None
-            # we can only rewrite source files
-            or not isinstance(spec.loader, importlib.machinery.SourceFileLoader)
-            # if the file doesn't exist, we can't rewrite it
-            or not os.path.exists(spec.origin)
-        ):
-            return None
-        else:
-            fn = spec.origin
-
-        if not self._should_rewrite(name, fn, state):
-            return None
-
-        return importlib.util.spec_from_file_location(
-            name,
-            fn,
-            loader=self,
-            submodule_search_locations=spec.submodule_search_locations,
-        )
-
-    def create_module(
-        self, spec: importlib.machinery.ModuleSpec
-    ) -> types.ModuleType | None:
-        return None  # default behaviour is fine
-
-    def exec_module(self, module: types.ModuleType) -> None:
-        assert module.__spec__ is not None
-        assert module.__spec__.origin is not None
-        fn = Path(module.__spec__.origin)
-        state = self.config.stash[assertstate_key]
-
-        self._rewritten_names[module.__name__] = fn
-
-        # The requested module looks like a test file, so rewrite it. This is
-        # the most magical part of the process: load the source, rewrite the
-        # asserts, and load the rewritten source. We also cache the rewritten
-        # module code in a special pyc. We must be aware of the possibility of
-        # concurrent pytest processes rewriting and loading pycs. To avoid
-        # tricky race conditions, we maintain the following invariant: The
-        # cached pyc is always a complete, valid pyc. Operations on it must be
-        # atomic. POSIX's atomic rename comes in handy.
-        write = not sys.dont_write_bytecode
-        cache_dir = get_cache_dir(fn)
-        if write:
-            ok = try_makedirs(cache_dir)
-            if not ok:
-                write = False
-                state.trace(f"read only directory: {cache_dir}")
-
-        cache_name = fn.name[:-3] + PYC_TAIL
-        pyc = cache_dir / cache_name
-        # Notice that even if we're in a read-only directory, I'm going
-        # to check for a cached pyc. This may not be optimal...
-        co = _read_pyc(fn, pyc, state.trace)
-        if co is None:
-            state.trace(f"rewriting {fn!r}")
-            source_stat, co = _rewrite_test(fn, self.config)
-            if write:
-                self._writing_pyc = True
-                try:
-                    _write_pyc(state, co, source_stat, pyc)
-                finally:
-                    self._writing_pyc = False
-        else:
-            state.trace(f"found cached rewritten pyc for {fn}")
-        exec(co, module.__dict__)
-
-    def _early_rewrite_bailout(self, name: str, state: AssertionState) -> bool:
-        """A fast way to get out of rewriting modules.
-
-        Profiling has shown that the call to PathFinder.find_spec (inside of
-        the find_spec from this class) is a major slowdown, so, this method
-        tries to filter what we're sure won't be rewritten before getting to
-        it.
-        """
-        if self.session is not None and not self._session_paths_checked:
-            self._session_paths_checked = True
-            for initial_path in self.session._initialpaths:
-                # Make something as c:/projects/my_project/path.py ->
-                #     ['c:', 'projects', 'my_project', 'path.py']
-                parts = str(initial_path).split(os.sep)
-                # add 'path' to basenames to be checked.
-                self._basenames_to_check_rewrite.add(os.path.splitext(parts[-1])[0])
-
-        # Note: conftest already by default in _basenames_to_check_rewrite.
-        parts = name.split(".")
-        if parts[-1] in self._basenames_to_check_rewrite:
-            return False
-
-        # For matching the name it must be as if it was a filename.
-        path = PurePath(*parts).with_suffix(".py")
-
-        for pat in self.fnpats:
-            # if the pattern contains subdirectories ("tests/**.py" for example) we can't bail out based
-            # on the name alone because we need to match against the full path
-            if os.path.dirname(pat):
-                return False
-            if fnmatch_ex(pat, path):
-                return False
-
-        if self._is_marked_for_rewrite(name, state):
-            return False
-
-        state.trace(f"early skip of rewriting module: {name}")
-        return True
-
-    def _should_rewrite(self, name: str, fn: str, state: AssertionState) -> bool:
-        # always rewrite conftest files
-        if os.path.basename(fn) == "conftest.py":
-            state.trace(f"rewriting conftest file: {fn!r}")
-            return True
-
-        if self.session is not None:
-            if self.session.isinitpath(absolutepath(fn)):
-                state.trace(f"matched test file (was specified on cmdline): {fn!r}")
-                return True
-
-        # modules not passed explicitly on the command line are only
-        # rewritten if they match the naming convention for test files
-        fn_path = PurePath(fn)
-        for pat in self.fnpats:
-            if fnmatch_ex(pat, fn_path):
-                state.trace(f"matched test file {fn!r}")
-                return True
-
-        return self._is_marked_for_rewrite(name, state)
-
-    def _is_marked_for_rewrite(self, name: str, state: AssertionState) -> bool:
-        try:
-            return self._marked_for_rewrite_cache[name]
-        except KeyError:
-            for marked in self._must_rewrite:
-                if name == marked or name.startswith(marked + "."):
-                    state.trace(f"matched marked file {name!r} (from {marked!r})")
-                    self._marked_for_rewrite_cache[name] = True
-                    return True
-
-            self._marked_for_rewrite_cache[name] = False
-            return False
-
-    def mark_rewrite(self, *names: str) -> None:
-        """Mark import names as needing to be rewritten.
-
-        The named module or package as well as any nested modules will
-        be rewritten on import.
-        """
-        already_imported = (
-            set(names).intersection(sys.modules).difference(self._rewritten_names)
-        )
-        for name in already_imported:
-            mod = sys.modules[name]
-            if not AssertionRewriter.is_rewrite_disabled(
-                mod.__doc__ or ""
-            ) and not isinstance(mod.__loader__, type(self)):
-                self._warn_already_imported(name)
-        self._must_rewrite.update(names)
-        self._marked_for_rewrite_cache.clear()
-
-    def _warn_already_imported(self, name: str) -> None:
-        from _pytest.warning_types import PytestAssertRewriteWarning
-
-        self.config.issue_config_time_warning(
-            PytestAssertRewriteWarning(
-                f"Module already imported so cannot be rewritten; {name}"
-            ),
-            stacklevel=5,
-        )
-
-    def get_data(self, pathname: str | bytes) -> bytes:
-        """Optional PEP302 get_data API."""
-        with open(pathname, "rb") as f:
-            return f.read()
-
-    def get_resource_reader(self, name: str) -> TraversableResources:
-        return FileReader(types.SimpleNamespace(path=self._rewritten_names[name]))  # type: ignore[arg-type]
-
-
-def _write_pyc_fp(
-    fp: IO[bytes], source_stat: os.stat_result, co: types.CodeType
-) -> None:
-    # Technically, we don't have to have the same pyc format as
-    # (C)Python, since these "pycs" should never be seen by builtin
-    # import. However, there's little reason to deviate.
-    fp.write(importlib.util.MAGIC_NUMBER)
-    # https://www.python.org/dev/peps/pep-0552/
-    flags = b"\x00\x00\x00\x00"
-    fp.write(flags)
-    # as of now, bytecode header expects 32-bit numbers for size and mtime (#4903)
-    mtime = int(source_stat.st_mtime) & 0xFFFFFFFF
-    size = source_stat.st_size & 0xFFFFFFFF
-    # "<LL" stands for 2 unsigned longs, little-endian.
-    fp.write(struct.pack("<LL", mtime, size))
-    fp.write(marshal.dumps(co))
-
-
-def _write_pyc(
-    state: AssertionState,
-    co: types.CodeType,
-    source_stat: os.stat_result,
-    pyc: Path,
-) -> bool:
-    proc_pyc = f"{pyc}.{os.getpid()}"
-    try:
-        with open(proc_pyc, "wb") as fp:
-            _write_pyc_fp(fp, source_stat, co)
-    except OSError as e:
-        state.trace(f"error writing pyc file at {proc_pyc}: errno={e.errno}")
-        return False
-
-    try:
-        os.replace(proc_pyc, pyc)
-    except OSError as e:
-        state.trace(f"error writing pyc file at {pyc}: {e}")
-        # we ignore any failure to write the cache file
-        # there are many reasons, permission-denied, pycache dir being a
-        # file etc.
-        return False
-    return True
-
-
-def _rewrite_test(fn: Path, config: Config) -> tuple[os.stat_result, types.CodeType]:
-    """Read and rewrite *fn* and return the code object."""
-    stat = os.stat(fn)
-    source = fn.read_bytes()
-    strfn = str(fn)
-    tree = ast.parse(source, filename=strfn)
-    rewrite_asserts(tree, source, strfn, config)
-    co = compile(tree, strfn, "exec", dont_inherit=True)
-    return stat, co
-
-
-def _read_pyc(
-    source: Path, pyc: Path, trace: Callable[[str], None] = lambda x: None
-) -> types.CodeType | None:
-    """Possibly read a pytest pyc containing rewritten code.
-
-    Return rewritten code if successful or None if not.
-    """
-    try:
-        fp = open(pyc, "rb")
-    except OSError:
-        return None
-    with fp:
-        try:
-            stat_result = os.stat(source)
-            mtime = int(stat_result.st_mtime)
-            size = stat_result.st_size
-            data = fp.read(16)
-        except OSError as e:
-            trace(f"_read_pyc({source}): OSError {e}")
-            return None
-        # Check for invalid or out of date pyc file.
-        if len(data) != (16):
-            trace(f"_read_pyc({source}): invalid pyc (too short)")
-            return None
-        if data[:4] != importlib.util.MAGIC_NUMBER:
-            trace(f"_read_pyc({source}): invalid pyc (bad magic number)")
-            return None
-        if data[4:8] != b"\x00\x00\x00\x00":
-            trace(f"_read_pyc({source}): invalid pyc (unsupported flags)")
-            return None
-        mtime_data = data[8:12]
-        if int.from_bytes(mtime_data, "little") != mtime & 0xFFFFFFFF:
-            trace(f"_read_pyc({source}): out of date")
-            return None
-        size_data = data[12:16]
-        if int.from_bytes(size_data, "little") != size & 0xFFFFFFFF:
-            trace(f"_read_pyc({source}): invalid pyc (incorrect size)")
-            return None
-        try:
-            co = marshal.load(fp)
-        except Exception as e:
-            trace(f"_read_pyc({source}): marshal.load error {e}")
-            return None
-        if not isinstance(co, types.CodeType):
-            trace(f"_read_pyc({source}): not a code object")
-            return None
-        return co
-
-
-def rewrite_asserts(
-    mod: ast.Module,
-    source: bytes,
-    module_path: str | None = None,
-    config: Config | None = None,
-) -> None:
-    """Rewrite the assert statements in mod."""
-    AssertionRewriter(module_path, config, source).run(mod)
-
-
-def _saferepr(obj: object) -> str:
-    r"""Get a safe repr of an object for assertion error messages.
-
-    The assertion formatting (util.format_explanation()) requires
-    newlines to be escaped since they are a special character for it.
-    Normally assertion.util.format_explanation() does this but for a
-    custom repr it is possible to contain one of the special escape
-    sequences, especially '\n{' and '\n}' are likely to be present in
-    JSON reprs.
-    """
-    if isinstance(obj, types.MethodType):
-        # for bound methods, skip redundant <bound method ...> information
-        return obj.__name__
-
-    maxsize = _get_maxsize_for_saferepr(util._config)
-    if not maxsize:
-        return saferepr_unlimited(obj).replace("\n", "\\n")
-    return saferepr(obj, maxsize=maxsize).replace("\n", "\\n")
-
-
-def _get_maxsize_for_saferepr(config: Config | None) -> int | None:
-    """Get `maxsize` configuration for saferepr based on the given config object."""
-    if config is None:
-        verbosity = 0
-    else:
-        verbosity = config.get_verbosity(Config.VERBOSITY_ASSERTIONS)
-    if verbosity >= 2:
-        return None
-    if verbosity >= 1:
-        return DEFAULT_REPR_MAX_SIZE * 10
-    return DEFAULT_REPR_MAX_SIZE
-
-
-def _format_assertmsg(obj: object) -> str:
-    r"""Format the custom assertion message given.
-
-    For strings this simply replaces newlines with '\n~' so that
-    util.format_explanation() will preserve them instead of escaping
-    newlines.  For other objects saferepr() is used first.
-    """
-    # reprlib appears to have a bug which means that if a string
-    # contains a newline it gets escaped, however if an object has a
-    # .__repr__() which contains newlines it does not get escaped.
-    # However in either case we want to preserve the newline.
-    replaces = [("\n", "\n~"), ("%", "%%")]
-    if not isinstance(obj, str):
-        obj = saferepr(obj, _get_maxsize_for_saferepr(util._config))
-        replaces.append(("\\n", "\n~"))
-
-    for r1, r2 in replaces:
-        obj = obj.replace(r1, r2)
-
-    return obj
-
-
-def _should_repr_global_name(obj: object) -> bool:
-    if callable(obj):
-        # For pytest fixtures the __repr__ method provides more information than the function name.
-        return isinstance(obj, FixtureFunctionDefinition)
-
-    try:
-        return not hasattr(obj, "__name__")
-    except Exception:
-        return True
-
-
-def _format_boolop(explanations: Iterable[str], is_or: bool) -> str:
-    explanation = "(" + ((is_or and " or ") or " and ").join(explanations) + ")"
-    return explanation.replace("%", "%%")
-
-
-def _call_reprcompare(
-    ops: Sequence[str],
-    results: Sequence[bool],
-    expls: Sequence[str],
-    each_obj: Sequence[object],
-) -> str:
-    for i, res, expl in zip(range(len(ops)), results, expls, strict=True):
-        try:
-            done = not res
-        except Exception:
-            done = True
-        if done:
-            break
-    if util._reprcompare is not None:
-        custom = util._reprcompare(ops[i], each_obj[i], each_obj[i + 1])
-        if custom is not None:
-            return custom
-    return expl
-
-
-def _call_assertion_pass(lineno: int, orig: str, expl: str) -> None:
-    if util._assertion_pass is not None:
-        util._assertion_pass(lineno, orig, expl)
-
-
-def _check_if_assertion_pass_impl() -> bool:
-    """Check if any plugins implement the pytest_assertion_pass hook
-    in order not to generate explanation unnecessarily (might be expensive)."""
-    return True if util._assertion_pass else False
-
-
-UNARY_MAP = {ast.Not: "not %s", ast.Invert: "~%s", ast.USub: "-%s", ast.UAdd: "+%s"}
-
-BINOP_MAP = {
-    ast.BitOr: "|",
-    ast.BitXor: "^",
-    ast.BitAnd: "&",
-    ast.LShift: "<<",
-    ast.RShift: ">>",
-    ast.Add: "+",
-    ast.Sub: "-",
-    ast.Mult: "*",
-    ast.Div: "/",
-    ast.FloorDiv: "//",
-    ast.Mod: "%%",  # escaped for string formatting
-    ast.Eq: "==",
-    ast.NotEq: "!=",
-    ast.Lt: "<",
-    ast.LtE: "<=",
-    ast.Gt: ">",
-    ast.GtE: ">=",
-    ast.Pow: "**",
-    ast.Is: "is",
-    ast.IsNot: "is not",
-    ast.In: "in",
-    ast.NotIn: "not in",
-    ast.MatMult: "@",
-}
-
-
-def traverse_node(node: ast.AST) -> Iterator[ast.AST]:
-    """Recursively yield node and all its children in depth-first order."""
-    yield node
-    for child in ast.iter_child_nodes(node):
-        yield from traverse_node(child)
-
-
-@functools.lru_cache(maxsize=1)
-def _get_assertion_exprs(src: bytes) -> dict[int, str]:
-    """Return a mapping from {lineno: "assertion test expression"}."""
-    ret: dict[int, str] = {}
-
-    depth = 0
-    lines: list[str] = []
-    assert_lineno: int | None = None
-    seen_lines: set[int] = set()
-
-    def _write_and_reset() -> None:
-        nonlocal depth, lines, assert_lineno, seen_lines
-        assert assert_lineno is not None
-        ret[assert_lineno] = "".join(lines).rstrip().rstrip("\\")
-        depth = 0
-        lines = []
-        assert_lineno = None
-        seen_lines = set()
-
-    tokens = tokenize.tokenize(io.BytesIO(src).readline)
-    for tp, source, (lineno, offset), _, line in tokens:
-        if tp == tokenize.NAME and source == "assert":
-            assert_lineno = lineno
-        elif assert_lineno is not None:
-            # keep track of depth for the assert-message `,` lookup
-            if tp == tokenize.OP and source in "([{":
-                depth += 1
-            elif tp == tokenize.OP and source in ")]}":
-                depth -= 1
-
-            if not lines:
-                lines.append(line[offset:])
-                seen_lines.add(lineno)
-            # a non-nested comma separates the expression from the message
-            elif depth == 0 and tp == tokenize.OP and source == ",":
-                # one line assert with message
-                if lineno in seen_lines and len(lines) == 1:
-                    offset_in_trimmed = offset + len(lines[-1]) - len(line)
-                    lines[-1] = lines[-1][:offset_in_trimmed]
-                # multi-line assert with message
-                elif lineno in seen_lines:
-                    lines[-1] = lines[-1][:offset]
-                # multi line assert with escaped newline before message
-                else:
-                    lines.append(line[:offset])
-                _write_and_reset()
-            elif tp in {tokenize.NEWLINE, tokenize.ENDMARKER}:
-                _write_and_reset()
-            elif lines and lineno not in seen_lines:
-                lines.append(line)
-                seen_lines.add(lineno)
-
-    return ret
-
-
-class AssertionRewriter(ast.NodeVisitor):
-    """Assertion rewriting implementation.
-
-    The main entrypoint is to call .run() with an ast.Module instance,
-    this will then find all the assert statements and rewrite them to
-    provide intermediate values and a detailed assertion error.  See
-    http://pybites.blogspot.be/2011/07/behind-scenes-of-pytests-new-assertion.html
-    for an overview of how this works.
-
-    The entry point here is .run() which will iterate over all the
-    statements in an ast.Module and for each ast.Assert statement it
-    finds call .visit() with it.  Then .visit_Assert() takes over and
-    is responsible for creating new ast statements to replace the
-    original assert statement: it rewrites the test of an assertion
-    to provide intermediate values and replace it with an if statement
-    which raises an assertion error with a detailed explanation in
-    case the expression is false and calls pytest_assertion_pass hook
-    if expression is true.
-
-    For this .visit_Assert() uses the visitor pattern to visit all the
-    AST nodes of the ast.Assert.test field, each visit call returning
-    an AST node and the corresponding explanation string.  During this
-    state is kept in several instance attributes:
-
-    :statements: All the AST statements which will replace the assert
-       statement.
-
-    :variables: This is populated by .variable() with each variable
-       used by the statements so that they can all be set to None at
-       the end of the statements.
-
-    :variable_counter: Counter to create new unique variables needed
-       by statements.  Variables are created using .variable() and
-       have the form of "@py_assert0".
-
-    :expl_stmts: The AST statements which will be executed to get
-       data from the assertion.  This is the code which will construct
-       the detailed assertion message that is used in the AssertionError
-       or for the pytest_assertion_pass hook.
-
-    :explanation_specifiers: A dict filled by .explanation_param()
-       with %-formatting placeholders and their corresponding
-       expressions to use in the building of an assertion message.
-       This is used by .pop_format_context() to build a message.
-
-    :stack: A stack of the explanation_specifiers dicts maintained by
-       .push_format_context() and .pop_format_context() which allows
-       to build another %-formatted string while already building one.
-
-    :scope: A tuple containing the current scope used for variables_overwrite.
-
-    :variables_overwrite: A dict filled with references to variables
-       that change value within an assert. This happens when a variable is
-       reassigned with the walrus operator
-
-    This state, except the variables_overwrite,  is reset on every new assert
-    statement visited and used by the other visitors.
-    """
-
-    def __init__(
-        self, module_path: str | None, config: Config | None, source: bytes
-    ) -> None:
-        super().__init__()
-        self.module_path = module_path
-        self.config = config
-        if config is not None:
-            self.enable_assertion_pass_hook = config.getini(
-                "enable_assertion_pass_hook"
-            )
-        else:
-            self.enable_assertion_pass_hook = False
-        self.source = source
-        self.scope: tuple[ast.AST, ...] = ()
-        self.variables_overwrite: defaultdict[tuple[ast.AST, ...], dict[str, str]] = (
-            defaultdict(dict)
-        )
-
-    def run(self, mod: ast.Module) -> None:
-        """Find all assert statements in *mod* and rewrite them."""
-        if not mod.body:
-            # Nothing to do.
-            return
-
-        # We'll insert some special imports at the top of the module, but after any
-        # docstrings and __future__ imports, so first figure out where that is.
-        doc = getattr(mod, "docstring", None)
-        expect_docstring = doc is None
-        if doc is not None and self.is_rewrite_disabled(doc):
-            return
-        pos = 0
-        for item in mod.body:
-            match item:
-                case ast.Expr(value=ast.Constant(value=str() as doc)) if (
-                    expect_docstring
-                ):
-                    if self.is_rewrite_disabled(doc):
-                        return
-                    expect_docstring = False
-                case ast.ImportFrom(level=0, module="__future__"):
-                    pass
-                case _:
-                    break
-            pos += 1
-        # Special case: for a decorated function, set the lineno to that of the
-        # first decorator, not the `def`. Issue #4984.
-        if isinstance(item, ast.FunctionDef) and item.decorator_list:
-            lineno = item.decorator_list[0].lineno
-        else:
-            lineno = item.lineno
-        # Now actually insert the special imports.
-        aliases = [
-            ast.alias("builtins", "@py_builtins", lineno=lineno, col_offset=0),
-            ast.alias(
-                "_pytest.assertion.rewrite",
-                "@pytest_ar",
-                lineno=lineno,
-                col_offset=0,
-            ),
-        ]
-        imports = [
-            ast.Import([alias], lineno=lineno, col_offset=0) for alias in aliases
-        ]
-        mod.body[pos:pos] = imports
-
-        # Collect asserts.
-        self.scope = (mod,)
-        nodes: list[ast.AST | Sentinel] = [mod]
-        while nodes:
-            node = nodes.pop()
-            if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef):
-                self.scope = tuple((*self.scope, node))
-                nodes.append(_SCOPE_END_MARKER)
-            if node == _SCOPE_END_MARKER:
-                self.scope = self.scope[:-1]
-                continue
-            assert isinstance(node, ast.AST)
-            for name, field in ast.iter_fields(node):
-                if isinstance(field, list):
-                    new: list[ast.AST] = []
-                    for i, child in enumerate(field):
-                        if isinstance(child, ast.Assert):
-                            # Transform assert.
-                            new.extend(self.visit(child))
-                        else:
-                            new.append(child)
-                            if isinstance(child, ast.AST):
-                                nodes.append(child)
-                    setattr(node, name, new)
-                elif (
-                    isinstance(field, ast.AST)
-                    # Don't recurse into expressions as they can't contain
-                    # asserts.
-                    and not isinstance(field, ast.expr)
-                ):
-                    nodes.append(field)
-
-    @staticmethod
-    def is_rewrite_disabled(docstring: str) -> bool:
-        return "PYTEST_DONT_REWRITE" in docstring
-
-    def variable(self) -> str:
-        """Get a new variable."""
-        # Use a character invalid in python identifiers to avoid clashing.
-        name = "@py_assert" + str(next(self.variable_counter))
-        self.variables.append(name)
-        return name
-
-    def assign(self, expr: ast.expr) -> ast.Name:
-        """Give *expr* a name."""
-        name = self.variable()
-        self.statements.append(ast.Assign([ast.Name(name, ast.Store())], expr))
-        return ast.copy_location(ast.Name(name, ast.Load()), expr)
-
-    def display(self, expr: ast.expr) -> ast.expr:
-        """Call saferepr on the expression."""
-        return self.helper("_saferepr", expr)
-
-    def helper(self, name: str, *args: ast.expr) -> ast.expr:
-        """Call a helper in this module."""
-        py_name = ast.Name("@pytest_ar", ast.Load())
-        attr = ast.Attribute(py_name, name, ast.Load())
-        return ast.Call(attr, list(args), [])
-
-    def builtin(self, name: str) -> ast.Attribute:
-        """Return the builtin called *name*."""
-        builtin_name = ast.Name("@py_builtins", ast.Load())
-        return ast.Attribute(builtin_name, name, ast.Load())
-
-    def explanation_param(self, expr: ast.expr) -> str:
-        """Return a new named %-formatting placeholder for expr.
-
-        This creates a %-formatting placeholder for expr in the
-        current formatting context, e.g. ``%(py0)s``.  The placeholder
-        and expr are placed in the current format context so that it
-        can be used on the next call to .pop_format_context().
-        """
-        specifier = "py" + str(next(self.variable_counter))
-        self.explanation_specifiers[specifier] = expr
-        return "%(" + specifier + ")s"
-
-    def push_format_context(self) -> None:
-        """Create a new formatting context.
-
-        The format context is used for when an explanation wants to
-        have a variable value formatted in the assertion message.  In
-        this case the value required can be added using
-        .explanation_param().  Finally .pop_format_context() is used
-        to format a string of %-formatted values as added by
-        .explanation_param().
-        """
-        self.explanation_specifiers: dict[str, ast.expr] = {}
-        self.stack.append(self.explanation_specifiers)
-
-    def pop_format_context(self, expl_expr: ast.expr) -> ast.Name:
-        """Format the %-formatted string with current format context.
-
-        The expl_expr should be an str ast.expr instance constructed from
-        the %-placeholders created by .explanation_param().  This will
-        add the required code to format said string to .expl_stmts and
-        return the ast.Name instance of the formatted string.
-        """
-        current = self.stack.pop()
-        if self.stack:
-            self.explanation_specifiers = self.stack[-1]
-        keys: list[ast.expr | None] = [ast.Constant(key) for key in current.keys()]
-        format_dict = ast.Dict(keys, list(current.values()))
-        form = ast.BinOp(expl_expr, ast.Mod(), format_dict)
-        name = "@py_format" + str(next(self.variable_counter))
-        if self.enable_assertion_pass_hook:
-            self.format_variables.append(name)
-        self.expl_stmts.append(ast.Assign([ast.Name(name, ast.Store())], form))
-        return ast.Name(name, ast.Load())
-
-    def generic_visit(self, node: ast.AST) -> tuple[ast.Name, str]:
-        """Handle expressions we don't have custom code for."""
-        assert isinstance(node, ast.expr)
-        res = self.assign(node)
-        return res, self.explanation_param(self.display(res))
-
-    def visit_Assert(self, assert_: ast.Assert) -> list[ast.stmt]:
-        """Return the AST statements to replace the ast.Assert instance.
-
-        This rewrites the test of an assertion to provide
-        intermediate values and replace it with an if statement which
-        raises an assertion error with a detailed explanation in case
-        the expression is false.
-        """
-        if isinstance(assert_.test, ast.Tuple) and len(assert_.test.elts) >= 1:
-            import warnings
-
-            from _pytest.warning_types import PytestAssertRewriteWarning
-
-            # TODO: This assert should not be needed.
-            assert self.module_path is not None
-            warnings.warn_explicit(
-                PytestAssertRewriteWarning(
-                    "assertion is always true, perhaps remove parentheses?"
-                ),
-                category=None,
-                filename=self.module_path,
-                lineno=assert_.lineno,
-            )
-
-        self.statements: list[ast.stmt] = []
-        self.variables: list[str] = []
-        self.variable_counter = itertools.count()
-
-        if self.enable_assertion_pass_hook:
-            self.format_variables: list[str] = []
-
-        self.stack: list[dict[str, ast.expr]] = []
-        self.expl_stmts: list[ast.stmt] = []
-        self.push_format_context()
-        # Rewrite assert into a bunch of statements.
-        top_condition, explanation = self.visit(assert_.test)
-
-        negation = ast.UnaryOp(ast.Not(), top_condition)
-
-        if self.enable_assertion_pass_hook:  # Experimental pytest_assertion_pass hook
-            msg = self.pop_format_context(ast.Constant(explanation))
-
-            # Failed
-            if assert_.msg:
-                assertmsg = self.helper("_format_assertmsg", assert_.msg)
-                gluestr = "\n>assert "
-            else:
-                assertmsg = ast.Constant("")
-                gluestr = "assert "
-            err_explanation = ast.BinOp(ast.Constant(gluestr), ast.Add(), msg)
-            err_msg = ast.BinOp(assertmsg, ast.Add(), err_explanation)
-            err_name = ast.Name("AssertionError", ast.Load())
-            fmt = self.helper("_format_explanation", err_msg)
-            exc = ast.Call(err_name, [fmt], [])
-            raise_ = ast.Raise(exc, None)
-            statements_fail = []
-            statements_fail.extend(self.expl_stmts)
-            statements_fail.append(raise_)
-
-            # Passed
-            fmt_pass = self.helper("_format_explanation", msg)
-            orig = _get_assertion_exprs(self.source)[assert_.lineno]
-            hook_call_pass = ast.Expr(
-                self.helper(
-                    "_call_assertion_pass",
-                    ast.Constant(assert_.lineno),
-                    ast.Constant(orig),
-                    fmt_pass,
-                )
-            )
-            # If any hooks implement assert_pass hook
-            hook_impl_test = ast.If(
-                self.helper("_check_if_assertion_pass_impl"),
-                [*self.expl_stmts, hook_call_pass],
-                [],
-            )
-            statements_pass: list[ast.stmt] = [hook_impl_test]
-
-            # Test for assertion condition
-            main_test = ast.If(negation, statements_fail, statements_pass)
-            self.statements.append(main_test)
-            if self.format_variables:
-                variables: list[ast.expr] = [
-                    ast.Name(name, ast.Store()) for name in self.format_variables
-                ]
-                clear_format = ast.Assign(variables, ast.Constant(None))
-                self.statements.append(clear_format)
-
-        else:  # Original assertion rewriting
-            # Create failure message.
-            body = self.expl_stmts
-            self.statements.append(ast.If(negation, body, []))
-            if assert_.msg:
-                assertmsg = self.helper("_format_assertmsg", assert_.msg)
-                explanation = "\n>assert " + explanation
-            else:
-                assertmsg = ast.Constant("")
-                explanation = "assert " + explanation
-            template = ast.BinOp(assertmsg, ast.Add(), ast.Constant(explanation))
-            msg = self.pop_format_context(template)
-            fmt = self.helper("_format_explanation", msg)
-            err_name = ast.Name("AssertionError", ast.Load())
-            exc = ast.Call(err_name, [fmt], [])
-            raise_ = ast.Raise(exc, None)
-
-            body.append(raise_)
-
-        # Clear temporary variables by setting them to None.
-        if self.variables:
-            variables = [ast.Name(name, ast.Store()) for name in self.variables]
-            clear = ast.Assign(variables, ast.Constant(None))
-            self.statements.append(clear)
-        # Fix locations (line numbers/column offsets).
-        for stmt in self.statements:
-            for node in traverse_node(stmt):
-                if getattr(node, "lineno", None) is None:
-                    # apply the assertion location to all generated ast nodes without source location
-                    # and preserve the location of existing nodes or generated nodes with an correct location.
-                    ast.copy_location(node, assert_)
-        return self.statements
-
-    def visit_NamedExpr(self, name: ast.NamedExpr) -> tuple[ast.NamedExpr, str]:
-        # This method handles the 'walrus operator' repr of the target
-        # name if it's a local variable or _should_repr_global_name()
-        # thinks it's acceptable.
-        locs = ast.Call(self.builtin("locals"), [], [])
-        target_id = name.target.id
-        inlocs = ast.Compare(ast.Constant(target_id), [ast.In()], [locs])
-        dorepr = self.helper("_should_repr_global_name", name)
-        test = ast.BoolOp(ast.Or(), [inlocs, dorepr])
-        expr = ast.IfExp(test, self.display(name), ast.Constant(target_id))
-        return name, self.explanation_param(expr)
-
-    def visit_Name(self, name: ast.Name) -> tuple[ast.Name, str]:
-        # Display the repr of the name if it's a local variable or
-        # _should_repr_global_name() thinks it's acceptable.
-        locs = ast.Call(self.builtin("locals"), [], [])
-        inlocs = ast.Compare(ast.Constant(name.id), [ast.In()], [locs])
-        dorepr = self.helper("_should_repr_global_name", name)
-        test = ast.BoolOp(ast.Or(), [inlocs, dorepr])
-        expr = ast.IfExp(test, self.display(name), ast.Constant(name.id))
-        return name, self.explanation_param(expr)
-
-    def visit_BoolOp(self, boolop: ast.BoolOp) -> tuple[ast.Name, str]:
-        res_var = self.variable()
-        expl_list = self.assign(ast.List([], ast.Load()))
-        app = ast.Attribute(expl_list, "append", ast.Load())
-        is_or = int(isinstance(boolop.op, ast.Or))
-        body = save = self.statements
-        fail_save = self.expl_stmts
-        levels = len(boolop.values) - 1
-        self.push_format_context()
-        # Process each operand, short-circuiting if needed.
-        for i, v in enumerate(boolop.values):
-            if i:
-                fail_inner: list[ast.stmt] = []
-                # cond is set in a prior loop iteration below
-                self.expl_stmts.append(ast.If(cond, fail_inner, []))  # noqa: F821
-                self.expl_stmts = fail_inner
-                match v:
-                    # Check if the left operand is an ast.NamedExpr and the value has already been visited
-                    case ast.Compare(
-                        left=ast.NamedExpr(target=ast.Name(id=target_id))
-                    ) if target_id in [
-                        e.id for e in boolop.values[:i] if hasattr(e, "id")
-                    ]:
-                        pytest_temp = self.variable()
-                        self.variables_overwrite[self.scope][target_id] = v.left  # type:ignore[assignment]
-                        # mypy's false positive, we're checking that the 'target' attribute exists.
-                        v.left.target.id = pytest_temp  # type:ignore[attr-defined]
-            self.push_format_context()
-            res, expl = self.visit(v)
-            body.append(ast.Assign([ast.Name(res_var, ast.Store())], res))
-            expl_format = self.pop_format_context(ast.Constant(expl))
-            call = ast.Call(app, [expl_format], [])
-            self.expl_stmts.append(ast.Expr(call))
-            if i < levels:
-                cond: ast.expr = res
-                if is_or:
-                    cond = ast.UnaryOp(ast.Not(), cond)
-                inner: list[ast.stmt] = []
-                self.statements.append(ast.If(cond, inner, []))
-                self.statements = body = inner
-        self.statements = save
-        self.expl_stmts = fail_save
-        expl_template = self.helper("_format_boolop", expl_list, ast.Constant(is_or))
-        expl = self.pop_format_context(expl_template)
-        return ast.Name(res_var, ast.Load()), self.explanation_param(expl)
-
-    def visit_UnaryOp(self, unary: ast.UnaryOp) -> tuple[ast.Name, str]:
-        pattern = UNARY_MAP[unary.op.__class__]
-        operand_res, operand_expl = self.visit(unary.operand)
-        res = self.assign(ast.copy_location(ast.UnaryOp(unary.op, operand_res), unary))
-        return res, pattern % (operand_expl,)
-
-    def visit_BinOp(self, binop: ast.BinOp) -> tuple[ast.Name, str]:
-        symbol = BINOP_MAP[binop.op.__class__]
-        left_expr, left_expl = self.visit(binop.left)
-        right_expr, right_expl = self.visit(binop.right)
-        explanation = f"({left_expl} {symbol} {right_expl})"
-        res = self.assign(
-            ast.copy_location(ast.BinOp(left_expr, binop.op, right_expr), binop)
-        )
-        return res, explanation
-
-    def visit_Call(self, call: ast.Call) -> tuple[ast.Name, str]:
-        new_func, func_expl = self.visit(call.func)
-        arg_expls = []
-        new_args = []
-        new_kwargs = []
-        for arg in call.args:
-            if isinstance(arg, ast.Name) and arg.id in self.variables_overwrite.get(
-                self.scope, {}
-            ):
-                arg = self.variables_overwrite[self.scope][arg.id]  # type:ignore[assignment]
-            res, expl = self.visit(arg)
-            arg_expls.append(expl)
-            new_args.append(res)
-        for keyword in call.keywords:
-            match keyword.value:
-                case ast.Name(id=id) if id in self.variables_overwrite.get(
-                    self.scope, {}
-                ):
-                    keyword.value = self.variables_overwrite[self.scope][id]  # type:ignore[assignment]
-            res, expl = self.visit(keyword.value)
-            new_kwargs.append(ast.keyword(keyword.arg, res))
-            if keyword.arg:
-                arg_expls.append(keyword.arg + "=" + expl)
-            else:  # **args have `arg` keywords with an .arg of None
-                arg_expls.append("**" + expl)
-
-        expl = "{}({})".format(func_expl, ", ".join(arg_expls))
-        new_call = ast.copy_location(ast.Call(new_func, new_args, new_kwargs), call)
-        res = self.assign(new_call)
-        res_expl = self.explanation_param(self.display(res))
-        outer_expl = f"{res_expl}\n{{{res_expl} = {expl}\n}}"
-        return res, outer_expl
-
-    def visit_Starred(self, starred: ast.Starred) -> tuple[ast.Starred, str]:
-        # A Starred node can appear in a function call.
-        res, expl = self.visit(starred.value)
-        new_starred = ast.Starred(res, starred.ctx)
-        return new_starred, "*" + expl
-
-    def visit_Attribute(self, attr: ast.Attribute) -> tuple[ast.Name, str]:
-        if not isinstance(attr.ctx, ast.Load):
-            return self.generic_visit(attr)
-        value, value_expl = self.visit(attr.value)
-        res = self.assign(
-            ast.copy_location(ast.Attribute(value, attr.attr, ast.Load()), attr)
-        )
-        res_expl = self.explanation_param(self.display(res))
-        pat = "%s\n{%s = %s.%s\n}"
-        expl = pat % (res_expl, res_expl, value_expl, attr.attr)
-        return res, expl
-
-    def visit_Compare(self, comp: ast.Compare) -> tuple[ast.expr, str]:
-        self.push_format_context()
-        # We first check if we have overwritten a variable in the previous assert
-        match comp.left:
-            case ast.Name(id=name_id) if name_id in self.variables_overwrite.get(
-                self.scope, {}
-            ):
-                comp.left = self.variables_overwrite[self.scope][name_id]  # type: ignore[assignment]
-            case ast.NamedExpr(target=ast.Name(id=target_id)):
-                self.variables_overwrite[self.scope][target_id] = comp.left  # type: ignore[assignment]
-        left_res, left_expl = self.visit(comp.left)
-        if isinstance(comp.left, ast.Compare | ast.BoolOp):
-            left_expl = f"({left_expl})"
-        res_variables = [self.variable() for i in range(len(comp.ops))]
-        load_names: list[ast.expr] = [ast.Name(v, ast.Load()) for v in res_variables]
-        store_names = [ast.Name(v, ast.Store()) for v in res_variables]
-        it = zip(range(len(comp.ops)), comp.ops, comp.comparators, strict=True)
-        expls: list[ast.expr] = []
-        syms: list[ast.expr] = []
-        results = [left_res]
-        for i, op, next_operand in it:
-            match (next_operand, left_res):
-                case (
-                    ast.NamedExpr(target=ast.Name(id=target_id)),
-                    ast.Name(id=name_id),
-                ) if target_id == name_id:
-                    next_operand.target.id = self.variable()
-                    self.variables_overwrite[self.scope][name_id] = next_operand  # type: ignore[assignment]
-
-            next_res, next_expl = self.visit(next_operand)
-            if isinstance(next_operand, ast.Compare | ast.BoolOp):
-                next_expl = f"({next_expl})"
-            results.append(next_res)
-            sym = BINOP_MAP[op.__class__]
-            syms.append(ast.Constant(sym))
-            expl = f"{left_expl} {sym} {next_expl}"
-            expls.append(ast.Constant(expl))
-            res_expr = ast.copy_location(ast.Compare(left_res, [op], [next_res]), comp)
-            self.statements.append(ast.Assign([store_names[i]], res_expr))
-            left_res, left_expl = next_res, next_expl
-        # Use pytest.assertion.util._reprcompare if that's available.
-        expl_call = self.helper(
-            "_call_reprcompare",
-            ast.Tuple(syms, ast.Load()),
-            ast.Tuple(load_names, ast.Load()),
-            ast.Tuple(expls, ast.Load()),
-            ast.Tuple(results, ast.Load()),
-        )
-        if len(comp.ops) > 1:
-            res: ast.expr = ast.BoolOp(ast.And(), load_names)
-        else:
-            res = load_names[0]
-
-        return res, self.explanation_param(self.pop_format_context(expl_call))
-
-
-def try_makedirs(cache_dir: Path) -> bool:
-    """Attempt to create the given directory and sub-directories exist.
-
-    Returns True if successful or if it already exists.
-    """
-    try:
-        os.makedirs(cache_dir, exist_ok=True)
-    except (FileNotFoundError, NotADirectoryError, FileExistsError):
-        # One of the path components was not a directory:
-        # - we're in a zip file
-        # - it is a file
-        return False
-    except PermissionError:
-        return False
-    except OSError as e:
-        # as of now, EROFS doesn't have an equivalent OSError-subclass
-        #
-        # squashfuse_ll returns ENOSYS "OSError: [Errno 38] Function not
-        # implemented" for a read-only error
-        if e.errno in {errno.EROFS, errno.ENOSYS}:
-            return False
-        raise
-    return True
-
-
-def get_cache_dir(file_path: Path) -> Path:
-    """Return the cache directory to write .pyc files for the given .py file path."""
-    if sys.pycache_prefix:
-        # given:
-        #   prefix = '/tmp/pycs'
-        #   path = '/home/user/proj/test_app.py'
-        # we want:
-        #   '/tmp/pycs/home/user/proj'
-        return Path(sys.pycache_prefix) / Path(*file_path.parts[1:-1])
-    else:
-        # classic pycache directory
-        return file_path.parent / "__pycache__"

venv/Lib/site-packages/_pytest/assertion/truncate.py

@@ -1,128 +0,0 @@
-"""Utilities for truncating assertion output.
-
-Current default behaviour is to truncate assertion explanations at
-terminal lines, unless running with an assertions verbosity level of at least 2 or running on CI.
-"""
-
-from __future__ import annotations
-
-from _pytest.compat import running_on_ci
-from _pytest.config import Config
-from _pytest.nodes import Item
-
-
-DEFAULT_MAX_LINES = 8
-DEFAULT_MAX_CHARS = DEFAULT_MAX_LINES * 80
-USAGE_MSG = "use '-vv' to show"
-
-
-def truncate_if_required(explanation: list[str], item: Item) -> list[str]:
-    """Truncate this assertion explanation if the given test item is eligible."""
-    should_truncate, max_lines, max_chars = _get_truncation_parameters(item)
-    if should_truncate:
-        return _truncate_explanation(
-            explanation,
-            max_lines=max_lines,
-            max_chars=max_chars,
-        )
-    return explanation
-
-
-def _get_truncation_parameters(item: Item) -> tuple[bool, int, int]:
-    """Return the truncation parameters related to the given item, as (should truncate, max lines, max chars)."""
-    # We do not need to truncate if one of conditions is met:
-    # 1. Verbosity level is 2 or more;
-    # 2. Test is being run in CI environment;
-    # 3. Both truncation_limit_lines and truncation_limit_chars
-    #    .ini parameters are set to 0 explicitly.
-    max_lines = item.config.getini("truncation_limit_lines")
-    max_lines = int(max_lines if max_lines is not None else DEFAULT_MAX_LINES)
-
-    max_chars = item.config.getini("truncation_limit_chars")
-    max_chars = int(max_chars if max_chars is not None else DEFAULT_MAX_CHARS)
-
-    verbose = item.config.get_verbosity(Config.VERBOSITY_ASSERTIONS)
-
-    should_truncate = verbose < 2 and not running_on_ci()
-    should_truncate = should_truncate and (max_lines > 0 or max_chars > 0)
-
-    return should_truncate, max_lines, max_chars
-
-
-def _truncate_explanation(
-    input_lines: list[str],
-    max_lines: int,
-    max_chars: int,
-) -> list[str]:
-    """Truncate given list of strings that makes up the assertion explanation.
-
-    Truncates to either max_lines, or max_chars - whichever the input reaches
-    first, taking the truncation explanation into account. The remaining lines
-    will be replaced by a usage message.
-
-    If max_chars=0, no truncation by character count is performed.
-    If max_lines=0, no truncation by line count is performed.
-
-    When this function is launched we know max_lines > 0 or max_chars > 0
-    because _get_truncation_parameters was called first.
-    """
-    # The length of the truncation explanation depends on the number of lines
-    # removed but is at least 68 characters:
-    # The real value is
-    # 64 (for the base message:
-    # '...\n...Full output truncated (1 line hidden), use '-vv' to show")'
-    # )
-    # + 1 (for plural)
-    # + int(math.log10(len(input_lines) - max_lines)) (number of hidden line, at least 1)
-    # + 3 for the '...' added to the truncated line
-    # But if there's more than 100 lines it's very likely that we're going to
-    # truncate, so we don't need the exact value using log10.
-    tolerable_max_chars = (
-        max_chars + 70  # 64 + 1 (for plural) + 2 (for '99') + 3 for '...'
-    )
-    # The truncation explanation add two lines to the output
-    if max_lines == 0 or len(input_lines) <= max_lines + 2:
-        if max_chars == 0 or sum(len(s) for s in input_lines) <= tolerable_max_chars:
-            return input_lines
-        truncated_explanation = input_lines
-    else:
-        # Truncate first to max_lines, and then truncate to max_chars if necessary
-        truncated_explanation = input_lines[:max_lines]
-    # We reevaluate the need to truncate chars following removal of some lines
-    need_to_truncate_char = (
-        max_chars > 0
-        and sum(len(e) for e in truncated_explanation) > tolerable_max_chars
-    )
-    if need_to_truncate_char:
-        truncated_explanation = _truncate_by_char_count(
-            truncated_explanation, max_chars
-        )
-    # Something was truncated, adding '...' at the end to show that
-    truncated_explanation[-1] += "..."
-    truncated_line_count = (
-        len(input_lines) - len(truncated_explanation) + int(need_to_truncate_char)
-    )
-    return [
-        *truncated_explanation,
-        "",
-        f"...Full output truncated ({truncated_line_count} line"
-        f"{'' if truncated_line_count == 1 else 's'} hidden), {USAGE_MSG}",
-    ]
-
-
-def _truncate_by_char_count(input_lines: list[str], max_chars: int) -> list[str]:
-    # Find point at which input length exceeds total allowed length
-    iterated_char_count = 0
-    for iterated_index, input_line in enumerate(input_lines):
-        if iterated_char_count + len(input_line) > max_chars:
-            break
-        iterated_char_count += len(input_line)
-
-    # Create truncated explanation with modified final line
-    truncated_result = input_lines[:iterated_index]
-    final_line = input_lines[iterated_index]
-    if final_line:
-        final_line_truncate_point = max_chars - iterated_char_count
-        final_line = final_line[:final_line_truncate_point]
-    truncated_result.append(final_line)
-    return truncated_result

venv/Lib/site-packages/_pytest/assertion/util.py

@@ -1,215 +0,0 @@
-# mypy: allow-untyped-defs
-"""Utilities for assertion debugging."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from collections.abc import Iterator
-from collections.abc import Sequence
-from typing import Literal
-from unicodedata import normalize
-
-from _pytest import outcomes
-import _pytest._code
-from _pytest._io.saferepr import saferepr
-from _pytest._io.saferepr import saferepr_unlimited
-from _pytest.assertion._compare_any import _compare_eq_any
-from _pytest.assertion._compare_set import SET_COMPARISON_FUNCTIONS
-from _pytest.assertion._guards import isset
-from _pytest.assertion._guards import istext
-from _pytest.assertion._typing import _AssertionTextDiffStyle
-from _pytest.assertion._typing import _HighlightFunc
-from _pytest.assertion.compare_text import _notin_text
-from _pytest.assertion.highlight import dummy_highlighter as dummy_highlighter
-from _pytest.config import Config
-from _pytest.config import UsageError
-
-
-# The _reprcompare attribute on the util module is used by the new assertion
-# interpretation code and assertion rewriter to detect this plugin was
-# loaded and in turn call the hooks defined here as part of the
-# DebugInterpreter.
-_reprcompare: Callable[[str, object, object], str | None] | None = None
-
-# Works similarly as _reprcompare attribute. Is populated with the hook call
-# when pytest_runtest_setup is called.
-_assertion_pass: Callable[[int, str, str], None] | None = None
-
-# Config object which is assigned during pytest_runtest_protocol.
-_config: Config | None = None
-
-ASSERTION_TEXT_DIFF_STYLE_INI = "assertion_text_diff_style"
-ASSERTION_TEXT_DIFF_STYLE_NDIFF: Literal["ndiff"] = "ndiff"
-ASSERTION_TEXT_DIFF_STYLE_BLOCK: Literal["block"] = "block"
-ASSERTION_TEXT_DIFF_STYLE_CHOICES = (
-    ASSERTION_TEXT_DIFF_STYLE_NDIFF,
-    ASSERTION_TEXT_DIFF_STYLE_BLOCK,
-)
-
-
-def get_assertion_text_diff_style(config: Config) -> _AssertionTextDiffStyle:
-    style = str(config.getini(ASSERTION_TEXT_DIFF_STYLE_INI))
-    match style:
-        case "ndiff" | "block":
-            return style
-        case _:
-            choices = ", ".join(
-                repr(choice) for choice in ASSERTION_TEXT_DIFF_STYLE_CHOICES
-            )
-            raise UsageError(
-                f"{ASSERTION_TEXT_DIFF_STYLE_INI} must be one of {choices}; got {style!r}"
-            )
-
-
-def validate_assertion_text_diff_style(config: Config) -> None:
-    get_assertion_text_diff_style(config)
-
-
-def format_explanation(explanation: str) -> str:
-    r"""Format an explanation.
-
-    Normally all embedded newlines are escaped, however there are
-    three exceptions: \n{, \n} and \n~.  The first two are intended
-    cover nested explanations, see function and attribute explanations
-    for examples (.visit_Call(), visit_Attribute()).  The last one is
-    for when one explanation needs to span multiple lines, e.g. when
-    displaying diffs.
-    """
-    lines = _split_explanation(explanation)
-    result = _format_lines(lines)
-    return "\n".join(result)
-
-
-def _split_explanation(explanation: str) -> list[str]:
-    r"""Return a list of individual lines in the explanation.
-
-    This will return a list of lines split on '\n{', '\n}' and '\n~'.
-    Any other newlines will be escaped and appear in the line as the
-    literal '\n' characters.
-    """
-    raw_lines = (explanation or "").split("\n")
-    lines = [raw_lines[0]]
-    for values in raw_lines[1:]:
-        if values and values[0] in ["{", "}", "~", ">"]:
-            lines.append(values)
-        else:
-            lines[-1] += "\\n" + values
-    return lines
-
-
-def _format_lines(lines: Sequence[str]) -> list[str]:
-    """Format the individual lines.
-
-    This will replace the '{', '}' and '~' characters of our mini formatting
-    language with the proper 'where ...', 'and ...' and ' + ...' text, taking
-    care of indentation along the way.
-
-    Return a list of formatted lines.
-    """
-    result = list(lines[:1])
-    stack = [0]
-    stackcnt = [0]
-    for line in lines[1:]:
-        if line.startswith("{"):
-            if stackcnt[-1]:
-                s = "and   "
-            else:
-                s = "where "
-            stack.append(len(result))
-            stackcnt[-1] += 1
-            stackcnt.append(0)
-            result.append(" +" + "  " * (len(stack) - 1) + s + line[1:])
-        elif line.startswith("}"):
-            stack.pop()
-            stackcnt.pop()
-            result[stack[-1]] += line[1:]
-        else:
-            assert line[0] in ["~", ">"]
-            stack[-1] += 1
-            indent = len(stack) if line.startswith("~") else len(stack) - 1
-            result.append("  " * indent + line[1:])
-    assert len(stack) == 1
-    return result
-
-
-def assertrepr_compare(
-    op: str,
-    left: object,
-    right: object,
-    *,
-    verbose: int,
-    highlighter: _HighlightFunc,
-    assertion_text_diff_style: _AssertionTextDiffStyle,
-) -> Iterator[str]:
-    """Yield specialised explanations for some operators/operands.
-
-    The first line yielded is always the summary (``left op right``);
-    subsequent lines are the detailed explanation. Yields nothing when no
-    specialised explanation applies, which lets consumers map an empty
-    iterator to "no explanation" without materialising anything.
-
-    The iterator is lazy on purpose: a streaming consumer can stop pulling
-    lines as soon as it has enough to show, so an enormous diff doesn't
-    have to be built in full just to be thrown away.
-    """
-    # Strings which normalize equal are often hard to distinguish when printed; use ascii() to make this easier.
-    # See issue #3246.
-    use_ascii = (
-        isinstance(left, str)
-        and isinstance(right, str)
-        and normalize("NFD", left) == normalize("NFD", right)
-    )
-
-    if verbose > 1:
-        left_repr = saferepr_unlimited(left, use_ascii=use_ascii)
-        right_repr = saferepr_unlimited(right, use_ascii=use_ascii)
-    else:
-        # XXX: "15 chars indentation" is wrong
-        #      ("E       AssertionError: assert "); should use term width.
-        maxsize = (
-            80 - 15 - len(op) - 2
-        ) // 2  # 15 chars indentation, 1 space around op
-
-        left_repr = saferepr(left, maxsize=maxsize, use_ascii=use_ascii)
-        right_repr = saferepr(right, maxsize=maxsize, use_ascii=use_ascii)
-
-    summary = f"{left_repr} {op} {right_repr}"
-
-    try:
-        if op == "==":
-            source = _compare_eq_any(
-                left,
-                right,
-                highlighter,
-                verbose,
-                assertion_text_diff_style,
-            )
-        elif op == "not in" and istext(left) and istext(right):
-            source = _notin_text(left, right, verbose)
-        elif op in {"!=", ">=", "<=", ">", "<"} and isset(left) and isset(right):
-            source = SET_COMPARISON_FUNCTIONS[op](left, right, highlighter, verbose)
-        else:
-            source = iter(())
-
-        # Only yield the summary if there is a detailed explanation.
-        # Make sure there's a separating empty line after the summary.
-        summary_yielded = False
-        for line in source:
-            if not summary_yielded:
-                yield summary
-                if line != "":
-                    yield ""
-                summary_yielded = True
-            yield line
-    except outcomes.Exit:
-        raise
-    except Exception:
-        repr_crash = _pytest._code.ExceptionInfo.from_current()._getreprcrash()
-        if not summary_yielded:
-            yield summary
-            yield ""
-            summary_yielded = True
-        yield (
-            f"(pytest_assertion plugin: representation of details failed: {repr_crash}."
-        )
-        yield " Probably an object has a faulty __repr__.)"

venv/Lib/site-packages/_pytest/cacheprovider.py

@@ -1,640 +0,0 @@
-# mypy: allow-untyped-defs
-"""Implementation of the cache provider."""
-
-# This plugin was not named "cache" to avoid conflicts with the external
-# pytest-cache version.
-from __future__ import annotations
-
-from collections.abc import Generator
-from collections.abc import Iterable
-import dataclasses
-import errno
-import json
-import os
-from pathlib import Path
-import shutil
-import tempfile
-from typing import final
-
-from .pathlib import resolve_from_str
-from .pathlib import rm_rf
-from .reports import CollectReport
-from _pytest import nodes
-from _pytest._io import TerminalWriter
-from _pytest.config import Config
-from _pytest.config import ExitCode
-from _pytest.config import hookimpl
-from _pytest.config.argparsing import Parser
-from _pytest.deprecated import check_ispytest
-from _pytest.fixtures import fixture
-from _pytest.fixtures import FixtureRequest
-from _pytest.main import Session
-from _pytest.nodes import Directory
-from _pytest.nodes import File
-from _pytest.reports import TestReport
-
-
-CACHEDIR_FILES: dict[str, bytes] = {
-    "README.md": b"""\
-# pytest cache directory #
-
-This directory contains data from the pytest's cache plugin,
-which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
-
-**Do not** commit this to version control.
-
-See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.
-""",
-    ".gitignore": b"# Created by pytest automatically.\n*\n",
-    "CACHEDIR.TAG": b"""\
-Signature: 8a477f597d28d172789f06886806bc55
-# This file is a cache directory tag created by pytest.
-# For information about cache directory tags, see:
-#	https://bford.info/cachedir/spec.html
-""",
-}
-
-
-def _make_cachedir(target: Path) -> None:
-    """Create the pytest cache directory atomically with supporting files.
-
-    Creates a temporary directory with README.md, .gitignore, and CACHEDIR.TAG,
-    then atomically renames it to the target location. If another process wins
-    the race, the temporary directory is cleaned up.
-    """
-    target.parent.mkdir(parents=True, exist_ok=True)
-    path = Path(tempfile.mkdtemp(prefix="pytest-cache-files-", dir=target.parent))
-    try:
-        # Reset permissions to the default, see #12308.
-        # Note: there's no way to get the current umask atomically, eek.
-        umask = os.umask(0o022)
-        os.umask(umask)
-        path.chmod(0o777 - umask)
-
-        for name, content in CACHEDIR_FILES.items():
-            path.joinpath(name).write_bytes(content)
-
-        path.rename(target)
-    except OSError as e:
-        # If 2 concurrent pytests both race to the rename, the loser
-        # gets "Directory not empty" from the rename. In this case,
-        # everything is handled so just continue after cleanup.
-        # On Windows, the error is a FileExistsError which translates to EEXIST.
-        if e.errno not in (errno.ENOTEMPTY, errno.EEXIST):
-            raise
-    finally:
-        shutil.rmtree(path, ignore_errors=True)
-
-
-@final
-@dataclasses.dataclass
-class Cache:
-    """Instance of the `cache` fixture."""
-
-    _cachedir: Path = dataclasses.field(repr=False)
-    _config: Config = dataclasses.field(repr=False)
-
-    # Sub-directory under cache-dir for directories created by `mkdir()`.
-    _CACHE_PREFIX_DIRS = "d"
-
-    # Sub-directory under cache-dir for values created by `set()`.
-    _CACHE_PREFIX_VALUES = "v"
-
-    def __init__(
-        self, cachedir: Path, config: Config, *, _ispytest: bool = False
-    ) -> None:
-        check_ispytest(_ispytest)
-        self._cachedir = cachedir
-        self._config = config
-
-    @classmethod
-    def for_config(cls, config: Config, *, _ispytest: bool = False) -> Cache:
-        """Create the Cache instance for a Config.
-
-        :meta private:
-        """
-        check_ispytest(_ispytest)
-        cachedir = cls.cache_dir_from_config(config, _ispytest=True)
-        if config.getoption("cacheclear") and cachedir.is_dir():
-            cls.clear_cache(cachedir, _ispytest=True)
-        return cls(cachedir, config, _ispytest=True)
-
-    @classmethod
-    def clear_cache(cls, cachedir: Path, _ispytest: bool = False) -> None:
-        """Clear the sub-directories used to hold cached directories and values.
-
-        :meta private:
-        """
-        check_ispytest(_ispytest)
-        for prefix in (cls._CACHE_PREFIX_DIRS, cls._CACHE_PREFIX_VALUES):
-            d = cachedir / prefix
-            if d.is_dir():
-                rm_rf(d)
-
-    @staticmethod
-    def cache_dir_from_config(config: Config, *, _ispytest: bool = False) -> Path:
-        """Get the path to the cache directory for a Config.
-
-        :meta private:
-        """
-        check_ispytest(_ispytest)
-        return resolve_from_str(config.getini("cache_dir"), config.rootpath)
-
-    def warn(self, fmt: str, *, _ispytest: bool = False, **args: object) -> None:
-        """Issue a cache warning.
-
-        :meta private:
-        """
-        check_ispytest(_ispytest)
-        import warnings
-
-        from _pytest.warning_types import PytestCacheWarning
-
-        warnings.warn(
-            PytestCacheWarning(fmt.format(**args) if args else fmt),
-            self._config.hook,
-            stacklevel=3,
-        )
-
-    def _mkdir(self, path: Path) -> None:
-        self._ensure_cache_dir_and_supporting_files()
-        path.mkdir(exist_ok=True, parents=True)
-
-    def mkdir(self, name: str) -> Path:
-        """Return a directory path object with the given name.
-
-        If the directory does not yet exist, it will be created. You can use
-        it to manage files to e.g. store/retrieve database dumps across test
-        sessions.
-
-        .. versionadded:: 7.0
-
-        :param name:
-            Must be a string not containing a ``/`` separator.
-            Make sure the name contains your plugin or application
-            identifiers to prevent clashes with other cache users.
-        """
-        path = Path(name)
-        if len(path.parts) > 1:
-            raise ValueError("name is not allowed to contain path separators")
-        res = self._cachedir.joinpath(self._CACHE_PREFIX_DIRS, path)
-        self._mkdir(res)
-        return res
-
-    def _getvaluepath(self, key: str) -> Path:
-        return self._cachedir.joinpath(self._CACHE_PREFIX_VALUES, Path(key))
-
-    def get(self, key: str, default):
-        """Return the cached value for the given key.
-
-        If no value was yet cached or the value cannot be read, the specified
-        default is returned.
-
-        :param key:
-            Must be a ``/`` separated value. Usually the first
-            name is the name of your plugin or your application.
-        :param default:
-            The value to return in case of a cache-miss or invalid cache value.
-        """
-        path = self._getvaluepath(key)
-        try:
-            with path.open("r", encoding="UTF-8") as f:
-                return json.load(f)
-        except (ValueError, OSError):
-            return default
-
-    def set(self, key: str, value: object) -> None:
-        """Save value for the given key.
-
-        :param key:
-            Must be a ``/`` separated value. Usually the first
-            name is the name of your plugin or your application.
-        :param value:
-            Must be of any combination of basic python types,
-            including nested types like lists of dictionaries.
-        """
-        path = self._getvaluepath(key)
-        try:
-            self._mkdir(path.parent)
-        except OSError as exc:
-            self.warn(
-                f"could not create cache path {path}: {exc}",
-                _ispytest=True,
-            )
-            return
-        data = json.dumps(value, ensure_ascii=False, indent=2)
-        try:
-            f = path.open("w", encoding="UTF-8")
-        except OSError as exc:
-            self.warn(
-                f"cache could not write path {path}: {exc}",
-                _ispytest=True,
-            )
-        else:
-            with f:
-                f.write(data)
-
-    def _ensure_cache_dir_and_supporting_files(self) -> None:
-        """Create the cache dir and its supporting files."""
-        if not self._cachedir.is_dir():
-            _make_cachedir(self._cachedir)
-
-
-class LFPluginCollWrapper:
-    def __init__(self, lfplugin: LFPlugin) -> None:
-        self.lfplugin = lfplugin
-        self._collected_at_least_one_failure = False
-
-    @hookimpl(wrapper=True)
-    def pytest_make_collect_report(
-        self, collector: nodes.Collector
-    ) -> Generator[None, CollectReport, CollectReport]:
-        res = yield
-        if isinstance(collector, Session | Directory):
-            # Sort any lf-paths to the beginning.
-            lf_paths = self.lfplugin._last_failed_paths
-
-            # Use stable sort to prioritize last failed.
-            def sort_key(node: nodes.Item | nodes.Collector) -> bool:
-                return node.path in lf_paths
-
-            res.result = sorted(
-                res.result,
-                key=sort_key,
-                reverse=True,
-            )
-
-        elif isinstance(collector, File):
-            if collector.path in self.lfplugin._last_failed_paths:
-                result = res.result
-                lastfailed = self.lfplugin.lastfailed
-
-                # Only filter with known failures.
-                if not self._collected_at_least_one_failure:
-                    if not any(x.nodeid in lastfailed for x in result):
-                        return res
-                    self.lfplugin.config.pluginmanager.register(
-                        LFPluginCollSkipfiles(self.lfplugin), "lfplugin-collskip"
-                    )
-                    self._collected_at_least_one_failure = True
-
-                session = collector.session
-                result[:] = [
-                    x
-                    for x in result
-                    if x.nodeid in lastfailed
-                    # Include any passed arguments (not trivial to filter).
-                    or session.isinitpath(x.path)
-                    # Keep all sub-collectors.
-                    or isinstance(x, nodes.Collector)
-                ]
-
-        return res
-
-
-class LFPluginCollSkipfiles:
-    def __init__(self, lfplugin: LFPlugin) -> None:
-        self.lfplugin = lfplugin
-
-    @hookimpl
-    def pytest_make_collect_report(
-        self, collector: nodes.Collector
-    ) -> CollectReport | None:
-        if isinstance(collector, File):
-            if collector.path not in self.lfplugin._last_failed_paths:
-                self.lfplugin._skipped_files += 1
-
-                return CollectReport(
-                    collector.nodeid, "passed", longrepr=None, result=[]
-                )
-        return None
-
-
-class LFPlugin:
-    """Plugin which implements the --lf (run last-failing) option."""
-
-    def __init__(self, config: Config) -> None:
-        self.config = config
-        active_keys = "lf", "failedfirst"
-        self.active = any(config.getoption(key) for key in active_keys)
-        assert config.cache
-        self.lastfailed: dict[str, bool] = config.cache.get("cache/lastfailed", {})
-        self._previously_failed_count: int | None = None
-        self._report_status: str | None = None
-        self._skipped_files = 0  # count skipped files during collection due to --lf
-
-        if config.getoption("lf"):
-            self._last_failed_paths = self.get_last_failed_paths()
-            config.pluginmanager.register(
-                LFPluginCollWrapper(self), "lfplugin-collwrapper"
-            )
-
-    def get_last_failed_paths(self) -> set[Path]:
-        """Return a set with all Paths of the previously failed nodeids and
-        their parents."""
-        rootpath = self.config.rootpath
-        result = set()
-        for nodeid in self.lastfailed:
-            path = rootpath / nodeid.split("::")[0]
-            result.add(path)
-            result.update(path.parents)
-        return {x for x in result if x.exists()}
-
-    def pytest_report_collectionfinish(self) -> str | None:
-        if self.active and self.config.get_verbosity() >= 0:
-            return f"run-last-failure: {self._report_status}"
-        return None
-
-    def pytest_runtest_logreport(self, report: TestReport) -> None:
-        if (report.when == "call" and report.passed) or report.skipped:
-            self.lastfailed.pop(report.nodeid, None)
-        elif report.failed:
-            self.lastfailed[report.nodeid] = True
-
-    def pytest_collectreport(self, report: CollectReport) -> None:
-        passed = report.outcome in ("passed", "skipped")
-        if passed:
-            if report.nodeid in self.lastfailed:
-                self.lastfailed.pop(report.nodeid)
-                self.lastfailed.update((item.nodeid, True) for item in report.result)
-        else:
-            self.lastfailed[report.nodeid] = True
-
-    @hookimpl(wrapper=True, tryfirst=True)
-    def pytest_collection_modifyitems(
-        self, config: Config, items: list[nodes.Item]
-    ) -> Generator[None]:
-        res = yield
-
-        if not self.active:
-            return res
-
-        if self.lastfailed:
-            previously_failed = []
-            previously_passed = []
-            for item in items:
-                if item.nodeid in self.lastfailed:
-                    previously_failed.append(item)
-                else:
-                    previously_passed.append(item)
-            self._previously_failed_count = len(previously_failed)
-
-            if not previously_failed:
-                # Running a subset of all tests with recorded failures
-                # only outside of it.
-                self._report_status = (
-                    f"{len(self.lastfailed)} known failures not in selected tests"
-                )
-            else:
-                if self.config.getoption("lf"):
-                    items[:] = previously_failed
-                    config.hook.pytest_deselected(items=previously_passed)
-                else:  # --failedfirst
-                    items[:] = previously_failed + previously_passed
-
-                noun = "failure" if self._previously_failed_count == 1 else "failures"
-                suffix = " first" if self.config.getoption("failedfirst") else ""
-                self._report_status = (
-                    f"rerun previous {self._previously_failed_count} {noun}{suffix}"
-                )
-
-            if self._skipped_files > 0:
-                files_noun = "file" if self._skipped_files == 1 else "files"
-                self._report_status += f" (skipped {self._skipped_files} {files_noun})"
-        else:
-            self._report_status = "no previously failed tests, "
-            if self.config.getoption("last_failed_no_failures") == "none":
-                self._report_status += "deselecting all items."
-                config.hook.pytest_deselected(items=items[:])
-                items[:] = []
-            else:
-                self._report_status += "not deselecting items."
-
-        return res
-
-    def pytest_sessionfinish(self, session: Session) -> None:
-        config = self.config
-        if config.getoption("cacheshow") or hasattr(config, "workerinput"):
-            return
-
-        assert config.cache is not None
-        saved_lastfailed = config.cache.get("cache/lastfailed", {})
-        if saved_lastfailed != self.lastfailed:
-            config.cache.set("cache/lastfailed", self.lastfailed)
-
-
-class NFPlugin:
-    """Plugin which implements the --nf (run new-first) option."""
-
-    def __init__(self, config: Config) -> None:
-        self.config = config
-        self.active = config.option.newfirst
-        assert config.cache is not None
-        self.cached_nodeids = set(config.cache.get("cache/nodeids", []))
-
-    @hookimpl(wrapper=True, tryfirst=True)
-    def pytest_collection_modifyitems(self, items: list[nodes.Item]) -> Generator[None]:
-        res = yield
-
-        if self.active:
-            new_items: dict[str, nodes.Item] = {}
-            other_items: dict[str, nodes.Item] = {}
-            for item in items:
-                if item.nodeid not in self.cached_nodeids:
-                    new_items[item.nodeid] = item
-                else:
-                    other_items[item.nodeid] = item
-
-            items[:] = self._get_increasing_order(
-                new_items.values()
-            ) + self._get_increasing_order(other_items.values())
-            self.cached_nodeids.update(new_items)
-        else:
-            self.cached_nodeids.update(item.nodeid for item in items)
-
-        return res
-
-    def _get_increasing_order(self, items: Iterable[nodes.Item]) -> list[nodes.Item]:
-        return sorted(items, key=lambda item: item.path.stat().st_mtime, reverse=True)
-
-    def pytest_sessionfinish(self) -> None:
-        config = self.config
-        if config.getoption("cacheshow") or hasattr(config, "workerinput"):
-            return
-
-        if config.getoption("collectonly"):
-            return
-
-        assert config.cache is not None
-        config.cache.set("cache/nodeids", sorted(self.cached_nodeids))
-
-
-def pytest_addoption(parser: Parser) -> None:
-    """Add command-line options for cache functionality.
-
-    :param parser: Parser object to add command-line options to.
-    """
-    group = parser.getgroup("general")
-    group.addoption(
-        "--lf",
-        "--last-failed",
-        action="store_true",
-        dest="lf",
-        help="Rerun only the tests that failed at the last run (or all if none failed)",
-    )
-    group.addoption(
-        "--ff",
-        "--failed-first",
-        action="store_true",
-        dest="failedfirst",
-        help="Run all tests, but run the last failures first. "
-        "This may re-order tests and thus lead to "
-        "repeated fixture setup/teardown.",
-    )
-    group.addoption(
-        "--nf",
-        "--new-first",
-        action="store_true",
-        dest="newfirst",
-        help="Run tests from new files first, then the rest of the tests "
-        "sorted by file mtime",
-    )
-    group.addoption(
-        "--cache-show",
-        action="append",
-        nargs="?",
-        dest="cacheshow",
-        help=(
-            "Show cache contents, don't perform collection or tests. "
-            "Optional argument: glob (default: '*')."
-        ),
-    )
-    group.addoption(
-        "--cache-clear",
-        action="store_true",
-        dest="cacheclear",
-        help="Remove all cache contents at start of test run",
-    )
-    cache_dir_default = ".pytest_cache"
-    if "TOX_ENV_DIR" in os.environ:
-        cache_dir_default = os.path.join(os.environ["TOX_ENV_DIR"], cache_dir_default)
-    parser.addini("cache_dir", default=cache_dir_default, help="Cache directory path")
-    group.addoption(
-        "--lfnf",
-        "--last-failed-no-failures",
-        action="store",
-        dest="last_failed_no_failures",
-        choices=("all", "none"),
-        default="all",
-        help="With ``--lf``, determines whether to execute tests when there "
-        "are no previously (known) failures or when no "
-        "cached ``lastfailed`` data was found. "
-        "``all`` (the default) runs the full test suite again. "
-        "``none`` just emits a message about no known failures and exits successfully.",
-    )
-
-
-def pytest_cmdline_main(config: Config) -> int | ExitCode | None:
-    if config.option.cacheshow and not config.option.help:
-        from _pytest.main import wrap_session
-
-        return wrap_session(config, cacheshow)
-    return None
-
-
-@hookimpl(tryfirst=True)
-def pytest_configure(config: Config) -> None:
-    """Configure cache system and register related plugins.
-
-    Creates the Cache instance and registers the last-failed (LFPlugin)
-    and new-first (NFPlugin) plugins with the plugin manager.
-
-    :param config: pytest configuration object.
-    """
-    config.cache = Cache.for_config(config, _ispytest=True)
-    config.pluginmanager.register(LFPlugin(config), "lfplugin")
-    config.pluginmanager.register(NFPlugin(config), "nfplugin")
-
-
-@fixture
-def cache(request: FixtureRequest) -> Cache:
-    """Return a cache object that can persist state between testing sessions.
-
-    cache.get(key, default)
-    cache.set(key, value)
-
-    Keys must be ``/`` separated strings, where the first part is usually the
-    name of your plugin or application to avoid clashes with other cache users.
-
-    Values can be any object handled by the json stdlib module.
-    """
-    assert request.config.cache is not None
-    return request.config.cache
-
-
-def pytest_report_header(config: Config) -> str | None:
-    """Display cachedir with --cache-show and if non-default."""
-    if config.option.verbose > 0 or config.getini("cache_dir") != ".pytest_cache":
-        assert config.cache is not None
-        cachedir = config.cache._cachedir
-        # TODO: evaluate generating upward relative paths
-        # starting with .., ../.. if sensible
-
-        try:
-            displaypath = cachedir.relative_to(config.rootpath)
-        except ValueError:
-            displaypath = cachedir
-        return f"cachedir: {displaypath}"
-    return None
-
-
-def cacheshow(config: Config, session: Session) -> int:
-    """Display cache contents when --cache-show is used.
-
-    Shows cached values and directories matching the specified glob pattern
-    (default: '*'). Displays cache location, cached test results, and
-    any cached directories created by plugins.
-
-    :param config: pytest configuration object.
-    :param session: pytest session object.
-    :returns: Exit code (0 for success).
-    """
-    from pprint import pformat
-
-    assert config.cache is not None
-
-    tw = TerminalWriter()
-    tw.line("cachedir: " + str(config.cache._cachedir))
-    if not config.cache._cachedir.is_dir():
-        tw.line("cache is empty")
-        return 0
-
-    glob = config.option.cacheshow[0]
-    if glob is None:
-        glob = "*"
-
-    dummy = object()
-    basedir = config.cache._cachedir
-    vdir = basedir / Cache._CACHE_PREFIX_VALUES
-    tw.sep("-", f"cache values for {glob!r}")
-    for valpath in sorted(x for x in vdir.rglob(glob) if x.is_file()):
-        key = str(valpath.relative_to(vdir))
-        val = config.cache.get(key, dummy)
-        if val is dummy:
-            tw.line(f"{key} contains unreadable content, will be ignored")
-        else:
-            tw.line(f"{key} contains:")
-            for line in pformat(val).splitlines():
-                tw.line("  " + line)
-
-    ddir = basedir / Cache._CACHE_PREFIX_DIRS
-    if ddir.is_dir():
-        contents = sorted(ddir.rglob(glob))
-        tw.sep("-", f"cache directories for {glob!r}")
-        for p in contents:
-            # if p.is_dir():
-            #    print("%s/" % p.relative_to(basedir))
-            if p.is_file():
-                key = str(p.relative_to(basedir))
-                tw.line(f"{key} is a file of length {p.stat().st_size}")
-    return 0

venv/Lib/site-packages/_pytest/capture.py

@@ -1,1151 +0,0 @@
-# mypy: allow-untyped-defs
-"""Per-test stdout/stderr capturing mechanism."""
-
-from __future__ import annotations
-
-import abc
-import collections
-from collections.abc import Generator
-from collections.abc import Iterable
-from collections.abc import Iterator
-import contextlib
-import io
-from io import UnsupportedOperation
-import os
-import sys
-from tempfile import TemporaryFile
-from types import TracebackType
-from typing import Any
-from typing import AnyStr
-from typing import BinaryIO
-from typing import cast
-from typing import Final
-from typing import final
-from typing import Generic
-from typing import Literal
-from typing import NamedTuple
-from typing import TextIO
-from typing import TYPE_CHECKING
-
-
-if TYPE_CHECKING:
-    from typing_extensions import Self
-
-from _pytest.config import Config
-from _pytest.config import hookimpl
-from _pytest.config.argparsing import Parser
-from _pytest.deprecated import check_ispytest
-from _pytest.fixtures import fixture
-from _pytest.fixtures import SubRequest
-from _pytest.nodes import Collector
-from _pytest.nodes import File
-from _pytest.nodes import Item
-from _pytest.reports import CollectReport
-
-
-_CaptureMethod = Literal["fd", "sys", "no", "tee-sys"]
-
-
-def pytest_addoption(parser: Parser) -> None:
-    group = parser.getgroup("general")
-    group.addoption(
-        "--capture",
-        action="store",
-        default="fd",
-        metavar="method",
-        choices=["fd", "sys", "no", "tee-sys"],
-        help="Per-test capturing method: one of fd|sys|no|tee-sys",
-    )
-    group._addoption(  # private to use reserved lower-case short option
-        "-s",
-        action="store_const",
-        const="no",
-        dest="capture",
-        help="Shortcut for --capture=no",
-    )
-
-
-def _colorama_workaround() -> None:
-    """Ensure colorama is imported so that it attaches to the correct stdio
-    handles on Windows.
-
-    colorama uses the terminal on import time. So if something does the
-    first import of colorama while I/O capture is active, colorama will
-    fail in various ways.
-    """
-    if sys.platform.startswith("win32"):
-        try:
-            import colorama  # noqa: F401
-        except ImportError:
-            pass
-
-
-def _readline_workaround() -> None:
-    """Ensure readline is imported early so it attaches to the correct stdio handles.
-
-    This isn't a problem with the default GNU readline implementation, but in
-    some configurations, Python uses libedit instead (on macOS, and for prebuilt
-    binaries such as used by uv).
-
-    In theory this is only needed if readline.backend == "libedit", but the
-    workaround consists of importing readline here, so we already worked around
-    the issue by the time we could check if we need to.
-    """
-    try:
-        import readline  # noqa: F401
-    except ImportError:
-        pass
-
-
-def _windowsconsoleio_workaround(stream: TextIO) -> None:
-    """Workaround for Windows Unicode console handling.
-
-    Python 3.6 implemented Unicode console handling for Windows. This works
-    by reading/writing to the raw console handle using
-    ``{Read,Write}ConsoleW``.
-
-    The problem is that we are going to ``dup2`` over the stdio file
-    descriptors when doing ``FDCapture`` and this will ``CloseHandle`` the
-    handles used by Python to write to the console. Though there is still some
-    weirdness and the console handle seems to only be closed randomly and not
-    on the first call to ``CloseHandle``, or maybe it gets reopened with the
-    same handle value when we suspend capturing.
-
-    The workaround in this case will reopen stdio with a different fd which
-    also means a different handle by replicating the logic in
-    "Py_lifecycle.c:initstdio/create_stdio".
-
-    :param stream:
-        In practice ``sys.stdout`` or ``sys.stderr``, but given
-        here as parameter for unittesting purposes.
-
-    See https://github.com/pytest-dev/py/issues/103.
-    """
-    if not sys.platform.startswith("win32") or hasattr(sys, "pypy_version_info"):
-        return
-
-    # Bail out if ``stream`` doesn't seem like a proper ``io`` stream (#2666).
-    if not hasattr(stream, "buffer"):  # type: ignore[unreachable,unused-ignore]
-        return
-
-    raw_stdout = stream.buffer.raw if hasattr(stream.buffer, "raw") else stream.buffer
-
-    if not isinstance(raw_stdout, io._WindowsConsoleIO):  # type: ignore[attr-defined,unused-ignore]
-        return
-
-    def _reopen_stdio(f, mode):
-        if not hasattr(stream.buffer, "raw") and mode[0] == "w":
-            buffering = 0
-        else:
-            buffering = -1
-
-        return io.TextIOWrapper(
-            open(os.dup(f.fileno()), mode, buffering),
-            f.encoding,
-            f.errors,
-            f.newlines,
-            f.line_buffering,
-        )
-
-    sys.stdin = _reopen_stdio(sys.stdin, "rb")
-    sys.stdout = _reopen_stdio(sys.stdout, "wb")
-    sys.stderr = _reopen_stdio(sys.stderr, "wb")
-
-
-@hookimpl(wrapper=True)
-def pytest_load_initial_conftests(early_config: Config) -> Generator[None]:
-    ns = early_config.known_args_namespace
-    if ns.capture == "fd":
-        _windowsconsoleio_workaround(sys.stdout)
-    _colorama_workaround()
-    _readline_workaround()
-    pluginmanager = early_config.pluginmanager
-    capman = CaptureManager(ns.capture)
-    pluginmanager.register(capman, "capturemanager")
-
-    # Make sure that capturemanager is properly reset at final shutdown.
-    early_config.add_cleanup(capman.stop_global_capturing)
-
-    # Finally trigger conftest loading but while capturing (issue #93).
-    capman.start_global_capturing()
-    try:
-        try:
-            yield
-        finally:
-            capman.suspend_global_capture()
-    except BaseException:
-        out, err = capman.read_global_capture()
-        sys.stdout.write(out)
-        sys.stderr.write(err)
-        raise
-
-
-# IO Helpers.
-
-
-class EncodedFile(io.TextIOWrapper):
-    __slots__ = ()
-
-    @property
-    def name(self) -> str:
-        # Ensure that file.name is a string. Workaround for a Python bug
-        # fixed in >=3.7.4: https://bugs.python.org/issue36015
-        return repr(self.buffer)
-
-    @property
-    def mode(self) -> str:
-        # TextIOWrapper doesn't expose a mode, but at least some of our
-        # tests check it.
-        assert hasattr(self.buffer, "mode")
-        return cast(str, self.buffer.mode.replace("b", ""))
-
-
-class CaptureIO(io.TextIOWrapper):
-    def __init__(self) -> None:
-        super().__init__(io.BytesIO(), encoding="UTF-8", newline="", write_through=True)
-
-    def getvalue(self) -> str:
-        assert isinstance(self.buffer, io.BytesIO)
-        return self.buffer.getvalue().decode("UTF-8")
-
-
-class TeeCaptureIO(CaptureIO):
-    def __init__(self, other: TextIO) -> None:
-        self._other = other
-        super().__init__()
-
-    def write(self, s: str) -> int:
-        super().write(s)
-        return self._other.write(s)
-
-
-class DontReadFromInput(TextIO):
-    @property
-    def encoding(self) -> str:
-        assert sys.__stdin__ is not None
-        return sys.__stdin__.encoding
-
-    def read(self, size: int = -1) -> str:
-        raise OSError(
-            "pytest: reading from stdin while output is captured!  Consider using `-s`."
-        )
-
-    readline = read
-
-    def __next__(self) -> str:
-        return self.readline()
-
-    def readlines(self, hint: int | None = -1) -> list[str]:
-        raise OSError(
-            "pytest: reading from stdin while output is captured!  Consider using `-s`."
-        )
-
-    def __iter__(self) -> Iterator[str]:
-        return self
-
-    def fileno(self) -> int:
-        raise UnsupportedOperation("redirected stdin is pseudofile, has no fileno()")
-
-    def flush(self) -> None:
-        raise UnsupportedOperation("redirected stdin is pseudofile, has no flush()")
-
-    def isatty(self) -> bool:
-        return False
-
-    def close(self) -> None:
-        pass
-
-    def readable(self) -> bool:
-        return False
-
-    def seek(self, offset: int, whence: int = 0) -> int:
-        raise UnsupportedOperation("redirected stdin is pseudofile, has no seek(int)")
-
-    def seekable(self) -> bool:
-        return False
-
-    def tell(self) -> int:
-        raise UnsupportedOperation("redirected stdin is pseudofile, has no tell()")
-
-    def truncate(self, size: int | None = None) -> int:
-        raise UnsupportedOperation("cannot truncate stdin")
-
-    def write(self, data: str) -> int:
-        raise UnsupportedOperation("cannot write to stdin")
-
-    def writelines(self, lines: Iterable[str]) -> None:
-        raise UnsupportedOperation("Cannot write to stdin")
-
-    def writable(self) -> bool:
-        return False
-
-    def __enter__(self) -> Self:
-        return self
-
-    def __exit__(
-        self,
-        type: type[BaseException] | None,
-        value: BaseException | None,
-        traceback: TracebackType | None,
-    ) -> None:
-        pass
-
-    @property
-    def buffer(self) -> BinaryIO:
-        # The str/bytes doesn't actually matter in this type, so OK to fake.
-        return self  # type: ignore[return-value]
-
-
-# Capture classes.
-
-
-class CaptureBase(abc.ABC, Generic[AnyStr]):
-    EMPTY_BUFFER: AnyStr
-
-    @abc.abstractmethod
-    def __init__(self, fd: int) -> None:
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def start(self) -> None:
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def done(self) -> None:
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def suspend(self) -> None:
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def resume(self) -> None:
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def writeorg(self, data: AnyStr) -> None:
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def snap(self) -> AnyStr:
-        raise NotImplementedError()
-
-
-patchsysdict = {0: "stdin", 1: "stdout", 2: "stderr"}
-
-
-class NoCapture(CaptureBase[str]):
-    EMPTY_BUFFER = ""
-
-    def __init__(self, fd: int) -> None:
-        pass
-
-    def start(self) -> None:
-        pass
-
-    def done(self) -> None:
-        pass
-
-    def suspend(self) -> None:
-        pass
-
-    def resume(self) -> None:
-        pass
-
-    def snap(self) -> str:
-        return ""
-
-    def writeorg(self, data: str) -> None:
-        pass
-
-
-class SysCaptureBase(CaptureBase[AnyStr]):
-    def __init__(
-        self, fd: int, tmpfile: TextIO | None = None, *, tee: bool = False
-    ) -> None:
-        name = patchsysdict[fd]
-        self._old: TextIO = getattr(sys, name)
-        self.name = name
-        if tmpfile is None:
-            if name == "stdin":
-                tmpfile = DontReadFromInput()
-            else:
-                tmpfile = CaptureIO() if not tee else TeeCaptureIO(self._old)
-        self.tmpfile = tmpfile
-        self._state = "initialized"
-
-    def repr(self, class_name: str) -> str:
-        return "<{} {} _old={} _state={!r} tmpfile={!r}>".format(
-            class_name,
-            self.name,
-            (hasattr(self, "_old") and repr(self._old)) or "<UNSET>",
-            self._state,
-            self.tmpfile,
-        )
-
-    def __repr__(self) -> str:
-        return "<{} {} _old={} _state={!r} tmpfile={!r}>".format(
-            self.__class__.__name__,
-            self.name,
-            (hasattr(self, "_old") and repr(self._old)) or "<UNSET>",
-            self._state,
-            self.tmpfile,
-        )
-
-    def _assert_state(self, op: str, states: tuple[str, ...]) -> None:
-        assert self._state in states, (
-            "cannot {} in state {!r}: expected one of {}".format(
-                op, self._state, ", ".join(states)
-            )
-        )
-
-    def start(self) -> None:
-        self._assert_state("start", ("initialized",))
-        setattr(sys, self.name, self.tmpfile)
-        self._state = "started"
-
-    def done(self) -> None:
-        self._assert_state("done", ("initialized", "started", "suspended", "done"))
-        if self._state == "done":
-            return
-        setattr(sys, self.name, self._old)
-        del self._old
-        self.tmpfile.close()
-        self._state = "done"
-
-    def suspend(self) -> None:
-        self._assert_state("suspend", ("started", "suspended"))
-        setattr(sys, self.name, self._old)
-        self._state = "suspended"
-
-    def resume(self) -> None:
-        self._assert_state("resume", ("started", "suspended"))
-        if self._state == "started":
-            return
-        setattr(sys, self.name, self.tmpfile)
-        self._state = "started"
-
-
-class SysCaptureBinary(SysCaptureBase[bytes]):
-    EMPTY_BUFFER = b""
-
-    def snap(self) -> bytes:
-        self._assert_state("snap", ("started", "suspended"))
-        self.tmpfile.seek(0)
-        res = self.tmpfile.buffer.read()
-        self.tmpfile.seek(0)
-        self.tmpfile.truncate()
-        return res
-
-    def writeorg(self, data: bytes) -> None:
-        self._assert_state("writeorg", ("started", "suspended"))
-        self._old.flush()
-        self._old.buffer.write(data)
-        self._old.buffer.flush()
-
-
-class SysCapture(SysCaptureBase[str]):
-    EMPTY_BUFFER = ""
-
-    def snap(self) -> str:
-        self._assert_state("snap", ("started", "suspended"))
-        assert isinstance(self.tmpfile, CaptureIO)
-        res = self.tmpfile.getvalue()
-        self.tmpfile.seek(0)
-        self.tmpfile.truncate()
-        return res
-
-    def writeorg(self, data: str) -> None:
-        self._assert_state("writeorg", ("started", "suspended"))
-        self._old.write(data)
-        self._old.flush()
-
-
-class FDCaptureBase(CaptureBase[AnyStr]):
-    def __init__(self, targetfd: int) -> None:
-        self.targetfd = targetfd
-
-        try:
-            os.fstat(targetfd)
-        except OSError:
-            # FD capturing is conceptually simple -- create a temporary file,
-            # redirect the FD to it, redirect back when done. But when the
-            # target FD is invalid it throws a wrench into this lovely scheme.
-            #
-            # Tests themselves shouldn't care if the FD is valid, FD capturing
-            # should work regardless of external circumstances. So falling back
-            # to just sys capturing is not a good option.
-            #
-            # Further complications are the need to support suspend() and the
-            # possibility of FD reuse (e.g. the tmpfile getting the very same
-            # target FD). The following approach is robust, I believe.
-            self.targetfd_invalid: int | None = os.open(os.devnull, os.O_RDWR)
-            os.dup2(self.targetfd_invalid, targetfd)
-        else:
-            self.targetfd_invalid = None
-        self.targetfd_save = os.dup(targetfd)
-
-        if targetfd == 0:
-            self.tmpfile = open(os.devnull, encoding="utf-8")
-            self.syscapture: CaptureBase[str] = SysCapture(targetfd)
-        else:
-            self.tmpfile = EncodedFile(
-                TemporaryFile(buffering=0),
-                encoding="utf-8",
-                errors="replace",
-                newline="",
-                write_through=True,
-            )
-            if targetfd in patchsysdict:
-                self.syscapture = SysCapture(targetfd, self.tmpfile)
-            else:
-                self.syscapture = NoCapture(targetfd)
-
-        self._state = "initialized"
-
-    def __repr__(self) -> str:
-        return (
-            f"<{self.__class__.__name__} {self.targetfd} oldfd={self.targetfd_save} "
-            f"_state={self._state!r} tmpfile={self.tmpfile!r}>"
-        )
-
-    def _assert_state(self, op: str, states: tuple[str, ...]) -> None:
-        assert self._state in states, (
-            "cannot {} in state {!r}: expected one of {}".format(
-                op, self._state, ", ".join(states)
-            )
-        )
-
-    def start(self) -> None:
-        """Start capturing on targetfd using memorized tmpfile."""
-        self._assert_state("start", ("initialized",))
-        os.dup2(self.tmpfile.fileno(), self.targetfd)
-        self.syscapture.start()
-        self._state = "started"
-
-    def done(self) -> None:
-        """Stop capturing, restore streams, return original capture file,
-        seeked to position zero."""
-        self._assert_state("done", ("initialized", "started", "suspended", "done"))
-        if self._state == "done":
-            return
-        os.dup2(self.targetfd_save, self.targetfd)
-        os.close(self.targetfd_save)
-        if self.targetfd_invalid is not None:
-            if self.targetfd_invalid != self.targetfd:
-                os.close(self.targetfd)
-            os.close(self.targetfd_invalid)
-        self.syscapture.done()
-        self.tmpfile.close()
-        self._state = "done"
-
-    def suspend(self) -> None:
-        self._assert_state("suspend", ("started", "suspended"))
-        if self._state == "suspended":
-            return
-        self.syscapture.suspend()
-        os.dup2(self.targetfd_save, self.targetfd)
-        self._state = "suspended"
-
-    def resume(self) -> None:
-        self._assert_state("resume", ("started", "suspended"))
-        if self._state == "started":
-            return
-        self.syscapture.resume()
-        os.dup2(self.tmpfile.fileno(), self.targetfd)
-        self._state = "started"
-
-
-class FDCaptureBinary(FDCaptureBase[bytes]):
-    """Capture IO to/from a given OS-level file descriptor.
-
-    snap() produces `bytes`.
-    """
-
-    EMPTY_BUFFER = b""
-
-    def snap(self) -> bytes:
-        self._assert_state("snap", ("started", "suspended"))
-        self.tmpfile.seek(0)
-        res = self.tmpfile.buffer.read()
-        self.tmpfile.seek(0)
-        self.tmpfile.truncate()
-        return res  # type: ignore[return-value]
-
-    def writeorg(self, data: bytes) -> None:
-        """Write to original file descriptor."""
-        self._assert_state("writeorg", ("started", "suspended"))
-        os.write(self.targetfd_save, data)
-
-
-class FDCapture(FDCaptureBase[str]):
-    """Capture IO to/from a given OS-level file descriptor.
-
-    snap() produces text.
-    """
-
-    EMPTY_BUFFER = ""
-
-    def snap(self) -> str:
-        self._assert_state("snap", ("started", "suspended"))
-        self.tmpfile.seek(0)
-        res = self.tmpfile.read()
-        self.tmpfile.seek(0)
-        self.tmpfile.truncate()
-        return res
-
-    def writeorg(self, data: str) -> None:
-        """Write to original file descriptor."""
-        self._assert_state("writeorg", ("started", "suspended"))
-        # XXX use encoding of original stream
-        os.write(self.targetfd_save, data.encode("utf-8"))
-
-
-# MultiCapture
-
-
-# Generic NamedTuple only supported since Python 3.11.
-if sys.version_info >= (3, 11) or TYPE_CHECKING:
-
-    @final
-    class CaptureResult(NamedTuple, Generic[AnyStr]):
-        """The result of :method:`caplog.readouterr() <pytest.CaptureFixture.readouterr>`."""
-
-        out: AnyStr
-        err: AnyStr
-
-else:
-
-    class CaptureResult(
-        collections.namedtuple("CaptureResult", ["out", "err"]),  # noqa: PYI024
-        Generic[AnyStr],
-    ):
-        """The result of :method:`caplog.readouterr() <pytest.CaptureFixture.readouterr>`."""
-
-        __slots__ = ()
-
-
-class MultiCapture(Generic[AnyStr]):
-    _state = None
-    _in_suspended = False
-
-    def __init__(
-        self,
-        in_: CaptureBase[AnyStr] | None,
-        out: CaptureBase[AnyStr] | None,
-        err: CaptureBase[AnyStr] | None,
-    ) -> None:
-        self.in_: CaptureBase[AnyStr] | None = in_
-        self.out: CaptureBase[AnyStr] | None = out
-        self.err: CaptureBase[AnyStr] | None = err
-
-    def __repr__(self) -> str:
-        return (
-            f"<MultiCapture out={self.out!r} err={self.err!r} in_={self.in_!r} "
-            f"_state={self._state!r} _in_suspended={self._in_suspended!r}>"
-        )
-
-    def start_capturing(self) -> None:
-        self._state = "started"
-        if self.in_:
-            self.in_.start()
-        if self.out:
-            self.out.start()
-        if self.err:
-            self.err.start()
-
-    def pop_outerr_to_orig(self) -> tuple[AnyStr, AnyStr]:
-        """Pop current snapshot out/err capture and flush to orig streams."""
-        out, err = self.readouterr()
-        if out:
-            assert self.out is not None
-            self.out.writeorg(out)
-        if err:
-            assert self.err is not None
-            self.err.writeorg(err)
-        return out, err
-
-    def suspend_capturing(self, in_: bool = False) -> None:
-        self._state = "suspended"
-        if self.out:
-            self.out.suspend()
-        if self.err:
-            self.err.suspend()
-        if in_ and self.in_:
-            self.in_.suspend()
-            self._in_suspended = True
-
-    def resume_capturing(self) -> None:
-        self._state = "started"
-        if self.out:
-            self.out.resume()
-        if self.err:
-            self.err.resume()
-        if self._in_suspended:
-            assert self.in_ is not None
-            self.in_.resume()
-            self._in_suspended = False
-
-    def stop_capturing(self) -> None:
-        """Stop capturing and reset capturing streams."""
-        if self._state == "stopped":
-            raise ValueError("was already stopped")
-        self._state = "stopped"
-        if self.out:
-            self.out.done()
-        if self.err:
-            self.err.done()
-        if self.in_:
-            self.in_.done()
-
-    def is_started(self) -> bool:
-        """Whether actively capturing -- not suspended or stopped."""
-        return self._state == "started"
-
-    def readouterr(self) -> CaptureResult[AnyStr]:
-        out = self.out.snap() if self.out else ""
-        err = self.err.snap() if self.err else ""
-        # TODO: This type error is real, need to fix.
-        return CaptureResult(out, err)  # type: ignore[arg-type]
-
-
-def _get_multicapture(method: _CaptureMethod) -> MultiCapture[str]:
-    if method == "fd":
-        return MultiCapture(in_=FDCapture(0), out=FDCapture(1), err=FDCapture(2))
-    elif method == "sys":
-        return MultiCapture(in_=SysCapture(0), out=SysCapture(1), err=SysCapture(2))
-    elif method == "no":
-        return MultiCapture(in_=None, out=None, err=None)
-    elif method == "tee-sys":
-        return MultiCapture(
-            in_=None, out=SysCapture(1, tee=True), err=SysCapture(2, tee=True)
-        )
-    raise ValueError(f"unknown capturing method: {method!r}")
-
-
-# CaptureManager and CaptureFixture
-
-
-class CaptureManager:
-    """The capture plugin.
-
-    Manages that the appropriate capture method is enabled/disabled during
-    collection and each test phase (setup, call, teardown). After each of
-    those points, the captured output is obtained and attached to the
-    collection/runtest report.
-
-    There are two levels of capture:
-
-    * global: enabled by default and can be suppressed by the ``-s``
-      option. This is always enabled/disabled during collection and each test
-      phase.
-
-    * fixture: when a test function or one of its fixture depend on the
-      ``capsys`` or ``capfd`` fixtures. In this case special handling is
-      needed to ensure the fixtures take precedence over the global capture.
-    """
-
-    def __init__(self, method: _CaptureMethod) -> None:
-        self._method: Final = method
-        self._global_capturing: MultiCapture[str] | None = None
-        self._capture_fixture: CaptureFixture[Any] | None = None
-
-    def __repr__(self) -> str:
-        return (
-            f"<CaptureManager _method={self._method!r} _global_capturing={self._global_capturing!r} "
-            f"_capture_fixture={self._capture_fixture!r}>"
-        )
-
-    def is_capturing(self) -> str | bool:
-        if self.is_globally_capturing():
-            return "global"
-        if self._capture_fixture:
-            return f"fixture {self._capture_fixture.request.fixturename}"
-        return False
-
-    # Global capturing control
-
-    def is_globally_capturing(self) -> bool:
-        return self._method != "no"
-
-    def start_global_capturing(self) -> None:
-        assert self._global_capturing is None
-        self._global_capturing = _get_multicapture(self._method)
-        self._global_capturing.start_capturing()
-
-    def stop_global_capturing(self) -> None:
-        if self._global_capturing is not None:
-            self._global_capturing.pop_outerr_to_orig()
-            self._global_capturing.stop_capturing()
-            self._global_capturing = None
-
-    def resume_global_capture(self) -> None:
-        # During teardown of the python process, and on rare occasions, capture
-        # attributes can be `None` while trying to resume global capture.
-        if self._global_capturing is not None:
-            self._global_capturing.resume_capturing()
-
-    def suspend_global_capture(self, in_: bool = False) -> None:
-        if self._global_capturing is not None:
-            self._global_capturing.suspend_capturing(in_=in_)
-
-    def suspend(self, in_: bool = False) -> None:
-        # Need to undo local capsys-et-al if it exists before disabling global capture.
-        self.suspend_fixture()
-        self.suspend_global_capture(in_)
-
-    def resume(self) -> None:
-        self.resume_global_capture()
-        self.resume_fixture()
-
-    def read_global_capture(self) -> CaptureResult[str]:
-        assert self._global_capturing is not None
-        return self._global_capturing.readouterr()
-
-    # Fixture Control
-
-    def set_fixture(self, capture_fixture: CaptureFixture[Any]) -> None:
-        if self._capture_fixture:
-            current_fixture = self._capture_fixture.request.fixturename
-            requested_fixture = capture_fixture.request.fixturename
-            capture_fixture.request.raiseerror(
-                f"cannot use {requested_fixture} and {current_fixture} at the same time"
-            )
-        self._capture_fixture = capture_fixture
-
-    def unset_fixture(self) -> None:
-        self._capture_fixture = None
-
-    def activate_fixture(self) -> None:
-        """If the current item is using ``capsys`` or ``capfd``, activate
-        them so they take precedence over the global capture."""
-        if self._capture_fixture:
-            self._capture_fixture._start()
-
-    def deactivate_fixture(self) -> None:
-        """Deactivate the ``capsys`` or ``capfd`` fixture of this item, if any."""
-        if self._capture_fixture:
-            self._capture_fixture.close()
-
-    def suspend_fixture(self) -> None:
-        if self._capture_fixture:
-            self._capture_fixture._suspend()
-
-    def resume_fixture(self) -> None:
-        if self._capture_fixture:
-            self._capture_fixture._resume()
-
-    # Helper context managers
-
-    @contextlib.contextmanager
-    def global_and_fixture_disabled(self) -> Generator[None]:
-        """Context manager to temporarily disable global and current fixture capturing."""
-        do_fixture = self._capture_fixture and self._capture_fixture._is_started()
-        if do_fixture:
-            self.suspend_fixture()
-        do_global = self._global_capturing and self._global_capturing.is_started()
-        if do_global:
-            self.suspend_global_capture()
-        try:
-            yield
-        finally:
-            if do_global:
-                self.resume_global_capture()
-            if do_fixture:
-                self.resume_fixture()
-
-    @contextlib.contextmanager
-    def item_capture(self, when: str, item: Item) -> Generator[None]:
-        self.resume_global_capture()
-        self.activate_fixture()
-        try:
-            yield
-        finally:
-            self.deactivate_fixture()
-            self.suspend_global_capture(in_=False)
-
-            out, err = self.read_global_capture()
-            item.add_report_section(when, "stdout", out)
-            item.add_report_section(when, "stderr", err)
-
-    # Hooks
-
-    @hookimpl(wrapper=True)
-    def pytest_make_collect_report(
-        self, collector: Collector
-    ) -> Generator[None, CollectReport, CollectReport]:
-        if isinstance(collector, File):
-            self.resume_global_capture()
-            try:
-                rep = yield
-            finally:
-                self.suspend_global_capture()
-            out, err = self.read_global_capture()
-            if out:
-                rep.sections.append(("Captured stdout", out))
-            if err:
-                rep.sections.append(("Captured stderr", err))
-        else:
-            rep = yield
-        return rep
-
-    @hookimpl(wrapper=True)
-    def pytest_runtest_setup(self, item: Item) -> Generator[None]:
-        with self.item_capture("setup", item):
-            return (yield)
-
-    @hookimpl(wrapper=True)
-    def pytest_runtest_call(self, item: Item) -> Generator[None]:
-        with self.item_capture("call", item):
-            return (yield)
-
-    @hookimpl(wrapper=True)
-    def pytest_runtest_teardown(self, item: Item) -> Generator[None]:
-        with self.item_capture("teardown", item):
-            return (yield)
-
-    @hookimpl(tryfirst=True)
-    def pytest_keyboard_interrupt(self) -> None:
-        self.stop_global_capturing()
-
-    @hookimpl(tryfirst=True)
-    def pytest_internalerror(self) -> None:
-        self.stop_global_capturing()
-
-
-class CaptureFixture(Generic[AnyStr]):
-    """Object returned by the :fixture:`capsys`, :fixture:`capsysbinary`,
-    :fixture:`capfd` and :fixture:`capfdbinary` fixtures."""
-
-    def __init__(
-        self,
-        captureclass: type[CaptureBase[AnyStr]],
-        request: SubRequest,
-        *,
-        config: dict[str, Any] | None = None,
-        _ispytest: bool = False,
-    ) -> None:
-        check_ispytest(_ispytest)
-        self.captureclass: type[CaptureBase[AnyStr]] = captureclass
-        self.request = request
-        self._config = config if config else {}
-        self._capture: MultiCapture[AnyStr] | None = None
-        self._captured_out: AnyStr = self.captureclass.EMPTY_BUFFER
-        self._captured_err: AnyStr = self.captureclass.EMPTY_BUFFER
-
-    def _start(self) -> None:
-        if self._capture is None:
-            self._capture = MultiCapture(
-                in_=None,
-                out=self.captureclass(1, **self._config),
-                err=self.captureclass(2, **self._config),
-            )
-            self._capture.start_capturing()
-
-    def close(self) -> None:
-        if self._capture is not None:
-            if self._config.get("tee"):
-                # When tee is enabled, output was already written to the
-                # original stream in real-time by TeeCaptureIO.  Using
-                # pop_outerr_to_orig() would write it a second time via
-                # writeorg(), causing doubled output (see #13784).
-                out, err = self._capture.readouterr()
-            else:
-                out, err = self._capture.pop_outerr_to_orig()
-            self._captured_out += out
-            self._captured_err += err
-            self._capture.stop_capturing()
-            self._capture = None
-
-    def readouterr(self) -> CaptureResult[AnyStr]:
-        """Read and return the captured output so far, resetting the internal
-        buffer.
-
-        :returns:
-            The captured content as a namedtuple with ``out`` and ``err``
-            string attributes.
-        """
-        captured_out, captured_err = self._captured_out, self._captured_err
-        if self._capture is not None:
-            out, err = self._capture.readouterr()
-            captured_out += out
-            captured_err += err
-        self._captured_out = self.captureclass.EMPTY_BUFFER
-        self._captured_err = self.captureclass.EMPTY_BUFFER
-        return CaptureResult(captured_out, captured_err)
-
-    def _suspend(self) -> None:
-        """Suspend this fixture's own capturing temporarily."""
-        if self._capture is not None:
-            self._capture.suspend_capturing()
-
-    def _resume(self) -> None:
-        """Resume this fixture's own capturing temporarily."""
-        if self._capture is not None:
-            self._capture.resume_capturing()
-
-    def _is_started(self) -> bool:
-        """Whether actively capturing -- not disabled or closed."""
-        if self._capture is not None:
-            return self._capture.is_started()
-        return False
-
-    @contextlib.contextmanager
-    def disabled(self) -> Generator[None]:
-        """Temporarily disable capturing while inside the ``with`` block."""
-        capmanager: CaptureManager = self.request.config.pluginmanager.getplugin(
-            "capturemanager"
-        )
-        with capmanager.global_and_fixture_disabled():
-            yield
-
-
-# The fixtures.
-
-
-@fixture
-def capsys(request: SubRequest) -> Generator[CaptureFixture[str]]:
-    r"""Enable text capturing of writes to ``sys.stdout`` and ``sys.stderr``.
-
-    The captured output is made available via ``capsys.readouterr()`` method
-    calls, which return a ``(out, err)`` namedtuple.
-    ``out`` and ``err`` will be ``text`` objects.
-
-    Returns an instance of :class:`CaptureFixture[str] <pytest.CaptureFixture>`.
-
-    Example:
-
-    .. code-block:: python
-
-        def test_output(capsys):
-            print("hello")
-            captured = capsys.readouterr()
-            assert captured.out == "hello\n"
-    """
-    capman: CaptureManager = request.config.pluginmanager.getplugin("capturemanager")
-    capture_fixture = CaptureFixture(SysCapture, request, _ispytest=True)
-    capman.set_fixture(capture_fixture)
-    capture_fixture._start()
-    yield capture_fixture
-    capture_fixture.close()
-    capman.unset_fixture()
-
-
-@fixture
-def capteesys(request: SubRequest) -> Generator[CaptureFixture[str]]:
-    r"""Enable simultaneous text capturing and pass-through of writes
-    to ``sys.stdout`` and ``sys.stderr`` as defined by ``--capture=``.
-
-
-    The captured output is made available via ``capteesys.readouterr()`` method
-    calls, which return a ``(out, err)`` namedtuple.
-    ``out`` and ``err`` will be ``text`` objects.
-
-    The output is also passed-through, allowing it to be "live-printed",
-    reported, or both as defined by ``--capture=``.
-
-    Returns an instance of :class:`CaptureFixture[str] <pytest.CaptureFixture>`.
-
-    Example:
-
-    .. code-block:: python
-
-        def test_output(capteesys):
-            print("hello")
-            captured = capteesys.readouterr()
-            assert captured.out == "hello\n"
-    """
-    capman: CaptureManager = request.config.pluginmanager.getplugin("capturemanager")
-    capture_fixture = CaptureFixture(
-        SysCapture, request, config=dict(tee=True), _ispytest=True
-    )
-    capman.set_fixture(capture_fixture)
-    capture_fixture._start()
-    yield capture_fixture
-    capture_fixture.close()
-    capman.unset_fixture()
-
-
-@fixture
-def capsysbinary(request: SubRequest) -> Generator[CaptureFixture[bytes]]:
-    r"""Enable bytes capturing of writes to ``sys.stdout`` and ``sys.stderr``.
-
-    The captured output is made available via ``capsysbinary.readouterr()``
-    method calls, which return a ``(out, err)`` namedtuple.
-    ``out`` and ``err`` will be ``bytes`` objects.
-
-    Returns an instance of :class:`CaptureFixture[bytes] <pytest.CaptureFixture>`.
-
-    Example:
-
-    .. code-block:: python
-
-        def test_output(capsysbinary):
-            print("hello")
-            captured = capsysbinary.readouterr()
-            assert captured.out == b"hello\n"
-    """
-    capman: CaptureManager = request.config.pluginmanager.getplugin("capturemanager")
-    capture_fixture = CaptureFixture(SysCaptureBinary, request, _ispytest=True)
-    capman.set_fixture(capture_fixture)
-    capture_fixture._start()
-    yield capture_fixture
-    capture_fixture.close()
-    capman.unset_fixture()
-
-
-@fixture
-def capfd(request: SubRequest) -> Generator[CaptureFixture[str]]:
-    r"""Enable text capturing of writes to file descriptors ``1`` and ``2``.
-
-    The captured output is made available via ``capfd.readouterr()`` method
-    calls, which return a ``(out, err)`` namedtuple.
-    ``out`` and ``err`` will be ``text`` objects.
-
-    Returns an instance of :class:`CaptureFixture[str] <pytest.CaptureFixture>`.
-
-    Example:
-
-    .. code-block:: python
-
-        def test_system_echo(capfd):
-            os.system('echo "hello"')
-            captured = capfd.readouterr()
-            assert captured.out == "hello\n"
-    """
-    capman: CaptureManager = request.config.pluginmanager.getplugin("capturemanager")
-    capture_fixture = CaptureFixture(FDCapture, request, _ispytest=True)
-    capman.set_fixture(capture_fixture)
-    capture_fixture._start()
-    yield capture_fixture
-    capture_fixture.close()
-    capman.unset_fixture()
-
-
-@fixture
-def capfdbinary(request: SubRequest) -> Generator[CaptureFixture[bytes]]:
-    r"""Enable bytes capturing of writes to file descriptors ``1`` and ``2``.
-
-    The captured output is made available via ``capfd.readouterr()`` method
-    calls, which return a ``(out, err)`` namedtuple.
-    ``out`` and ``err`` will be ``byte`` objects.
-
-    Returns an instance of :class:`CaptureFixture[bytes] <pytest.CaptureFixture>`.
-
-    Example:
-
-    .. code-block:: python
-
-        def test_system_echo(capfdbinary):
-            os.system('echo "hello"')
-            captured = capfdbinary.readouterr()
-            assert captured.out == b"hello\n"
-
-    """
-    capman: CaptureManager = request.config.pluginmanager.getplugin("capturemanager")
-    capture_fixture = CaptureFixture(FDCaptureBinary, request, _ispytest=True)
-    capman.set_fixture(capture_fixture)
-    capture_fixture._start()
-    yield capture_fixture
-    capture_fixture.close()
-    capman.unset_fixture()

venv/Lib/site-packages/_pytest/compat.py

@@ -1,329 +0,0 @@
-# mypy: allow-untyped-defs
-"""Python version compatibility code and random general utilities."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-import enum
-import functools
-import inspect
-from inspect import Parameter
-from inspect import Signature
-import os
-from pathlib import Path
-import sys
-from typing import Any
-from typing import Final
-from typing import NoReturn
-from typing import TYPE_CHECKING
-
-import py
-
-
-if sys.version_info >= (3, 14):
-    from annotationlib import Format
-
-
-#: constant to prepare valuing pylib path replacements/lazy proxies later on
-#  intended for removal in pytest 8.0 or 9.0
-
-# fmt: off
-# intentional space to create a fake difference for the verification
-LEGACY_PATH = py.path. local
-# fmt: on
-
-
-def legacy_path(path: str | os.PathLike[str]) -> LEGACY_PATH:
-    """Internal wrapper to prepare lazy proxies for legacy_path instances"""
-    return LEGACY_PATH(path)
-
-
-# fmt: off
-# Singleton type for NOTSET, as described in:
-# https://www.python.org/dev/peps/pep-0484/#support-for-singleton-types-in-unions
-class NotSetType(enum.Enum):
-    token = 0
-NOTSET: Final = NotSetType.token
-# fmt: on
-
-
-def iscoroutinefunction(func: object) -> bool:
-    """Return True if func is a coroutine function (a function defined with async
-    def syntax, and doesn't contain yield), or a function decorated with
-    @asyncio.coroutine.
-
-    Note: copied and modified from Python 3.5's builtin coroutines.py to avoid
-    importing asyncio directly, which in turns also initializes the "logging"
-    module as a side-effect (see issue #8).
-    """
-    return inspect.iscoroutinefunction(func) or getattr(func, "_is_coroutine", False)
-
-
-def is_async_function(func: object) -> bool:
-    """Return True if the given function seems to be an async function or
-    an async generator."""
-    return iscoroutinefunction(func) or inspect.isasyncgenfunction(func)
-
-
-def signature(obj: Callable[..., Any]) -> Signature:
-    """Return signature without evaluating annotations."""
-    if sys.version_info >= (3, 14):
-        return inspect.signature(obj, annotation_format=Format.STRING)
-    return inspect.signature(obj)
-
-
-def getlocation(function, curdir: str | os.PathLike[str] | None = None) -> str:
-    function = get_real_func(function)
-    fn = Path(inspect.getfile(function))
-    lineno = function.__code__.co_firstlineno
-    if curdir is not None:
-        try:
-            relfn = fn.relative_to(curdir)
-        except ValueError:
-            pass
-        else:
-            return f"{relfn}:{lineno + 1}"
-    return f"{fn}:{lineno + 1}"
-
-
-def num_mock_patch_args(function) -> int:
-    """Return number of arguments used up by mock arguments (if any)."""
-    patchings = getattr(function, "patchings", None)
-    if not patchings:
-        return 0
-
-    mock_sentinel = getattr(sys.modules.get("mock"), "DEFAULT", object())
-    ut_mock_sentinel = getattr(sys.modules.get("unittest.mock"), "DEFAULT", object())
-
-    return len(
-        [
-            p
-            for p in patchings
-            if not p.attribute_name
-            and (p.new is mock_sentinel or p.new is ut_mock_sentinel)
-        ]
-    )
-
-
-def getfuncargnames(
-    function: Callable[..., object],
-    *,
-    name: str = "",
-    cls: type | None = None,
-) -> tuple[str, ...]:
-    """Return the names of a function's mandatory arguments.
-
-    Should return the names of all function arguments that:
-    * Aren't bound to an instance or type as in instance or class methods.
-    * Don't have default values.
-    * Aren't bound with functools.partial.
-    * Aren't replaced with mocks.
-
-    The cls arguments indicate that the function should be treated as a bound
-    method even though it's not unless the function is a static method.
-
-    The name parameter should be the original name in which the function was collected.
-    """
-    # TODO(RonnyPfannschmidt): This function should be refactored when we
-    # revisit fixtures. The fixture mechanism should ask the node for
-    # the fixture names, and not try to obtain directly from the
-    # function object well after collection has occurred.
-
-    # The parameters attribute of a Signature object contains an
-    # ordered mapping of parameter names to Parameter instances.  This
-    # creates a tuple of the names of the parameters that don't have
-    # defaults.
-    try:
-        parameters = signature(function).parameters.values()
-    except (ValueError, TypeError) as e:
-        from _pytest.outcomes import fail
-
-        fail(
-            f"Could not determine arguments of {function!r}: {e}",
-            pytrace=False,
-        )
-
-    arg_names = tuple(
-        p.name
-        for p in parameters
-        if (
-            p.kind is Parameter.POSITIONAL_OR_KEYWORD
-            or p.kind is Parameter.KEYWORD_ONLY
-        )
-        and p.default is Parameter.empty
-    )
-    if not name:
-        name = function.__name__
-
-    # If this function should be treated as a bound method even though
-    # it's passed as an unbound method or function, and its first parameter
-    # wasn't defined as positional only, remove the first parameter name.
-    if not any(p.kind is Parameter.POSITIONAL_ONLY for p in parameters) and (
-        # Not using `getattr` because we don't want to resolve the staticmethod.
-        # Not using `cls.__dict__` because we want to check the entire MRO.
-        cls
-        and not isinstance(
-            inspect.getattr_static(cls, name, default=None), staticmethod
-        )
-    ):
-        arg_names = arg_names[1:]
-    # Remove any names that will be replaced with mocks.
-    if hasattr(function, "__wrapped__"):
-        arg_names = arg_names[num_mock_patch_args(function) :]
-    return arg_names
-
-
-def get_default_arg_names(function: Callable[..., Any]) -> tuple[str, ...]:
-    # Note: this code intentionally mirrors the code at the beginning of
-    # getfuncargnames, to get the arguments which were excluded from its result
-    # because they had default values.
-    return tuple(
-        p.name
-        for p in signature(function).parameters.values()
-        if p.kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY)
-        and p.default is not Parameter.empty
-    )
-
-
-_non_printable_ascii_translate_table = {
-    i: f"\\x{i:02x}" for i in range(128) if i not in range(32, 127)
-}
-_non_printable_ascii_translate_table.update(
-    {ord("\t"): "\\t", ord("\r"): "\\r", ord("\n"): "\\n"}
-)
-
-
-def ascii_escaped(val: bytes | str) -> str:
-    r"""If val is pure ASCII, return it as an str, otherwise, escape
-    bytes objects into a sequence of escaped bytes:
-
-    b'\xc3\xb4\xc5\xd6' -> r'\xc3\xb4\xc5\xd6'
-
-    and escapes strings into a sequence of escaped unicode ids, e.g.:
-
-    r'4\nV\U00043efa\x0eMXWB\x1e\u3028\u15fd\xcd\U0007d944'
-
-    Note:
-       The obvious "v.decode('unicode-escape')" will return
-       valid UTF-8 unicode if it finds them in bytes, but we
-       want to return escaped bytes for any byte, even if they match
-       a UTF-8 string.
-    """
-    if isinstance(val, bytes):
-        ret = val.decode("ascii", "backslashreplace")
-    else:
-        ret = val.encode("unicode_escape").decode("ascii")
-    return ret.translate(_non_printable_ascii_translate_table)
-
-
-def get_real_func(obj):
-    """Get the real function object of the (possibly) wrapped object by
-    :func:`functools.wraps`, or :func:`functools.partial`."""
-    obj = inspect.unwrap(obj)
-
-    if isinstance(obj, functools.partial):
-        obj = obj.func
-    return obj
-
-
-def getimfunc(func):
-    try:
-        return func.__func__
-    except AttributeError:
-        return func
-
-
-def safe_getattr(object: Any, name: str, default: Any) -> Any:
-    """Like getattr but return default upon any Exception or any OutcomeException.
-
-    Attribute access can potentially fail for 'evil' Python objects.
-    See issue #214.
-    It catches OutcomeException because of #2490 (issue #580), new outcomes
-    are derived from BaseException instead of Exception (for more details
-    check #2707).
-    """
-    from _pytest.outcomes import TEST_OUTCOME
-
-    try:
-        return getattr(object, name, default)
-    except TEST_OUTCOME:
-        return default
-
-
-def safe_isclass(obj: object) -> bool:
-    """Ignore any exception via isinstance on Python 3."""
-    try:
-        return inspect.isclass(obj)
-    except Exception:
-        return False
-
-
-def get_user_id() -> int | None:
-    """Return the current process's real user id or None if it could not be
-    determined.
-
-    :return: The user id or None if it could not be determined.
-    """
-    # mypy follows the version and platform checking expectation of PEP 484:
-    # https://mypy.readthedocs.io/en/stable/common_issues.html?highlight=platform#python-version-and-system-platform-checks
-    # Containment checks are too complex for mypy v1.5.0 and cause failure.
-    if sys.platform == "win32" or sys.platform == "emscripten":
-        # win32 does not have a getuid() function.
-        # Emscripten has a return 0 stub.
-        return None
-    else:
-        # On other platforms, a return value of -1 is assumed to indicate that
-        # the current process's real user id could not be determined.
-        ERROR = -1
-        uid = os.getuid()
-        return uid if uid != ERROR else None
-
-
-if sys.version_info >= (3, 11):
-    from typing import assert_never
-else:
-
-    def assert_never(value: NoReturn) -> NoReturn:
-        assert False, f"Unhandled value: {value} ({type(value).__name__})"
-
-
-class CallableBool:
-    """
-    A bool-like object that can also be called, returning its true/false value.
-
-    Used for backwards compatibility in cases where something was supposed to be a method
-    but was implemented as a simple attribute by mistake (see `TerminalReporter.isatty`).
-
-    Do not use in new code.
-    """
-
-    def __init__(self, value: bool) -> None:
-        self._value = value
-
-    def __bool__(self) -> bool:
-        return self._value
-
-    def __call__(self) -> bool:
-        return self._value
-
-
-def running_on_ci() -> bool:
-    """Check if we're currently running on a CI system."""
-    # Only enable CI mode if one of these env variables is defined and non-empty.
-    # Note: review `regendoc` tox env in case this list is changed.
-    env_vars = ["CI", "BUILD_NUMBER"]
-    return any(os.environ.get(var) for var in env_vars)
-
-
-if sys.version_info >= (3, 13):
-    from warnings import deprecated as deprecated
-else:
-    if TYPE_CHECKING:
-        from typing_extensions import deprecated as deprecated
-    else:
-
-        def deprecated(msg, /, *, category=None, stacklevel=1):
-            def decorator(func):
-                return func
-
-            return decorator

venv/Lib/site-packages/_pytest/config/__init__.py

@@ -1,2246 +0,0 @@
-# mypy: allow-untyped-defs
-"""Command line options, config-file and conftest.py processing."""
-
-from __future__ import annotations
-
-import argparse
-import builtins
-import collections.abc
-from collections.abc import Callable
-from collections.abc import Generator
-from collections.abc import Iterable
-from collections.abc import Iterator
-from collections.abc import Mapping
-from collections.abc import MutableMapping
-from collections.abc import Sequence
-import contextlib
-import copy
-import dataclasses
-import enum
-from functools import lru_cache
-import glob
-import importlib
-import importlib.metadata
-import inspect
-import os
-import pathlib
-import re
-import shlex
-import sys
-from textwrap import dedent
-import types
-from types import FunctionType
-from typing import Any
-from typing import cast
-from typing import Final
-from typing import final
-from typing import IO
-from typing import TextIO
-from typing import TYPE_CHECKING
-import warnings
-
-from pluggy import HookimplMarker
-from pluggy import HookimplOpts
-from pluggy import HookspecMarker
-from pluggy import HookspecOpts
-from pluggy import PluginManager
-
-from .exceptions import PrintHelp as PrintHelp
-from .exceptions import UsageError as UsageError
-from .findpaths import ConfigDict
-from .findpaths import ConfigValue
-from .findpaths import determine_setup
-from .findpaths import parse_override_ini
-from _pytest import __version__
-import _pytest._code
-from _pytest._code import ExceptionInfo
-from _pytest._code import filter_traceback
-from _pytest._code.code import TracebackStyle
-from _pytest._io import TerminalWriter
-from _pytest.compat import assert_never
-from _pytest.compat import deprecated
-from _pytest.compat import NOTSET
-from _pytest.config.argparsing import Argument
-from _pytest.config.argparsing import FILE_OR_DIR
-from _pytest.config.argparsing import Parser
-import _pytest.deprecated
-import _pytest.hookspec
-from _pytest.outcomes import fail
-from _pytest.outcomes import Skipped
-from _pytest.pathlib import absolutepath
-from _pytest.pathlib import bestrelpath
-from _pytest.pathlib import import_path
-from _pytest.pathlib import ImportMode
-from _pytest.pathlib import resolve_package_path
-from _pytest.pathlib import safe_exists
-from _pytest.stash import Stash
-from _pytest.warning_types import PytestConfigWarning
-from _pytest.warning_types import warn_explicit_for
-
-
-if TYPE_CHECKING:
-    from _pytest.assertion.rewrite import AssertionRewritingHook
-    from _pytest.cacheprovider import Cache
-    from _pytest.terminal import TerminalReporter
-
-_PluggyPlugin = object
-"""A type to represent plugin objects.
-
-Plugins can be any namespace, so we can't narrow it down much, but we use an
-alias to make the intent clear.
-
-Ideally this type would be provided by pluggy itself.
-"""
-
-
-hookimpl = HookimplMarker("pytest")
-hookspec = HookspecMarker("pytest")
-
-
-@final
-class ExitCode(enum.IntEnum):
-    """Encodes the valid exit codes by pytest.
-
-    Currently users and plugins may supply other exit codes as well.
-
-    .. versionadded:: 5.0
-    """
-
-    #: Tests passed.
-    OK = 0
-    #: Tests failed.
-    TESTS_FAILED = 1
-    #: pytest was interrupted.
-    INTERRUPTED = 2
-    #: An internal error got in the way.
-    INTERNAL_ERROR = 3
-    #: pytest was misused.
-    USAGE_ERROR = 4
-    #: pytest couldn't find tests.
-    NO_TESTS_COLLECTED = 5
-    #: All tests pass, but maximum number of warnings exceeded.
-    MAX_WARNINGS_ERROR = 6
-
-    __module__ = "pytest"
-
-
-class ConftestImportFailure(Exception):
-    def __init__(
-        self,
-        path: pathlib.Path,
-        *,
-        cause: Exception,
-    ) -> None:
-        self.path = path
-        self.cause = cause
-
-    def __str__(self) -> str:
-        return f"{type(self.cause).__name__}: {self.cause} (from {self.path})"
-
-
-def filter_traceback_for_conftest_import_failure(
-    entry: _pytest._code.TracebackEntry,
-) -> bool:
-    """Filter tracebacks entries which point to pytest internals or importlib.
-
-    Make a special case for importlib because we use it to import test modules and conftest files
-    in _pytest.pathlib.import_path.
-    """
-    return filter_traceback(entry) and "importlib" not in str(entry.path).split(os.sep)
-
-
-def print_conftest_import_error(e: ConftestImportFailure, file: TextIO) -> None:
-    exc_info = ExceptionInfo.from_exception(e.cause)
-    tw = TerminalWriter(file)
-    tw.line(f"ImportError while loading conftest '{e.path}'.", red=True)
-    exc_info.traceback = exc_info.traceback.filter(
-        filter_traceback_for_conftest_import_failure
-    )
-    exc_repr = (
-        exc_info.getrepr(style="short", chain=False)
-        if exc_info.traceback
-        else exc_info.exconly()
-    )
-    formatted_tb = str(exc_repr)
-    for line in formatted_tb.splitlines():
-        tw.line(line.rstrip(), red=True)
-
-
-def print_usage_error(e: UsageError, file: TextIO) -> None:
-    tw = TerminalWriter(file)
-    for msg in e.args:
-        tw.line(f"ERROR: {msg}\n", red=True)
-
-
-def _get_prog_name(argv: Sequence[str]) -> str:
-    """Determine the CLI program name from the argument vector.
-
-    :param argv: The argument vector (typically ``sys.argv``).
-    :returns: ``"python -m pytest"`` when invoked via ``python -m``,
-              ``"pytest"`` otherwise.
-    """
-    argv0 = argv[0] if argv else ""
-    if os.path.basename(argv0) == "__main__.py":
-        return "python -m pytest"
-    return "pytest"
-
-
-def main(
-    args: list[str] | os.PathLike[str] | None = None,
-    plugins: Sequence[str | _PluggyPlugin] | None = None,
-) -> int | ExitCode:
-    """Perform an in-process test run.
-
-    :param args:
-        List of command line arguments. If `None` or not given, defaults to reading
-        arguments directly from the process command line (:data:`sys.argv`).
-    :param plugins: List of plugin objects to be auto-registered during initialization.
-
-    :returns: An exit code.
-    """
-    return _main(args=args, plugins=plugins, prog="pytest.main()")
-
-
-def _main(
-    *,
-    args: list[str] | os.PathLike[str] | None = None,
-    plugins: Sequence[str | _PluggyPlugin] | None = None,
-    prog: str,
-) -> int | ExitCode:
-    # Handle a single `--version`/`-V` argument early to avoid starting up the entire pytest infrastructure.
-    new_args = sys.argv[1:] if args is None else args
-    if (
-        isinstance(new_args, Sequence)
-        and (new_args.count("--version") + new_args.count("-V")) == 1
-    ):
-        sys.stdout.write(f"pytest {__version__}\n")
-        return ExitCode.OK
-
-    old_pytest_version = os.environ.get("PYTEST_VERSION")
-    try:
-        os.environ["PYTEST_VERSION"] = __version__
-        try:
-            config = _prepareconfig(new_args, plugins, prog=prog)
-        except ConftestImportFailure as e:
-            print_conftest_import_error(e, file=sys.stderr)
-            return ExitCode.USAGE_ERROR
-
-        try:
-            ret: ExitCode | int = config.hook.pytest_cmdline_main(config=config)
-            try:
-                return ExitCode(ret)
-            except ValueError:
-                return ret
-        finally:
-            config._ensure_unconfigure()
-    except UsageError as e:
-        print_usage_error(e, file=sys.stderr)
-        return ExitCode.USAGE_ERROR
-    finally:
-        if old_pytest_version is None:
-            os.environ.pop("PYTEST_VERSION", None)
-        else:
-            os.environ["PYTEST_VERSION"] = old_pytest_version
-
-
-def _console_main() -> int:
-    """The CLI entry point of pytest (internal).
-
-    This is the real implementation used by entry points and ``__main__.py``.
-    """
-    # https://docs.python.org/3/library/signal.html#note-on-sigpipe
-    try:
-        code = _main(prog=_get_prog_name(sys.argv))
-        sys.stdout.flush()
-        return code
-    except BrokenPipeError:
-        # Python flushes standard streams on exit; redirect remaining output
-        # to devnull to avoid another BrokenPipeError at shutdown
-        devnull = os.open(os.devnull, os.O_WRONLY)
-        os.dup2(devnull, sys.stdout.fileno())
-        return 1  # Python exits with error code 1 on EPIPE
-
-
-def console_main() -> int:
-    """The CLI entry point of pytest.
-
-    .. deprecated:: 9.1
-        This function is slated for removal in pytest 10.
-        It is not meant for programmable use; use :func:`pytest.main` instead.
-    """
-    import warnings
-
-    from _pytest.deprecated import CONSOLE_MAIN
-
-    warnings.warn(CONSOLE_MAIN, stacklevel=2)
-    return _console_main()
-
-
-class cmdline:  # compatibility namespace
-    main = staticmethod(main)
-
-
-def filename_arg(path: str, optname: str) -> str:
-    """Argparse type validator for filename arguments.
-
-    :path: Path of filename.
-    :optname: Name of the option.
-    """
-    if os.path.isdir(path):
-        raise UsageError(f"{optname} must be a filename, given: {path}")
-    return path
-
-
-def directory_arg(path: str, optname: str) -> str:
-    """Argparse type validator for directory arguments.
-
-    :path: Path of directory.
-    :optname: Name of the option.
-    """
-    if not os.path.isdir(path):
-        raise UsageError(f"{optname} must be a directory, given: {path}")
-    return path
-
-
-# Plugins that cannot be disabled via "-p no:X" currently.
-essential_plugins = (
-    "mark",
-    "main",
-    "runner",
-    "fixtures",
-    "helpconfig",  # Provides -p.
-)
-
-default_plugins = (
-    *essential_plugins,
-    "python",
-    "terminal",
-    "debugging",
-    "unittest",
-    "capture",
-    "skipping",
-    "legacypath",
-    "tmpdir",
-    "monkeypatch",
-    "recwarn",
-    "pastebin",
-    "assertion",
-    "junitxml",
-    "doctest",
-    "cacheprovider",
-    "setuponly",
-    "setupplan",
-    "stepwise",
-    "unraisableexception",
-    "threadexception",
-    "warnings",
-    "logging",
-    "reports",
-    "faulthandler",
-    "subtests",
-)
-
-builtin_plugins = {
-    *default_plugins,
-    "pytester",
-    "pytester_assertions",
-    "terminalprogress",
-}
-
-
-def get_config(
-    args: Iterable[str] | None = None,
-    plugins: Sequence[str | _PluggyPlugin] | None = None,
-    *,
-    prog: str | None = None,
-) -> Config:
-    # Subsequent calls to main will create a fresh instance.
-    pluginmanager = PytestPluginManager()
-    invocation_params = Config.InvocationParams(
-        args=args or (),
-        plugins=plugins,
-        dir=pathlib.Path.cwd(),
-    )
-    config = Config(pluginmanager, invocation_params=invocation_params, prog=prog)
-
-    if invocation_params.args:
-        # Handle any "-p no:plugin" args.
-        pluginmanager.consider_preparse(invocation_params.args, exclude_only=True)
-
-    for spec in default_plugins:
-        pluginmanager.import_plugin(spec)
-
-    return config
-
-
-def get_plugin_manager() -> PytestPluginManager:
-    """Obtain a new instance of the
-    :py:class:`pytest.PytestPluginManager`, with default plugins
-    already loaded.
-
-    This function can be used by integration with other tools, like hooking
-    into pytest to run tests into an IDE.
-    """
-    return get_config().pluginmanager
-
-
-def _prepareconfig(
-    args: list[str] | os.PathLike[str],
-    plugins: Sequence[str | _PluggyPlugin] | None = None,
-    *,
-    prog: str | None = None,
-) -> Config:
-    if isinstance(args, os.PathLike):
-        args = [os.fspath(args)]
-    elif not isinstance(args, list):
-        msg = (  # type:ignore[unreachable]
-            "`args` parameter expected to be a list of strings, got: {!r} (type: {})"
-        )
-        raise TypeError(msg.format(args, type(args)))
-
-    initial_config = get_config(args, plugins, prog=prog)
-    pluginmanager = initial_config.pluginmanager
-    try:
-        if plugins:
-            for plugin in plugins:
-                if isinstance(plugin, str):
-                    pluginmanager.consider_pluginarg(plugin)
-                else:
-                    pluginmanager.register(plugin)
-        config: Config = pluginmanager.hook.pytest_cmdline_parse(
-            pluginmanager=pluginmanager, args=args
-        )
-        return config
-    except BaseException:
-        initial_config._ensure_unconfigure()
-        raise
-
-
-def _get_directory(path: pathlib.Path) -> pathlib.Path:
-    """Get the directory of a path - itself if already a directory."""
-    if path.is_file():
-        return path.parent
-    else:
-        return path
-
-
-def _get_legacy_hook_marks(
-    method: Any,
-    hook_type: str,
-    opt_names: tuple[str, ...],
-) -> dict[str, bool]:
-    if TYPE_CHECKING:
-        # abuse typeguard from importlib to avoid massive method type union that's lacking an alias
-        assert inspect.isroutine(method)
-    known_marks: set[str] = {m.name for m in getattr(method, "pytestmark", [])}
-    must_warn: list[str] = []
-    opts: dict[str, bool] = {}
-    for opt_name in opt_names:
-        opt_attr = getattr(method, opt_name, AttributeError)
-        if opt_attr is not AttributeError:
-            must_warn.append(f"{opt_name}={opt_attr}")
-            opts[opt_name] = True
-        elif opt_name in known_marks:
-            must_warn.append(f"{opt_name}=True")
-            opts[opt_name] = True
-        else:
-            opts[opt_name] = False
-    if must_warn:
-        hook_opts = ", ".join(must_warn)
-        message = _pytest.deprecated.HOOK_LEGACY_MARKING.format(
-            type=hook_type,
-            fullname=method.__qualname__,
-            hook_opts=hook_opts,
-        )
-        warn_explicit_for(cast(FunctionType, method), message)
-    return opts
-
-
-@final
-class PytestPluginManager(PluginManager):
-    """A :py:class:`pluggy.PluginManager <pluggy.PluginManager>` with
-    additional pytest-specific functionality:
-
-    * Loading plugins from the command line, ``PYTEST_PLUGINS`` env variable and
-      ``pytest_plugins`` global variables found in plugins being loaded.
-    * ``conftest.py`` loading during start-up.
-    """
-
-    def __init__(self) -> None:
-        from _pytest.assertion import DummyRewriteHook
-        from _pytest.assertion import RewriteHook
-
-        super().__init__("pytest")
-
-        # -- State related to local conftest plugins.
-        # All loaded conftest modules.
-        self._conftest_plugins: set[types.ModuleType] = set()
-        # All conftest modules applicable for a directory.
-        # This includes the directory's own conftest modules as well
-        # as those of its parent directories.
-        self._dirpath2confmods: dict[pathlib.Path, list[types.ModuleType]] = {}
-        # Cutoff directory above which conftests are no longer discovered.
-        self._confcutdir: pathlib.Path | None = None
-        # If set, conftest loading is skipped.
-        self._noconftest = False
-
-        # _getconftestmodules()'s call to _get_directory() causes a stat
-        # storm when it's called potentially thousands of times in a test
-        # session (#9478), often with the same path, so cache it.
-        self._get_directory = lru_cache(256)(_get_directory)
-
-        # plugins that were explicitly skipped with pytest.skip
-        # list of (module name, skip reason)
-        # previously we would issue a warning when a plugin was skipped, but
-        # since we refactored warnings as first citizens of Config, they are
-        # just stored here to be used later.
-        self.skipped_plugins: list[tuple[str, str]] = []
-
-        self.add_hookspecs(_pytest.hookspec)
-        self.register(self)
-        if os.environ.get("PYTEST_DEBUG"):
-            err: IO[str] = sys.stderr
-            encoding: str = getattr(err, "encoding", "utf8")
-            try:
-                err = open(
-                    os.dup(err.fileno()),
-                    mode=err.mode,
-                    buffering=1,
-                    encoding=encoding,
-                )
-            except Exception:
-                pass
-            self.trace.root.setwriter(err.write)
-            self.enable_tracing()
-
-        # Config._consider_importhook will set a real object if required.
-        self.rewrite_hook: RewriteHook = DummyRewriteHook()
-        # Used to know when we are importing conftests after the pytest_configure stage.
-        self._configured = False
-
-    def parse_hookimpl_opts(
-        self, plugin: _PluggyPlugin, name: str
-    ) -> HookimplOpts | None:
-        """:meta private:"""
-        # pytest hooks are always prefixed with "pytest_",
-        # so we avoid accessing possibly non-readable attributes
-        # (see issue #1073).
-        if not name.startswith("pytest_"):
-            return None
-        # Ignore names which cannot be hooks.
-        if name == "pytest_plugins":
-            return None
-
-        opts = super().parse_hookimpl_opts(plugin, name)
-        if opts is not None:
-            return opts
-
-        method = getattr(plugin, name)
-        # Consider only actual functions for hooks (#3775).
-        if not inspect.isroutine(method):
-            return None
-        # Collect unmarked hooks as long as they have the `pytest_' prefix.
-        legacy = _get_legacy_hook_marks(
-            method, "impl", ("tryfirst", "trylast", "optionalhook", "hookwrapper")
-        )
-        return cast(HookimplOpts, legacy)
-
-    def parse_hookspec_opts(self, module_or_class, name: str) -> HookspecOpts | None:
-        """:meta private:"""
-        opts = super().parse_hookspec_opts(module_or_class, name)
-        if opts is None:
-            method = getattr(module_or_class, name)
-            if name.startswith("pytest_"):
-                legacy = _get_legacy_hook_marks(
-                    method, "spec", ("firstresult", "historic")
-                )
-                opts = cast(HookspecOpts, legacy)
-        return opts
-
-    def register(self, plugin: _PluggyPlugin, name: str | None = None) -> str | None:
-        if name in _pytest.deprecated.DEPRECATED_EXTERNAL_PLUGINS:
-            warnings.warn(
-                PytestConfigWarning(
-                    "{} plugin has been merged into the core, "
-                    "please remove it from your requirements.".format(
-                        name.replace("_", "-")
-                    )
-                )
-            )
-            return None
-        plugin_name = super().register(plugin, name)
-        if plugin_name is not None:
-            self.hook.pytest_plugin_registered.call_historic(
-                kwargs=dict(
-                    plugin=plugin,
-                    plugin_name=plugin_name,
-                    manager=self,
-                )
-            )
-
-            if isinstance(plugin, types.ModuleType):
-                self.consider_module(plugin)
-        return plugin_name
-
-    def getplugin(self, name: str):
-        # Support deprecated naming because plugins (xdist e.g.) use it.
-        plugin: _PluggyPlugin | None = self.get_plugin(name)
-        return plugin
-
-    def hasplugin(self, name: str) -> bool:
-        """Return whether a plugin with the given name is registered."""
-        return bool(self.get_plugin(name))
-
-    def pytest_configure(self, config: Config) -> None:
-        """:meta private:"""
-        # XXX now that the pluginmanager exposes hookimpl(tryfirst...)
-        # we should remove tryfirst/trylast as markers.
-        config.addinivalue_line(
-            "markers",
-            "tryfirst: mark a hook implementation function such that the "
-            "plugin machinery will try to call it first/as early as possible. "
-            "DEPRECATED, use @pytest.hookimpl(tryfirst=True) instead.",
-        )
-        config.addinivalue_line(
-            "markers",
-            "trylast: mark a hook implementation function such that the "
-            "plugin machinery will try to call it last/as late as possible. "
-            "DEPRECATED, use @pytest.hookimpl(trylast=True) instead.",
-        )
-        self._configured = True
-
-    #
-    # Internal API for local conftest plugin handling.
-    #
-    def _set_initial_conftests(
-        self,
-        args: Sequence[str | pathlib.Path],
-        pyargs: bool,
-        noconftest: bool,
-        rootpath: pathlib.Path,
-        confcutdir: pathlib.Path | None,
-        invocation_dir: pathlib.Path,
-        importmode: ImportMode | str,
-        *,
-        consider_namespace_packages: bool,
-    ) -> None:
-        """Load initial conftest files given a preparsed "namespace".
-
-        As conftest files may add their own command line options which have
-        arguments ('--my-opt somepath') we might get some false positives.
-        All builtin and 3rd party plugins will have been loaded, however, so
-        common options will not confuse our logic here.
-        """
-        self._confcutdir = (
-            absolutepath(invocation_dir / confcutdir) if confcutdir else None
-        )
-        self._noconftest = noconftest
-        self._using_pyargs = pyargs
-
-        anchors = []
-        for initial_path in args:
-            path = str(initial_path)
-            # remove node-id syntax
-            i = path.find("::")
-            if i != -1:
-                path = path[:i]
-            anchor = absolutepath(invocation_dir / path)
-            # Ensure we do not break if what appears to be an anchor
-            # is in fact a very long option (#10169, #11394).
-            if not safe_exists(anchor):
-                continue
-
-            anchors.append(anchor)
-            # Let's also consider test* subdirs.
-            if anchor.is_dir():
-                anchors.extend(x for x in anchor.glob("test*") if x.is_dir())
-        if not anchors:
-            anchors.append(invocation_dir)
-            anchors.extend(x for x in invocation_dir.glob("test*") if x.is_dir())
-
-        for anchor in anchors:
-            self._loadconftestmodules(
-                anchor,
-                importmode,
-                rootpath,
-                consider_namespace_packages=consider_namespace_packages,
-            )
-
-    def _is_in_confcutdir(self, path: pathlib.Path) -> bool:
-        """Whether to consider the given path to load conftests from."""
-        if self._confcutdir is None:
-            return True
-        # The semantics here are literally:
-        #   Do not load a conftest if it is found upwards from confcut dir.
-        # But this is *not* the same as:
-        #   Load only conftests from confcutdir or below.
-        # At first glance they might seem the same thing, however we do support use cases where
-        # we want to load conftests that are not found in confcutdir or below, but are found
-        # in completely different directory hierarchies like packages installed
-        # in out-of-source trees.
-        # (see #9767 for a regression where the logic was inverted).
-        return path not in self._confcutdir.parents
-
-    def _loadconftestmodules(
-        self,
-        path: pathlib.Path,
-        importmode: str | ImportMode,
-        rootpath: pathlib.Path,
-        *,
-        consider_namespace_packages: bool,
-    ) -> None:
-        if self._noconftest:
-            return
-
-        directory = self._get_directory(path)
-
-        # Optimization: avoid repeated searches in the same directory.
-        # Assumes always called with same importmode and rootpath.
-        if directory in self._dirpath2confmods:
-            return
-
-        clist = []
-        for parent in reversed((directory, *directory.parents)):
-            if self._is_in_confcutdir(parent):
-                conftestpath = parent / "conftest.py"
-                if conftestpath.is_file():
-                    mod = self._importconftest(
-                        conftestpath,
-                        importmode,
-                        rootpath,
-                        consider_namespace_packages=consider_namespace_packages,
-                    )
-                    clist.append(mod)
-        self._dirpath2confmods[directory] = clist
-
-    def _getconftestmodules(self, path: pathlib.Path) -> Sequence[types.ModuleType]:
-        directory = self._get_directory(path)
-        return self._dirpath2confmods.get(directory, ())
-
-    def _rget_with_confmod(
-        self,
-        name: str,
-        path: pathlib.Path,
-    ) -> tuple[types.ModuleType, Any]:
-        modules = self._getconftestmodules(path)
-        for mod in reversed(modules):
-            try:
-                return mod, getattr(mod, name)
-            except AttributeError:
-                continue
-        raise KeyError(name)
-
-    def _importconftest(
-        self,
-        conftestpath: pathlib.Path,
-        importmode: str | ImportMode,
-        rootpath: pathlib.Path,
-        *,
-        consider_namespace_packages: bool,
-    ) -> types.ModuleType:
-        conftestpath_plugin_name = str(conftestpath)
-        existing = self.get_plugin(conftestpath_plugin_name)
-        if existing is not None:
-            return cast(types.ModuleType, existing)
-
-        # conftest.py files there are not in a Python package all have module
-        # name "conftest", and thus conflict with each other. Clear the existing
-        # before loading the new one, otherwise the existing one will be
-        # returned from the module cache.
-        pkgpath = resolve_package_path(conftestpath)
-        if pkgpath is None:
-            try:
-                del sys.modules[conftestpath.stem]
-            except KeyError:
-                pass
-
-        try:
-            mod = import_path(
-                conftestpath,
-                mode=importmode,
-                root=rootpath,
-                consider_namespace_packages=consider_namespace_packages,
-            )
-        except Exception as e:
-            assert e.__traceback__ is not None
-            raise ConftestImportFailure(conftestpath, cause=e) from e
-
-        self._check_non_top_pytest_plugins(mod, conftestpath)
-
-        self._conftest_plugins.add(mod)
-        dirpath = conftestpath.parent
-        if dirpath in self._dirpath2confmods:
-            for path, mods in self._dirpath2confmods.items():
-                if dirpath in path.parents or path == dirpath:
-                    if mod in mods:
-                        raise AssertionError(
-                            f"While trying to load conftest path {conftestpath!s}, "
-                            f"found that the module {mod} is already loaded with path {mod.__file__}. "
-                            "This is not supposed to happen. Please report this issue to pytest."
-                        )
-                    mods.append(mod)
-        self.trace(f"loading conftestmodule {mod!r}")
-        self.consider_conftest(mod, registration_name=conftestpath_plugin_name)
-        return mod
-
-    def _check_non_top_pytest_plugins(
-        self,
-        mod: types.ModuleType,
-        conftestpath: pathlib.Path,
-    ) -> None:
-        if (
-            hasattr(mod, "pytest_plugins")
-            and self._configured
-            and not self._using_pyargs
-        ):
-            msg = (
-                "Defining 'pytest_plugins' in a non-top-level conftest is no longer supported:\n"
-                "It affects the entire test suite instead of just below the conftest as expected.\n"
-                "  {}\n"
-                "Please move it to a top level conftest file at the rootdir:\n"
-                "  {}\n"
-                "For more information, visit:\n"
-                "  https://docs.pytest.org/en/stable/deprecations.html#pytest-plugins-in-non-top-level-conftest-files"
-            )
-            fail(msg.format(conftestpath, self._confcutdir), pytrace=False)
-
-    #
-    # API for bootstrapping plugin loading
-    #
-    #
-
-    def consider_preparse(
-        self, args: Sequence[str], *, exclude_only: bool = False
-    ) -> None:
-        """:meta private:"""
-        i = 0
-        n = len(args)
-        while i < n:
-            opt = args[i]
-            i += 1
-            if isinstance(opt, str):
-                if opt == "-p":
-                    try:
-                        parg = args[i]
-                    except IndexError:
-                        return
-                    i += 1
-                elif opt.startswith("-p"):
-                    parg = opt[2:]
-                else:
-                    continue
-                parg = parg.strip()
-                if exclude_only and not parg.startswith("no:"):
-                    continue
-                self.consider_pluginarg(parg)
-
-    def consider_pluginarg(self, arg: str) -> None:
-        """:meta private:"""
-        if arg.startswith("no:"):
-            name = arg[3:]
-            if name in essential_plugins:
-                raise UsageError(f"plugin {name} cannot be disabled")
-
-            if name.endswith("conftest.py"):
-                raise UsageError(
-                    f"Blocking conftest files using -p is not supported: -p no:{name}\n"
-                    "conftest.py files are not plugins and cannot be disabled via -p.\n"
-                )
-
-            # PR #4304: remove stepwise if cacheprovider is blocked.
-            if name == "cacheprovider":
-                self.set_blocked("stepwise")
-                self.set_blocked("pytest_stepwise")
-
-            self.set_blocked(name)
-            if not name.startswith("pytest_"):
-                self.set_blocked("pytest_" + name)
-        else:
-            name = arg
-            # Unblock the plugin.
-            self.unblock(name)
-            if not name.startswith("pytest_"):
-                self.unblock("pytest_" + name)
-            self.import_plugin(arg, consider_entry_points=True)
-
-    def consider_conftest(
-        self, conftestmodule: types.ModuleType, registration_name: str
-    ) -> None:
-        """:meta private:"""
-        self.register(conftestmodule, name=registration_name)
-
-    def consider_env(self) -> None:
-        """:meta private:"""
-        self._import_plugin_specs(os.environ.get("PYTEST_PLUGINS"))
-
-    def consider_module(self, mod: types.ModuleType) -> None:
-        """:meta private:"""
-        self._import_plugin_specs(getattr(mod, "pytest_plugins", []))
-
-    def _import_plugin_specs(
-        self, spec: None | types.ModuleType | str | Sequence[str]
-    ) -> None:
-        plugins = _get_plugin_specs_as_list(spec)
-        for import_spec in plugins:
-            self.import_plugin(import_spec)
-
-    def import_plugin(self, modname: str, consider_entry_points: bool = False) -> None:
-        """Import a plugin with ``modname``.
-
-        If ``consider_entry_points`` is True, entry point names are also
-        considered to find a plugin.
-        """
-        # Most often modname refers to builtin modules, e.g. "pytester",
-        # "terminal" or "capture".  Those plugins are registered under their
-        # basename for historic purposes but must be imported with the
-        # _pytest prefix.
-        assert isinstance(modname, str), (
-            f"module name as text required, got {modname!r}"
-        )
-        if self.is_blocked(modname) or self.get_plugin(modname) is not None:
-            return
-
-        importspec = "_pytest." + modname if modname in builtin_plugins else modname
-        self.rewrite_hook.mark_rewrite(importspec)
-
-        if consider_entry_points:
-            loaded = self.load_setuptools_entrypoints("pytest11", name=modname)
-            if loaded:
-                return
-
-        try:
-            if sys.version_info >= (3, 11):
-                mod = importlib.import_module(importspec)
-            else:
-                # On Python 3.10, import_module breaks
-                # testing/test_config.py::test_disable_plugin_autoload.
-                __import__(importspec)
-                mod = sys.modules[importspec]
-        except ImportError as e:
-            raise ImportError(
-                f'Error importing plugin "{modname}": {e.args[0]}'
-            ).with_traceback(e.__traceback__) from e
-
-        except Skipped as e:
-            self.skipped_plugins.append((modname, e.msg or ""))
-        else:
-            self.register(mod, modname)
-
-
-def _get_plugin_specs_as_list(
-    specs: None | types.ModuleType | str | Sequence[str],
-) -> list[str]:
-    """Parse a plugins specification into a list of plugin names."""
-    # None means empty.
-    if specs is None:
-        return []
-    # Workaround for #3899 - a submodule which happens to be called "pytest_plugins".
-    if isinstance(specs, types.ModuleType):
-        return []
-    # Comma-separated list.
-    if isinstance(specs, str):
-        return specs.split(",") if specs else []
-    # Direct specification.
-    if isinstance(specs, collections.abc.Sequence):
-        return list(specs)
-    raise UsageError(
-        f"Plugins may be specified as a sequence or a ','-separated string of plugin names. Got: {specs!r}"
-    )
-
-
-def _iter_rewritable_modules(package_files: Iterable[str]) -> Iterator[str]:
-    """Given an iterable of file names in a source distribution, return the "names" that should
-    be marked for assertion rewrite.
-
-    For example the package "pytest_mock/__init__.py" should be added as "pytest_mock" in
-    the assertion rewrite mechanism.
-
-    This function has to deal with dist-info based distributions and egg based distributions
-    (which are still very much in use for "editable" installs).
-
-    Here are the file names as seen in a dist-info based distribution:
-
-        pytest_mock/__init__.py
-        pytest_mock/_version.py
-        pytest_mock/plugin.py
-        pytest_mock.egg-info/PKG-INFO
-
-    Here are the file names as seen in an egg based distribution:
-
-        src/pytest_mock/__init__.py
-        src/pytest_mock/_version.py
-        src/pytest_mock/plugin.py
-        src/pytest_mock.egg-info/PKG-INFO
-        LICENSE
-        setup.py
-
-    We have to take in account those two distribution flavors in order to determine which
-    names should be considered for assertion rewriting.
-
-    More information:
-        https://github.com/pytest-dev/pytest-mock/issues/167
-    """
-    package_files = list(package_files)
-    seen_some = False
-    for fn in package_files:
-        is_simple_module = "/" not in fn and fn.endswith(".py")
-        is_package = fn.count("/") == 1 and fn.endswith("__init__.py")
-        if is_simple_module:
-            module_name, _ = os.path.splitext(fn)
-            # we ignore "setup.py" at the root of the distribution
-            # as well as editable installation finder modules made by setuptools
-            if module_name != "setup" and not module_name.startswith("__editable__"):
-                seen_some = True
-                yield module_name
-        elif is_package:
-            package_name = os.path.dirname(fn)
-            seen_some = True
-            yield package_name
-
-    if not seen_some:
-        # At this point we did not find any packages or modules suitable for assertion
-        # rewriting, so we try again by stripping the first path component (to account for
-        # "src" based source trees for example).
-        # This approach lets us have the common case continue to be fast, as egg-distributions
-        # are rarer.
-        new_package_files = []
-        for fn in package_files:
-            parts = fn.split("/")
-            new_fn = "/".join(parts[1:])
-            if new_fn:
-                new_package_files.append(new_fn)
-        if new_package_files:
-            yield from _iter_rewritable_modules(new_package_files)
-
-
-class _DeprecatedInicfgProxy(MutableMapping[str, Any]):
-    """Compatibility proxy for the deprecated Config.inicfg."""
-
-    __slots__ = ("_config",)
-
-    def __init__(self, config: Config) -> None:
-        self._config = config
-
-    def __getitem__(self, key: str) -> Any:
-        return self._config._inicfg[key].value
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self._config._inicfg[key] = ConfigValue(value, origin="override", mode="toml")
-
-    def __delitem__(self, key: str) -> None:
-        del self._config._inicfg[key]
-
-    def __iter__(self) -> Iterator[str]:
-        return iter(self._config._inicfg)
-
-    def __len__(self) -> int:
-        return len(self._config._inicfg)
-
-
-@final
-class Config:
-    """Access to configuration values, pluginmanager and plugin hooks.
-
-    :param PytestPluginManager pluginmanager:
-        A pytest PluginManager.
-
-    :param InvocationParams invocation_params:
-        Object containing parameters regarding the :func:`pytest.main`
-        invocation.
-    """
-
-    @final
-    @dataclasses.dataclass(frozen=True)
-    class InvocationParams:
-        """Holds parameters passed during :func:`pytest.main`.
-
-        The object attributes are read-only.
-
-        .. versionadded:: 5.1
-
-        .. note::
-
-            Note that the environment variable ``PYTEST_ADDOPTS`` and the ``addopts``
-            configuration option are handled by pytest, not being included in the ``args`` attribute.
-
-            Plugins accessing ``InvocationParams`` must be aware of that.
-        """
-
-        args: tuple[str, ...]
-        """The command-line arguments as passed to :func:`pytest.main`."""
-        plugins: Sequence[str | _PluggyPlugin] | None
-        """Extra plugins, might be `None`."""
-        dir: pathlib.Path
-        """The directory from which :func:`pytest.main` was invoked."""
-
-        def __init__(
-            self,
-            *,
-            args: Iterable[str],
-            plugins: Sequence[str | _PluggyPlugin] | None,
-            dir: pathlib.Path,
-        ) -> None:
-            object.__setattr__(self, "args", tuple(args))
-            object.__setattr__(self, "plugins", plugins)
-            object.__setattr__(self, "dir", dir)
-
-    class ArgsSource(enum.Enum):
-        """Indicates the source of the test arguments.
-
-        .. versionadded:: 7.2
-        """
-
-        #: Command line arguments.
-        ARGS = enum.auto()
-        #: Invocation directory.
-        INVOCATION_DIR = enum.auto()
-        INCOVATION_DIR = INVOCATION_DIR  # backwards compatibility alias
-        #: 'testpaths' configuration value.
-        TESTPATHS = enum.auto()
-
-    # Set by cacheprovider plugin.
-    cache: Cache
-
-    def __init__(
-        self,
-        pluginmanager: PytestPluginManager,
-        *,
-        invocation_params: InvocationParams | None = None,
-        prog: str | None = None,
-    ) -> None:
-        if invocation_params is None:
-            invocation_params = self.InvocationParams(
-                args=(), plugins=None, dir=pathlib.Path.cwd()
-            )
-
-        self.option = argparse.Namespace()
-        """Access to command line option as attributes.
-
-        :type: argparse.Namespace
-        """
-
-        self.invocation_params = invocation_params
-        """The parameters with which pytest was invoked.
-
-        :type: InvocationParams
-        """
-
-        self._parser = Parser(
-            usage=f"%(prog)s [options] [{FILE_OR_DIR}] [{FILE_OR_DIR}] [...]",
-            processopt=self._processopt,
-            prog=prog,
-            _ispytest=True,
-        )
-        self.pluginmanager = pluginmanager
-        """The plugin manager handles plugin registration and hook invocation.
-
-        :type: PytestPluginManager
-        """
-
-        self.stash = Stash()
-        """A place where plugins can store information on the config for their
-        own use.
-
-        :type: Stash
-        """
-        # Deprecated alias. Was never public. Can be removed in a few releases.
-        self._store = self.stash
-
-        self.trace = self.pluginmanager.trace.root.get("config")
-        self.hook = self.pluginmanager.hook
-        self._inicache: dict[str, Any] = {}
-        self._inicfg: ConfigDict = {}
-        self._cleanup_stack = contextlib.ExitStack()
-        self.pluginmanager.register(self, "pytestconfig")
-        self._configured = False
-        self.hook.pytest_addoption.call_historic(
-            kwargs=dict(parser=self._parser, pluginmanager=self.pluginmanager)
-        )
-        self.args_source = Config.ArgsSource.ARGS
-        self.args: list[str] = []
-
-    if TYPE_CHECKING:
-
-        @deprecated(
-            "config.inicfg is deprecated, use config.getini() to access configuration values instead.",
-        )
-        @property
-        def inicfg(self) -> _DeprecatedInicfgProxy:
-            raise NotImplementedError()
-    else:
-
-        @property
-        def inicfg(self) -> _DeprecatedInicfgProxy:
-            warnings.warn(
-                _pytest.deprecated.CONFIG_INICFG,
-                stacklevel=2,
-            )
-            return _DeprecatedInicfgProxy(self)
-
-    @property
-    def rootpath(self) -> pathlib.Path:
-        """The path to the :ref:`rootdir <rootdir>`.
-
-        .. versionadded:: 6.1
-        """
-        return self._rootpath
-
-    @property
-    def inipath(self) -> pathlib.Path | None:
-        """The path to the :ref:`configfile <configfiles>`.
-
-        .. versionadded:: 6.1
-        """
-        return self._inipath
-
-    def add_cleanup(self, func: Callable[[], None]) -> None:
-        """Add a function to be called when the config object gets out of
-        use (usually coinciding with pytest_unconfigure).
-        """
-        self._cleanup_stack.callback(func)
-
-    def _do_configure(self) -> None:
-        assert not self._configured
-        self._configured = True
-        self.hook.pytest_configure.call_historic(kwargs=dict(config=self))
-
-    def _ensure_unconfigure(self) -> None:
-        try:
-            if self._configured:
-                self._configured = False
-                try:
-                    self.hook.pytest_unconfigure(config=self)
-                finally:
-                    self.hook.pytest_configure._call_history = []
-        finally:
-            try:
-                self._cleanup_stack.close()
-            finally:
-                self._cleanup_stack = contextlib.ExitStack()
-
-    def get_terminal_writer(self) -> TerminalWriter:
-        terminalreporter: TerminalReporter | None = self.pluginmanager.get_plugin(
-            "terminalreporter"
-        )
-        assert terminalreporter is not None
-        return terminalreporter._tw
-
-    def pytest_cmdline_parse(
-        self, pluginmanager: PytestPluginManager, args: list[str]
-    ) -> Config:
-        try:
-            self.parse(args)
-        except UsageError:
-            # Handle `--version --version` and `--help` here in a minimal fashion.
-            # This gets done via helpconfig normally, but its
-            # pytest_cmdline_main is not called in case of errors.
-            if getattr(self.option, "version", False) or "--version" in args:
-                from _pytest.helpconfig import show_version_verbose
-
-                # Note that `--version` (single argument) is handled early by `Config.main()`, so the only
-                # way we are reaching this point is via `--version --version`.
-                show_version_verbose(self)
-            elif (
-                getattr(self.option, "help", False) or "--help" in args or "-h" in args
-            ):
-                self._parser.optparser.print_help()
-                sys.stdout.write(
-                    "\nNOTE: displaying only minimal help due to UsageError.\n\n"
-                )
-
-            raise
-
-        return self
-
-    def notify_exception(
-        self,
-        excinfo: ExceptionInfo[BaseException],
-        option: argparse.Namespace | None = None,
-    ) -> None:
-        if option and getattr(option, "fulltrace", False):
-            style: TracebackStyle = "long"
-        else:
-            style = "native"
-        excrepr = excinfo.getrepr(
-            funcargs=True, showlocals=getattr(option, "showlocals", False), style=style
-        )
-        res = self.hook.pytest_internalerror(excrepr=excrepr, excinfo=excinfo)
-        if not any(res):
-            for line in str(excrepr).split("\n"):
-                sys.stderr.write(f"INTERNALERROR> {line}\n")
-                sys.stderr.flush()
-
-    def cwd_relative_nodeid(self, nodeid: str) -> str:
-        # nodeid's are relative to the rootpath, compute relative to cwd.
-        if self.invocation_params.dir != self.rootpath:
-            base_path_part, *nodeid_part = nodeid.split("::")
-            # Only process path part
-            fullpath = self.rootpath / base_path_part
-            relative_path = bestrelpath(self.invocation_params.dir, fullpath)
-
-            nodeid = "::".join([relative_path, *nodeid_part])
-        return nodeid
-
-    @classmethod
-    def fromdictargs(cls, option_dict: Mapping[str, Any], args: list[str]) -> Config:
-        """Constructor usable for subprocesses."""
-        config = get_config(args)
-        config.option.__dict__.update(option_dict)
-        config.parse(args, addopts=False)
-        for x in config.option.plugins:
-            config.pluginmanager.consider_pluginarg(x)
-        return config
-
-    def _processopt(self, opt: Argument) -> None:
-        if not hasattr(self.option, opt.dest):
-            setattr(self.option, opt.dest, opt.default)
-
-    @hookimpl(trylast=True)
-    def pytest_load_initial_conftests(self, early_config: Config) -> None:
-        # We haven't fully parsed the command line arguments yet, so
-        # early_config.args it not set yet. But we need it for
-        # discovering the initial conftests. So "pre-run" the logic here.
-        # It will be done for real in `parse()`.
-        args, _args_source = early_config._decide_args(
-            args=early_config.known_args_namespace.file_or_dir,
-            pyargs=early_config.known_args_namespace.pyargs,
-            testpaths=early_config.getini("testpaths"),
-            invocation_dir=early_config.invocation_params.dir,
-            rootpath=early_config.rootpath,
-            warn=False,
-        )
-        self.pluginmanager._set_initial_conftests(
-            args=args,
-            pyargs=early_config.known_args_namespace.pyargs,
-            noconftest=early_config.known_args_namespace.noconftest,
-            rootpath=early_config.rootpath,
-            confcutdir=early_config.known_args_namespace.confcutdir,
-            invocation_dir=early_config.invocation_params.dir,
-            importmode=early_config.known_args_namespace.importmode,
-            consider_namespace_packages=early_config.getini(
-                "consider_namespace_packages"
-            ),
-        )
-
-    def _consider_importhook(self) -> None:
-        """Install the PEP 302 import hook if using assertion rewriting.
-
-        Needs to parse the --assert=<mode> option from the commandline
-        and find all the installed plugins to mark them for rewriting
-        by the importhook.
-        """
-        mode = getattr(self.known_args_namespace, "assertmode", "plain")
-
-        disable_autoload = getattr(
-            self.known_args_namespace, "disable_plugin_autoload", False
-        ) or bool(os.environ.get("PYTEST_DISABLE_PLUGIN_AUTOLOAD"))
-        if mode == "rewrite":
-            import _pytest.assertion
-
-            try:
-                hook = _pytest.assertion.install_importhook(self)
-            except SystemError:
-                mode = "plain"
-            else:
-                self._mark_plugins_for_rewrite(hook, disable_autoload)
-        self._warn_about_missing_assertion(mode)
-
-    def _mark_plugins_for_rewrite(
-        self, hook: AssertionRewritingHook, disable_autoload: bool
-    ) -> None:
-        """Given an importhook, mark for rewrite any top-level
-        modules or packages in the distribution package for
-        all pytest plugins."""
-        self.pluginmanager.rewrite_hook = hook
-
-        if disable_autoload:
-            # We don't autoload from distribution package entry points,
-            # no need to continue.
-            return
-
-        package_files = (
-            str(file)
-            for dist in importlib.metadata.distributions()
-            if any(ep.group == "pytest11" for ep in dist.entry_points)
-            for file in dist.files or []
-        )
-
-        for name in _iter_rewritable_modules(package_files):
-            hook.mark_rewrite(name)
-
-    def _configure_python_path(self) -> None:
-        # `pythonpath = a b` will set `sys.path` to `[a, b, x, y, z, ...]`
-        for path in reversed(self.getini("pythonpath")):
-            sys.path.insert(0, str(path))
-        self.add_cleanup(self._unconfigure_python_path)
-
-    def _unconfigure_python_path(self) -> None:
-        for path in self.getini("pythonpath"):
-            path_str = str(path)
-            if path_str in sys.path:
-                sys.path.remove(path_str)
-
-    def _validate_args(self, args: list[str], via: str) -> list[str]:
-        """Validate known args."""
-        self._parser.extra_info["config source"] = via
-        try:
-            self._parser.parse_known_and_unknown_args(
-                args, namespace=copy.copy(self.option)
-            )
-        finally:
-            self._parser.extra_info.pop("config source", None)
-
-        return args
-
-    def _decide_args(
-        self,
-        *,
-        args: list[str],
-        pyargs: bool,
-        testpaths: list[str],
-        invocation_dir: pathlib.Path,
-        rootpath: pathlib.Path,
-        warn: bool,
-    ) -> tuple[list[str], ArgsSource]:
-        """Decide the args (initial paths/nodeids) to use given the relevant inputs.
-
-        :param warn: Whether can issue warnings.
-
-        :returns: The args and the args source. Guaranteed to be non-empty.
-        """
-        if args:
-            source = Config.ArgsSource.ARGS
-            result = args
-        else:
-            if invocation_dir == rootpath:
-                source = Config.ArgsSource.TESTPATHS
-                if pyargs:
-                    result = testpaths
-                else:
-                    result = []
-                    for path in testpaths:
-                        result.extend(sorted(glob.iglob(path, recursive=True)))
-                    if testpaths and not result:
-                        if warn:
-                            warning_text = (
-                                "No files were found in testpaths; "
-                                "consider removing or adjusting your testpaths configuration. "
-                                "Searching recursively from the current directory instead."
-                            )
-                            self.issue_config_time_warning(
-                                PytestConfigWarning(warning_text), stacklevel=3
-                            )
-            else:
-                result = []
-            if not result:
-                source = Config.ArgsSource.INVOCATION_DIR
-                result = [str(invocation_dir)]
-        return result, source
-
-    @hookimpl(wrapper=True)
-    def pytest_collection(self) -> Generator[None, object, object]:
-        # Validate invalid configuration keys after collection is done so we
-        # take in account options added by late-loading conftest files.
-        try:
-            return (yield)
-        finally:
-            self._validate_config_options()
-
-    def _checkversion(self) -> None:
-        import pytest
-
-        minver = self.getini("minversion")
-        if minver:
-            # Imported lazily to improve start-up time.
-            from packaging.version import Version
-
-            if Version(minver) > Version(pytest.__version__):
-                raise pytest.UsageError(
-                    f"{self.inipath}: 'minversion' requires pytest-{minver}, actual pytest-{pytest.__version__}'"
-                )
-
-    def _validate_config_options(self) -> None:
-        for key in sorted(self._get_unknown_ini_keys()):
-            self._warn_or_fail_if_strict(f"Unknown config option: {key}\n")
-
-    def _validate_plugins(self) -> None:
-        required_plugins = sorted(self.getini("required_plugins"))
-        if not required_plugins:
-            return
-
-        # Imported lazily to improve start-up time.
-        from packaging.requirements import InvalidRequirement
-        from packaging.requirements import Requirement
-        from packaging.version import Version
-
-        plugin_info = self.pluginmanager.list_plugin_distinfo()
-        plugin_dist_info = {dist.project_name: dist.version for _, dist in plugin_info}
-
-        missing_plugins = []
-        for required_plugin in required_plugins:
-            try:
-                req = Requirement(required_plugin)
-            except InvalidRequirement:
-                missing_plugins.append(required_plugin)
-                continue
-
-            if req.name not in plugin_dist_info:
-                missing_plugins.append(required_plugin)
-            elif not req.specifier.contains(
-                Version(plugin_dist_info[req.name]), prereleases=True
-            ):
-                missing_plugins.append(required_plugin)
-
-        if missing_plugins:
-            raise UsageError(
-                "Missing required plugins: {}".format(", ".join(missing_plugins)),
-            )
-
-    def _warn_or_fail_if_strict(self, message: str) -> None:
-        strict_config = self.getini("strict_config")
-        if strict_config is None:
-            strict_config = self.getini("strict")
-        if strict_config:
-            raise UsageError(message)
-
-        self.issue_config_time_warning(PytestConfigWarning(message), stacklevel=3)
-
-    def _get_unknown_ini_keys(self) -> set[str]:
-        known_keys = self._parser._inidict.keys() | self._parser._ini_aliases.keys()
-        return self._inicfg.keys() - known_keys
-
-    def parse(self, args: list[str], addopts: bool = True) -> None:
-        # Parse given cmdline arguments into this config object.
-        assert self.args == [], (
-            "can only parse cmdline args at most once per Config object"
-        )
-
-        self.hook.pytest_addhooks.call_historic(
-            kwargs=dict(pluginmanager=self.pluginmanager)
-        )
-
-        if addopts:
-            env_addopts = os.environ.get("PYTEST_ADDOPTS", "")
-            if len(env_addopts):
-                args[:] = (
-                    self._validate_args(shlex.split(env_addopts), "via PYTEST_ADDOPTS")
-                    + args
-                )
-
-        # At this point, self.option contains only defaults from the _processopt
-        # callback.
-        ns = self._parser.parse_known_args(args, namespace=copy.copy(self.option))
-        rootpath, inipath, inicfg, ignored_config_files = determine_setup(
-            inifile=ns.inifilename,
-            override_ini=ns.override_ini,
-            args=ns.file_or_dir,
-            rootdir_cmd_arg=ns.rootdir or None,
-            invocation_dir=self.invocation_params.dir,
-        )
-        self._rootpath = rootpath
-        self._inipath = inipath
-        self._ignored_config_files = ignored_config_files
-        self._inicfg = inicfg
-        self._parser.extra_info["rootdir"] = str(self.rootpath)
-        self._parser.extra_info["inifile"] = str(self.inipath)
-
-        self._parser.addini("addopts", "Extra command line options", "args")
-        self._parser.addini("minversion", "Minimally required pytest version")
-        self._parser.addini(
-            "pythonpath", type="paths", help="Add paths to sys.path", default=[]
-        )
-        self._parser.addini(
-            "required_plugins",
-            "Plugins that must be present for pytest to run",
-            type="args",
-            default=[],
-        )
-
-        if addopts:
-            args[:] = (
-                self._validate_args(self.getini("addopts"), "via addopts config") + args
-            )
-
-        self.known_args_namespace = self._parser.parse_known_args(
-            args, namespace=copy.copy(self.option)
-        )
-        if addopts:
-            # addopts may have added overrides (especially via OverrideIniAction).
-            # The thing can be endlessly circular but we only do one level (#14442).
-            if overrides := parse_override_ini(self.known_args_namespace.override_ini):
-                self._inicfg.update(overrides)
-                self._inicache.clear()
-        self._checkversion()
-        self._consider_importhook()
-        self._configure_python_path()
-        self.pluginmanager.consider_preparse(args, exclude_only=False)
-        if (
-            not os.environ.get("PYTEST_DISABLE_PLUGIN_AUTOLOAD")
-            and not self.known_args_namespace.disable_plugin_autoload
-        ):
-            # Autoloading from distribution package entry point has
-            # not been disabled.
-            self.pluginmanager.load_setuptools_entrypoints("pytest11")
-        # Otherwise only plugins explicitly specified in PYTEST_PLUGINS
-        # are going to be loaded.
-        self.pluginmanager.consider_env()
-
-        # Parse again, now including options added in pytest_addoption
-        # by third-party plugins loaded above. This way they're available
-        # on early_config in the pytest_load_initial_conftests hook call below.
-        self.known_args_namespace = self._parser.parse_known_args(
-            args, namespace=copy.copy(self.option)
-        )
-
-        self._validate_plugins()
-        self._warn_about_skipped_plugins()
-
-        if self.known_args_namespace.confcutdir is None:
-            if self.inipath is not None:
-                confcutdir = str(self.inipath.parent)
-            else:
-                confcutdir = str(self.rootpath)
-            self.known_args_namespace.confcutdir = confcutdir
-        try:
-            self.hook.pytest_load_initial_conftests(
-                early_config=self, args=args, parser=self._parser
-            )
-        except ConftestImportFailure as e:
-            if self.known_args_namespace.help or self.known_args_namespace.version:
-                # we don't want to prevent --help/--version to work
-                # so just let it pass and print a warning at the end
-                self.issue_config_time_warning(
-                    PytestConfigWarning(f"could not load initial conftests: {e.path}"),
-                    stacklevel=2,
-                )
-            else:
-                raise
-
-        try:
-            self._parser.parse(args, namespace=self.option)
-        except PrintHelp:
-            return
-
-        self.args, self.args_source = self._decide_args(
-            args=getattr(self.option, FILE_OR_DIR),
-            pyargs=self.option.pyargs,
-            testpaths=self.getini("testpaths"),
-            invocation_dir=self.invocation_params.dir,
-            rootpath=self.rootpath,
-            warn=True,
-        )
-
-    def issue_config_time_warning(self, warning: Warning, stacklevel: int) -> None:
-        """Issue and handle a warning during the "configure" stage.
-
-        During ``pytest_configure`` we can't capture warnings using the ``catch_warnings_for_item``
-        function because it is not possible to have hook wrappers around ``pytest_configure``.
-
-        This function is mainly intended for plugins that need to issue warnings during
-        ``pytest_configure`` (or similar stages).
-
-        :param warning: The warning instance.
-        :param stacklevel: stacklevel forwarded to warnings.warn.
-        """
-        if self.pluginmanager.is_blocked("warnings"):
-            return
-
-        cmdline_filters = self.known_args_namespace.pythonwarnings or []
-        config_filters = self.getini("filterwarnings")
-
-        with warnings.catch_warnings(record=True) as records:
-            warnings.simplefilter("always", type(warning))
-            apply_warning_filters(config_filters, cmdline_filters)
-            warnings.warn(warning, stacklevel=stacklevel)
-
-        if records:
-            frame = sys._getframe(stacklevel - 1)
-            location = frame.f_code.co_filename, frame.f_lineno, frame.f_code.co_name
-            self.hook.pytest_warning_recorded.call_historic(
-                kwargs=dict(
-                    warning_message=records[0],
-                    when="config",
-                    nodeid="",
-                    location=location,
-                )
-            )
-
-    def addinivalue_line(self, name: str, line: str) -> None:
-        """Add a line to a configuration option. The option must have been
-        declared but might not yet be set in which case the line becomes
-        the first line in its value."""
-        x = self.getini(name)
-        assert isinstance(x, list)
-        x.append(line)  # modifies the cached list inline
-
-    def getini(self, name: str) -> Any:
-        """Return configuration value the an :ref:`configuration file <configfiles>`.
-
-        If a configuration value is not defined in a
-        :ref:`configuration file <configfiles>`, then the ``default`` value
-        provided while registering the configuration through
-        :func:`parser.addini <pytest.Parser.addini>` will be returned.
-        Please note that you can even provide ``None`` as a valid
-        default value.
-
-        If ``default`` is not provided while registering using
-        :func:`parser.addini <pytest.Parser.addini>`, then a default value
-        based on the ``type`` parameter passed to
-        :func:`parser.addini <pytest.Parser.addini>` will be returned.
-        The default values based on ``type`` are:
-        ``paths``, ``pathlist``, ``args`` and ``linelist`` : empty list ``[]``
-        ``bool`` : ``False``
-        ``string`` : empty string ``""``
-        ``int`` : ``0``
-        ``float`` : ``0.0``
-
-        If neither the ``default`` nor the ``type`` parameter is passed
-        while registering the configuration through
-        :func:`parser.addini <pytest.Parser.addini>`, then the configuration
-        is treated as a string and a default empty string '' is returned.
-
-        If the specified name hasn't been registered through a prior
-        :func:`parser.addini <pytest.Parser.addini>` call (usually from a
-        plugin), a ValueError is raised.
-        """
-        canonical_name = self._parser._ini_aliases.get(name, name)
-        try:
-            return self._inicache[canonical_name]
-        except KeyError:
-            pass
-        self._inicache[canonical_name] = val = self._getini(canonical_name)
-        return val
-
-    # Meant for easy monkeypatching by legacypath plugin.
-    # Can be inlined back (with no cover removed) once legacypath is gone.
-    def _getini_unknown_type(self, name: str, type: str, value: object):
-        msg = (
-            f"Option {name} has unknown configuration type {type} with value {value!r}"
-        )
-        raise ValueError(msg)  # pragma: no cover
-
-    def _getini(self, name: str):
-        # If this is an alias, resolve to canonical name.
-        canonical_name = self._parser._ini_aliases.get(name, name)
-
-        try:
-            _description, type, default = self._parser._inidict[canonical_name]
-        except KeyError as e:
-            raise ValueError(f"unknown configuration value: {name!r}") from e
-
-        # Collect all possible values (canonical name + aliases) from _inicfg.
-        # Each candidate is (ConfigValue, is_canonical).
-        candidates = []
-        if canonical_name in self._inicfg:
-            candidates.append((self._inicfg[canonical_name], True))
-        for alias, target in self._parser._ini_aliases.items():
-            if target == canonical_name and alias in self._inicfg:
-                candidates.append((self._inicfg[alias], False))
-
-        if not candidates:
-            return default
-
-        # Pick the best candidate based on precedence:
-        # 1. CLI override takes precedence over file, then
-        # 2. Canonical name takes precedence over alias.
-        selected = max(candidates, key=lambda x: (x[0].origin == "override", x[1]))[0]
-        value = selected.value
-        mode = selected.mode
-
-        if mode == "ini":
-            # In ini mode, values are always str | list[str].
-            assert isinstance(value, (str, list))
-            return self._getini_ini(name, canonical_name, type, value, default)
-        elif mode == "toml":
-            return self._getini_toml(name, canonical_name, type, value, default)
-        else:
-            assert_never(mode)
-
-    def _getini_ini(
-        self,
-        name: str,
-        canonical_name: str,
-        type: str,
-        value: str | list[str],
-        default: Any,
-    ):
-        """Handle config values read in INI mode.
-
-        In INI mode, values are stored as str or list[str] only, and coerced
-        from string based on the registered type.
-        """
-        # Note: some coercions are only required if we are reading from .ini
-        # files, because the file format doesn't contain type information, but
-        # when reading from toml (in ini mode) we will get either str or list of
-        # str values (see load_config_dict_from_file). For example:
-        #
-        #   ini:
-        #     a_line_list = "tests acceptance"
-        #
-        # in this case, we need to split the string to obtain a list of strings.
-        #
-        #   toml (ini mode):
-        #     a_line_list = ["tests", "acceptance"]
-        #
-        # in this case, we already have a list ready to use.
-        if type == "paths":
-            dp = (
-                self.inipath.parent
-                if self.inipath is not None
-                else self.invocation_params.dir
-            )
-            input_values = shlex.split(value) if isinstance(value, str) else value
-            return [dp / x for x in input_values]
-        elif type == "args":
-            return shlex.split(value) if isinstance(value, str) else value
-        elif type == "linelist":
-            if isinstance(value, str):
-                return [t for t in map(lambda x: x.strip(), value.split("\n")) if t]
-            else:
-                return value
-        elif type == "bool":
-            return _strtobool(str(value).strip())
-        elif type == "string":
-            return value
-        elif type == "int":
-            if not isinstance(value, str):
-                raise TypeError(
-                    f"Expected an int string for option {name} of type integer, but got: {value!r}"
-                ) from None
-            return int(value)
-        elif type == "float":
-            if not isinstance(value, str):
-                raise TypeError(
-                    f"Expected a float string for option {name} of type float, but got: {value!r}"
-                ) from None
-            return float(value)
-        else:
-            return self._getini_unknown_type(name, type, value)
-
-    def _getini_toml(
-        self,
-        name: str,
-        canonical_name: str,
-        type: str,
-        value: object,
-        default: Any,
-    ):
-        """Handle TOML config values with strict type validation and no coercion.
-
-        In TOML mode, values already have native types from TOML parsing.
-        We validate types match expectations exactly, including list items.
-        """
-        value_type = builtins.type(value).__name__
-        if type == "paths":
-            # Expect a list of strings.
-            if not isinstance(value, list):
-                raise TypeError(
-                    f"{self.inipath}: config option '{name}' expects a list for type 'paths', "
-                    f"got {value_type}: {value!r}"
-                )
-            for i, item in enumerate(value):
-                if not isinstance(item, str):
-                    item_type = builtins.type(item).__name__
-                    raise TypeError(
-                        f"{self.inipath}: config option '{name}' expects a list of strings, "
-                        f"but item at index {i} is {item_type}: {item!r}"
-                    )
-            dp = (
-                self.inipath.parent
-                if self.inipath is not None
-                else self.invocation_params.dir
-            )
-            return [dp / x for x in value]
-        elif type in {"args", "linelist"}:
-            # Expect a list of strings.
-            if not isinstance(value, list):
-                raise TypeError(
-                    f"{self.inipath}: config option '{name}' expects a list for type '{type}', "
-                    f"got {value_type}: {value!r}"
-                )
-            for i, item in enumerate(value):
-                if not isinstance(item, str):
-                    item_type = builtins.type(item).__name__
-                    raise TypeError(
-                        f"{self.inipath}: config option '{name}' expects a list of strings, "
-                        f"but item at index {i} is {item_type}: {item!r}"
-                    )
-            return list(value)
-        elif type == "bool":
-            # Expect a boolean.
-            if not isinstance(value, bool):
-                raise TypeError(
-                    f"{self.inipath}: config option '{name}' expects a bool, "
-                    f"got {value_type}: {value!r}"
-                )
-            return value
-        elif type == "int":
-            # Expect an integer (but not bool, which is a subclass of int).
-            if not isinstance(value, int) or isinstance(value, bool):
-                raise TypeError(
-                    f"{self.inipath}: config option '{name}' expects an int, "
-                    f"got {value_type}: {value!r}"
-                )
-            return value
-        elif type == "float":
-            # Expect a float or integer only.
-            if not isinstance(value, (float, int)) or isinstance(value, bool):
-                raise TypeError(
-                    f"{self.inipath}: config option '{name}' expects a float, "
-                    f"got {value_type}: {value!r}"
-                )
-            return value
-        elif type == "string":
-            # Expect a string.
-            if not isinstance(value, str):
-                raise TypeError(
-                    f"{self.inipath}: config option '{name}' expects a string, "
-                    f"got {value_type}: {value!r}"
-                )
-            return value
-        else:
-            return self._getini_unknown_type(name, type, value)
-
-    def _getconftest_pathlist(
-        self, name: str, path: pathlib.Path
-    ) -> list[pathlib.Path] | None:
-        try:
-            mod, relroots = self.pluginmanager._rget_with_confmod(name, path)
-        except KeyError:
-            return None
-        assert mod.__file__ is not None
-        modpath = pathlib.Path(mod.__file__).parent
-        values: list[pathlib.Path] = []
-        for relroot in relroots:
-            if isinstance(relroot, os.PathLike):
-                relroot = pathlib.Path(relroot)
-            else:
-                relroot = relroot.replace("/", os.sep)
-                relroot = absolutepath(modpath / relroot)
-            values.append(relroot)
-        return values
-
-    def getoption(self, name: str, default: Any = NOTSET, skip: bool = False):
-        """Return command line option value.
-
-        :param name: Name of the option. You may also specify
-            the literal ``--OPT`` option instead of the "dest" option name.
-        :param default: Fallback value if no option of that name is **declared** via :hook:`pytest_addoption`.
-            Note this parameter will be ignored when the option is **declared** even if the option's value is ``None``.
-        :param skip: If ``True``, raise :func:`pytest.skip` if option is undeclared or has a ``None`` value.
-            Note that even if ``True``, if a default was specified it will be returned instead of a skip.
-        """
-        name = self._parser._opt2dest.get(name, name)
-        try:
-            val = getattr(self.option, name)
-            if val is None and skip:
-                raise AttributeError(name)
-            return val
-        except AttributeError as e:
-            if default is not NOTSET:
-                return default
-            if skip:
-                import pytest
-
-                pytest.skip(f"no {name!r} option found")
-            raise ValueError(f"no option named {name!r}") from e
-
-    def getvalue(self, name: str, path=None):
-        """Deprecated, use getoption() instead."""
-        return self.getoption(name)
-
-    def getvalueorskip(self, name: str, path=None):
-        """Deprecated, use getoption(skip=True) instead."""
-        return self.getoption(name, skip=True)
-
-    #: Verbosity type for failed assertions (see :confval:`verbosity_assertions`).
-    VERBOSITY_ASSERTIONS: Final = "assertions"
-    #: Verbosity type for test case execution (see :confval:`verbosity_test_cases`).
-    VERBOSITY_TEST_CASES: Final = "test_cases"
-    #: Verbosity type for failed subtests (see :confval:`verbosity_subtests`).
-    VERBOSITY_SUBTESTS: Final = "subtests"
-
-    _VERBOSITY_INI_DEFAULT: Final = "auto"
-
-    def get_verbosity(self, verbosity_type: str | None = None) -> int:
-        r"""Retrieve the verbosity level for a fine-grained verbosity type.
-
-        :param verbosity_type: Verbosity type to get level for. If a level is
-            configured for the given type, that value will be returned. If the
-            given type is not a known verbosity type, the global verbosity
-            level will be returned. If the given type is None (default), the
-            global verbosity level will be returned.
-
-        To configure a level for a fine-grained verbosity type, the
-        configuration file should have a setting for the configuration name
-        and a numeric value for the verbosity level. A special value of "auto"
-        can be used to explicitly use the global verbosity level.
-
-        Example:
-
-        .. tab:: toml
-
-            .. code-block:: toml
-
-                [tool.pytest]
-                verbosity_assertions = 2
-
-        .. tab:: ini
-
-            .. code-block:: ini
-
-                [pytest]
-                verbosity_assertions = 2
-
-        .. code-block:: console
-
-            pytest -v
-
-        .. code-block:: python
-
-            print(config.get_verbosity())  # 1
-            print(config.get_verbosity(Config.VERBOSITY_ASSERTIONS))  # 2
-        """
-        global_level = self.getoption("verbose", default=0)
-        assert isinstance(global_level, int)
-        if verbosity_type is None:
-            return global_level
-
-        ini_name = Config._verbosity_ini_name(verbosity_type)
-        if ini_name not in self._parser._inidict:
-            return global_level
-
-        level = self.getini(ini_name)
-        if level == Config._VERBOSITY_INI_DEFAULT:
-            return global_level
-
-        return int(level)
-
-    @staticmethod
-    def _verbosity_ini_name(verbosity_type: str) -> str:
-        return f"verbosity_{verbosity_type}"
-
-    @staticmethod
-    def _add_verbosity_ini(parser: Parser, verbosity_type: str, help: str) -> None:
-        """Add a output verbosity configuration option for the given output type.
-
-        :param parser: Parser for command line arguments and config-file values.
-        :param verbosity_type: Fine-grained verbosity category.
-        :param help: Description of the output this type controls.
-
-        The value should be retrieved via a call to
-        :py:func:`config.get_verbosity(type) <pytest.Config.get_verbosity>`.
-        """
-        parser.addini(
-            Config._verbosity_ini_name(verbosity_type),
-            help=help,
-            type="string",
-            default=Config._VERBOSITY_INI_DEFAULT,
-        )
-
-    def _warn_about_missing_assertion(self, mode: str) -> None:
-        if not _assertion_supported():
-            if mode == "plain":
-                warning_text = (
-                    "ASSERTIONS ARE NOT EXECUTED"
-                    " and FAILING TESTS WILL PASS.  Are you"
-                    " using python -O?"
-                )
-            else:
-                warning_text = (
-                    "assertions not in test modules or"
-                    " plugins will be ignored"
-                    " because assert statements are not executed "
-                    "by the underlying Python interpreter "
-                    "(are you using python -O?)\n"
-                )
-            self.issue_config_time_warning(
-                PytestConfigWarning(warning_text),
-                stacklevel=3,
-            )
-
-    def _warn_about_skipped_plugins(self) -> None:
-        for module_name, msg in self.pluginmanager.skipped_plugins:
-            self.issue_config_time_warning(
-                PytestConfigWarning(f"skipped plugin {module_name!r}: {msg}"),
-                stacklevel=2,
-            )
-
-
-def _assertion_supported() -> bool:
-    try:
-        assert False
-    except AssertionError:
-        return True
-    else:
-        return False  # type: ignore[unreachable]
-
-
-def create_terminal_writer(
-    config: Config, file: TextIO | None = None
-) -> TerminalWriter:
-    """Create a TerminalWriter instance configured according to the options
-    in the config object.
-
-    Every code which requires a TerminalWriter object and has access to a
-    config object should use this function.
-    """
-    tw = TerminalWriter(file=file)
-
-    if config.option.color == "yes":
-        tw.hasmarkup = True
-    elif config.option.color == "no":
-        tw.hasmarkup = False
-
-    if config.option.code_highlight == "yes":
-        tw.code_highlight = True
-    elif config.option.code_highlight == "no":
-        tw.code_highlight = False
-
-    return tw
-
-
-def _strtobool(val: str) -> bool:
-    """Convert a string representation of truth to True or False.
-
-    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
-    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
-    'val' is anything else.
-
-    .. note:: Copied from distutils.util.
-    """
-    val = val.lower()
-    if val in ("y", "yes", "t", "true", "on", "1"):
-        return True
-    elif val in ("n", "no", "f", "false", "off", "0"):
-        return False
-    else:
-        raise ValueError(f"invalid truth value {val!r}")
-
-
-@lru_cache(maxsize=50)
-def parse_warning_filter(
-    arg: str, *, escape: bool
-) -> tuple[warnings._ActionKind, str, type[Warning], str, int]:
-    """Parse a warnings filter string.
-
-    This is copied from warnings._setoption with the following changes:
-
-    * Does not apply the filter.
-    * Escaping is optional.
-    * Raises UsageError so we get nice error messages on failure.
-    """
-    __tracebackhide__ = True
-    error_template = dedent(
-        f"""\
-        while parsing the following warning configuration:
-
-          {arg}
-
-        This error occurred:
-
-        {{error}}
-        """
-    )
-
-    parts = arg.split(":")
-    if len(parts) > 5:
-        doc_url = (
-            "https://docs.python.org/3/library/warnings.html#describing-warning-filters"
-        )
-        error = dedent(
-            f"""\
-            Too many fields ({len(parts)}), expected at most 5 separated by colons:
-
-              action:message:category:module:line
-
-            For more information please consult: {doc_url}
-            """
-        )
-        raise UsageError(error_template.format(error=error))
-
-    while len(parts) < 5:
-        parts.append("")
-    action_, message, category_, module, lineno_ = (s.strip() for s in parts)
-    try:
-        action: warnings._ActionKind = warnings._getaction(action_)  # type: ignore[attr-defined]
-    except warnings._OptionError as e:
-        raise UsageError(error_template.format(error=str(e))) from None
-    try:
-        category: type[Warning] = _resolve_warning_category(category_)
-    except ImportError:
-        raise
-    except Exception:
-        exc_info = ExceptionInfo.from_current()
-        exception_text = exc_info.getrepr(style="native")
-        raise UsageError(error_template.format(error=exception_text)) from None
-    if message and escape:
-        message = re.escape(message)
-    if module and escape:
-        module = re.escape(module) + r"\Z"
-    if lineno_:
-        try:
-            lineno = int(lineno_)
-            if lineno < 0:
-                raise ValueError("number is negative")
-        except ValueError as e:
-            raise UsageError(
-                error_template.format(error=f"invalid lineno {lineno_!r}: {e}")
-            ) from None
-    else:
-        lineno = 0
-    try:
-        re.compile(message)
-        re.compile(module)
-    except re.error as e:
-        raise UsageError(
-            error_template.format(error=f"Invalid regex {e.pattern!r}: {e}")
-        ) from None
-    return action, message, category, module, lineno
-
-
-def _resolve_warning_category(category: str) -> type[Warning]:
-    """
-    Copied from warnings._getcategory, but changed so it lets exceptions (specially ImportErrors)
-    propagate so we can get access to their tracebacks (#9218).
-    """
-    __tracebackhide__ = True
-    if not category:
-        return Warning
-
-    if "." not in category:
-        import builtins as m
-
-        klass = category
-    else:
-        module, _, klass = category.rpartition(".")
-        m = importlib.import_module(module)
-    cat = getattr(m, klass)
-    if not issubclass(cat, Warning):
-        raise UsageError(f"{cat} is not a Warning subclass")
-    return cast(type[Warning], cat)
-
-
-def apply_warning_filters(
-    config_filters: Iterable[str], cmdline_filters: Iterable[str]
-) -> None:
-    """Applies pytest-configured filters to the warnings module"""
-    # Filters should have this precedence: cmdline options, config.
-    # Filters should be applied in the inverse order of precedence.
-    for arg in config_filters:
-        try:
-            warnings.filterwarnings(*parse_warning_filter(arg, escape=False))
-        except ImportError as e:
-            warnings.warn(
-                f"Failed to import filter module '{e.name}': {arg}", PytestConfigWarning
-            )
-            continue
-
-    for arg in cmdline_filters:
-        try:
-            warnings.filterwarnings(*parse_warning_filter(arg, escape=True))
-        except ImportError as e:
-            warnings.warn(
-                f"Failed to import filter module '{e.name}': {arg}", PytestConfigWarning
-            )
-            continue

venv/Lib/site-packages/_pytest/config/argparsing.py

@@ -1,503 +0,0 @@
-# mypy: allow-untyped-defs
-from __future__ import annotations
-
-import argparse
-from collections.abc import Callable
-from collections.abc import Sequence
-import os
-import sys
-import textwrap
-from typing import Any
-from typing import final
-from typing import Literal
-from typing import NoReturn
-
-from .exceptions import UsageError
-import _pytest._io
-from _pytest.compat import NOTSET
-from _pytest.deprecated import check_ispytest
-
-
-FILE_OR_DIR = "file_or_dir"
-
-
-@final
-class Parser:
-    """Parser for command line arguments and config-file values.
-
-    :ivar extra_info: Dict of generic param -> value to display in case
-        there's an error processing the command line arguments.
-    """
-
-    def __init__(
-        self,
-        usage: str | None = None,
-        processopt: Callable[[Argument], None] | None = None,
-        *,
-        prog: str | None = None,
-        _ispytest: bool = False,
-    ) -> None:
-        check_ispytest(_ispytest)
-
-        from _pytest._argcomplete import filescompleter
-
-        self._processopt = processopt
-        self.extra_info: dict[str, Any] = {}
-        self.optparser = PytestArgumentParser(usage, self.extra_info, prog=prog)
-        anonymous_arggroup = self.optparser.add_argument_group("Custom options")
-        self._anonymous = OptionGroup(
-            anonymous_arggroup, "_anonymous", self, _ispytest=True
-        )
-        self._groups = [self._anonymous]
-        # Maps option strings -> dest, e.g. "-V" and "--version" to "version".
-        self._opt2dest: dict[str, str] = {}
-        file_or_dir_arg = self.optparser.add_argument(FILE_OR_DIR, nargs="*")
-        file_or_dir_arg.completer = filescompleter  # type: ignore
-
-        self._inidict: dict[str, tuple[str, str, Any]] = {}
-        # Maps alias -> canonical name.
-        self._ini_aliases: dict[str, str] = {}
-
-    @property
-    def prog(self) -> str:
-        return self.optparser.prog
-
-    @prog.setter
-    def prog(self, value: str) -> None:
-        self.optparser.prog = value
-
-    def processoption(self, option: Argument) -> None:
-        if self._processopt:
-            if option.dest:
-                self._processopt(option)
-
-    def getgroup(
-        self, name: str, description: str = "", after: str | None = None
-    ) -> OptionGroup:
-        """Get (or create) a named option Group.
-
-        :param name: Name of the option group.
-        :param description: Long description for --help output.
-        :param after: Name of another group, used for ordering --help output.
-        :returns: The option group.
-
-        The returned group object has an ``addoption`` method with the same
-        signature as :func:`parser.addoption <pytest.Parser.addoption>` but
-        will be shown in the respective group in the output of
-        ``pytest --help``.
-        """
-        for group in self._groups:
-            if group.name == name:
-                return group
-
-        arggroup = self.optparser.add_argument_group(description or name)
-        group = OptionGroup(arggroup, name, self, _ispytest=True)
-        i = 0
-        for i, grp in enumerate(self._groups):
-            if grp.name == after:
-                break
-        self._groups.insert(i + 1, group)
-        # argparse doesn't provide a way to control `--help` order, so must
-        # access its internals ☹.
-        self.optparser._action_groups.insert(i + 1, self.optparser._action_groups.pop())
-        return group
-
-    def addoption(self, *opts: str, **attrs: Any) -> None:
-        """Register a command line option.
-
-        :param opts:
-            Option names, can be short or long options.
-        :param attrs:
-            Same attributes as the argparse library's :meth:`add_argument()
-            <argparse.ArgumentParser.add_argument>` function accepts.
-
-        After command line parsing, options are available on the pytest config
-        object via ``config.option.NAME`` where ``NAME`` is usually set
-        by passing a ``dest`` attribute, for example
-        ``addoption("--long", dest="NAME", ...)``.
-        """
-        self._anonymous.addoption(*opts, **attrs)
-
-    def parse(
-        self,
-        args: Sequence[str | os.PathLike[str]],
-        namespace: argparse.Namespace | None = None,
-    ) -> argparse.Namespace:
-        """Parse the arguments.
-
-        Unlike ``parse_known_args`` and ``parse_known_and_unknown_args``,
-        raises PrintHelp on `--help` and UsageError on unknown flags
-
-        :meta private:
-        """
-        from _pytest._argcomplete import try_argcomplete
-
-        try_argcomplete(self.optparser)
-        strargs = [os.fspath(x) for x in args]
-        if namespace is None:
-            namespace = argparse.Namespace()
-        try:
-            namespace._raise_print_help = True
-            return self.optparser.parse_intermixed_args(strargs, namespace=namespace)
-        finally:
-            del namespace._raise_print_help
-
-    def parse_known_args(
-        self,
-        args: Sequence[str | os.PathLike[str]],
-        namespace: argparse.Namespace | None = None,
-    ) -> argparse.Namespace:
-        """Parse the known arguments at this point.
-
-        :returns: An argparse namespace object.
-        """
-        return self.parse_known_and_unknown_args(args, namespace=namespace)[0]
-
-    def parse_known_and_unknown_args(
-        self,
-        args: Sequence[str | os.PathLike[str]],
-        namespace: argparse.Namespace | None = None,
-    ) -> tuple[argparse.Namespace, list[str]]:
-        """Parse the known arguments at this point, and also return the
-        remaining unknown flag arguments.
-
-        :returns:
-            A tuple containing an argparse namespace object for the known
-            arguments, and a list of unknown flag arguments.
-        """
-        strargs = [os.fspath(x) for x in args]
-        if sys.version_info < (3, 12, 8) or (3, 13) <= sys.version_info < (3, 13, 1):
-            # Older argparse have a bugged parse_known_intermixed_args.
-            namespace, unknown = self.optparser.parse_known_args(strargs, namespace)
-            assert namespace is not None
-            file_or_dir = getattr(namespace, FILE_OR_DIR)
-            unknown_flags: list[str] = []
-            for arg in unknown:
-                (unknown_flags if arg.startswith("-") else file_or_dir).append(arg)
-            return namespace, unknown_flags
-        else:
-            return self.optparser.parse_known_intermixed_args(strargs, namespace)
-
-    def addini(
-        self,
-        name: str,
-        help: str,
-        type: Literal[
-            "string", "paths", "pathlist", "args", "linelist", "bool", "int", "float"
-        ]
-        | None = None,
-        default: Any = NOTSET,
-        *,
-        aliases: Sequence[str] = (),
-    ) -> None:
-        """Register a configuration file option.
-
-        :param name:
-            Name of the configuration.
-        :param type:
-            Type of the configuration. Can be:
-
-                * ``string``: a string
-                * ``bool``: a boolean
-                * ``args``: a list of strings, separated as in a shell
-                * ``linelist``: a list of strings, separated by line breaks
-                * ``paths``: a list of :class:`pathlib.Path`, separated as in a shell
-                * ``pathlist``: a list of ``py.path``, separated as in a shell
-                * ``int``: an integer
-                * ``float``: a floating-point number
-
-                .. versionadded:: 8.4
-
-                    The ``float`` and ``int`` types.
-
-            For ``paths`` and ``pathlist`` types, they are considered relative to the config-file.
-            In case the execution is happening without a config-file defined,
-            they will be considered relative to the current working directory (for example with ``--override-ini``).
-
-            .. versionadded:: 7.0
-                The ``paths`` variable type.
-
-            .. versionadded:: 8.1
-                Use the current working directory to resolve ``paths`` and ``pathlist`` in the absence of a config-file.
-
-            Defaults to ``string`` if ``None`` or not passed.
-        :param default:
-            Default value if no config-file option exists but is queried.
-        :param aliases:
-            Additional names by which this option can be referenced.
-            Aliases resolve to the canonical name.
-
-            .. versionadded:: 9.0
-                The ``aliases`` parameter.
-
-        The value of configuration keys can be retrieved via a call to
-        :py:func:`config.getini(name) <pytest.Config.getini>`.
-        """
-        assert type in (
-            None,
-            "string",
-            "paths",
-            "pathlist",
-            "args",
-            "linelist",
-            "bool",
-            "int",
-            "float",
-        )
-        if type is None:
-            type = "string"
-        if default is NOTSET:
-            default = get_ini_default_for_type(type)
-
-        self._inidict[name] = (help, type, default)
-
-        for alias in aliases:
-            if alias in self._inidict:
-                raise ValueError(
-                    f"alias {alias!r} conflicts with existing configuration option"
-                )
-            if (already := self._ini_aliases.get(alias)) is not None:
-                raise ValueError(f"{alias!r} is already an alias of {already!r}")
-            self._ini_aliases[alias] = name
-
-
-def get_ini_default_for_type(
-    type: Literal[
-        "string", "paths", "pathlist", "args", "linelist", "bool", "int", "float"
-    ],
-) -> Any:
-    """
-    Used by addini to get the default value for a given config option type, when
-    default is not supplied.
-    """
-    if type in ("paths", "pathlist", "args", "linelist"):
-        return []
-    elif type == "bool":
-        return False
-    elif type == "int":
-        return 0
-    elif type == "float":
-        return 0.0
-    else:
-        return ""
-
-
-class Argument:
-    """An option defined in an OptionGroup."""
-
-    def __init__(self, action: argparse.Action) -> None:
-        self._action = action
-
-    def attrs(self) -> dict[str, Any]:
-        return self._action.__dict__
-
-    def names(self) -> Sequence[str]:
-        return self._action.option_strings
-
-    @property
-    def dest(self) -> str:
-        return self._action.dest
-
-    @property
-    def default(self) -> Any:
-        return self._action.default
-
-    @property
-    def type(self) -> Any | None:
-        return self._action.type
-
-    def __repr__(self) -> str:
-        action = getattr(self, "_action", None)
-        if action is None:
-            return "Argument(<uninitialized>)"
-        args: list[str] = []
-        args += ["opts: " + repr(self.names())]
-        args += ["dest: " + repr(self.dest)]
-        if action.type:
-            args += ["type: " + repr(self.type)]
-        args += ["default: " + repr(self.default)]
-        return "Argument({})".format(", ".join(args))
-
-
-class OptionGroup:
-    """A group of options shown in its own section."""
-
-    def __init__(
-        self,
-        arggroup: argparse._ArgumentGroup,
-        name: str,
-        parser: Parser | None,
-        _ispytest: bool = False,
-    ) -> None:
-        check_ispytest(_ispytest)
-        self._arggroup = arggroup
-        self.name = name
-        self.options: list[Argument] = []
-        self.parser = parser
-
-    def addoption(self, *opts: str, **attrs: Any) -> None:
-        """Add an option to this group.
-
-        If a shortened version of a long option is specified, it will
-        be suppressed in the help. ``addoption('--twowords', '--two-words')``
-        results in help showing ``--two-words`` only, but ``--twowords`` gets
-        accepted **and** the automatic destination is in ``args.twowords``.
-
-        :param opts:
-            Option names, can be short or long options.
-            Note that lower-case short options (e.g. `-x`) are reserved.
-        :param attrs:
-            Same attributes as the argparse library's :meth:`add_argument()
-            <argparse.ArgumentParser.add_argument>` function accepts.
-        """
-        conflict = set(opts).intersection(
-            name for opt in self.options for name in opt.names()
-        )
-        if conflict:
-            raise ValueError(f"option names {conflict} already added")
-        self._addoption_inner(opts, attrs, allow_reserved=False)
-
-    def _addoption(self, *opts: str, **attrs: Any) -> None:
-        """Like addoption(), but also allows registering short lower case options (e.g. -x),
-        which are reserved for pytest core."""
-        self._addoption_inner(opts, attrs, allow_reserved=True)
-
-    def _addoption_inner(
-        self, opts: tuple[str, ...], attrs: dict[str, Any], allow_reserved: bool
-    ) -> None:
-        if not allow_reserved:
-            for opt in opts:
-                if len(opt) >= 2 and opt[0] == "-" and opt[1].islower():
-                    raise ValueError("lowercase short options are reserved")
-
-        action = self._arggroup.add_argument(*opts, **attrs)
-        option = Argument(action)
-        self.options.append(option)
-        if self.parser:
-            for name in option.names():
-                self.parser._opt2dest[name] = option.dest
-            self.parser.processoption(option)
-
-
-class PytestArgumentParser(argparse.ArgumentParser):
-    def __init__(
-        self,
-        usage: str | None,
-        extra_info: dict[str, str],
-        *,
-        prog: str | None = None,
-    ) -> None:
-        super().__init__(
-            usage=usage,
-            prog=prog,
-            add_help=False,
-            formatter_class=DropShorterLongHelpFormatter,
-            allow_abbrev=False,
-            fromfile_prefix_chars="@",
-        )
-        # extra_info is a dict of (param -> value) to display if there's
-        # an usage error to provide more contextual information to the user.
-        self.extra_info = extra_info
-
-    def error(self, message: str) -> NoReturn:
-        """Transform argparse error message into UsageError."""
-        # TODO(py313): Replace with `exit_on_error=False`. Note that while it
-        # was added in Python 3.9, it was broken until 3.13 (cpython#121018).
-        msg = f"{self.prog}: error: {message}"
-        if self.extra_info:
-            msg += "\n" + "\n".join(
-                f"  {k}: {v}" for k, v in sorted(self.extra_info.items())
-            )
-        raise UsageError(self.format_usage() + msg)
-
-
-class DropShorterLongHelpFormatter(argparse.HelpFormatter):
-    """Shorten help for long options that differ only in extra hyphens.
-
-    - Collapse **long** options that are the same except for extra hyphens.
-    - Shortcut if there are only two options and one of them is a short one.
-    """
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        # Use more accurate terminal width.
-        if "width" not in kwargs:
-            kwargs["width"] = _pytest._io.get_terminal_width()
-        super().__init__(*args, **kwargs)
-
-    def _format_action_invocation(self, action: argparse.Action) -> str:
-        orgstr = super()._format_action_invocation(action)
-        if orgstr and orgstr[0] != "-":  # only optional arguments
-            return orgstr
-        options = orgstr.split(", ")
-        if len(options) == 2 and (len(options[0]) == 2 or len(options[1]) == 2):
-            # a shortcut for '-h, --help' or '--abc', '-a'
-            return orgstr
-        return_list = []
-        short_long: dict[str, str] = {}
-        for option in options:
-            if len(option) == 2 or option[2] == " ":
-                continue
-            assert option.startswith("--"), (
-                f'long optional argument without "--": [{option}]'
-            )
-            xxoption = option[2:]
-            shortened = xxoption.replace("-", "")
-            if shortened not in short_long or len(short_long[shortened]) < len(
-                xxoption
-            ):
-                short_long[shortened] = xxoption
-        # now short_long has been filled out to the longest with dashes
-        # **and** we keep the right option ordering from add_argument
-        for option in options:
-            if len(option) == 2 or option[2] == " ":
-                return_list.append(option)
-            if option[2:] == short_long.get(option.replace("-", "")):
-                return_list.append(option.replace(" ", "=", 1))
-        return ", ".join(return_list)
-
-    def _split_lines(self, text: str, width: int) -> list[str]:
-        """Wrap lines after splitting on original newlines.
-
-        This allows to have explicit line breaks in the help text.
-        """
-        lines = []
-        for line in text.splitlines():
-            lines.extend(textwrap.wrap(line.strip(), width))
-        return lines
-
-
-class OverrideIniAction(argparse.Action):
-    """Custom argparse action that makes a CLI flag equivalent to overriding an
-    option, in addition to behaving like `store_true`.
-
-    This can simplify things since code only needs to inspect the config option
-    and not consider the CLI flag.
-    """
-
-    def __init__(
-        self,
-        option_strings: Sequence[str],
-        dest: str,
-        nargs: int | str | None = None,
-        *args,
-        ini_option: str,
-        ini_value: str,
-        **kwargs,
-    ) -> None:
-        super().__init__(option_strings, dest, 0, *args, **kwargs)
-        self.ini_option = ini_option
-        self.ini_value = ini_value
-
-    def __call__(
-        self,
-        parser: argparse.ArgumentParser,
-        namespace: argparse.Namespace,
-        *args,
-        **kwargs,
-    ) -> None:
-        setattr(namespace, self.dest, True)
-        current_overrides = getattr(namespace, "override_ini", None)
-        if current_overrides is None:
-            current_overrides = []
-        current_overrides.append(f"{self.ini_option}={self.ini_value}")
-        setattr(namespace, "override_ini", current_overrides)

venv/Lib/site-packages/_pytest/config/exceptions.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-from typing import final
-
-
-@final
-class UsageError(Exception):
-    """Error in pytest usage or invocation."""
-
-    __module__ = "pytest"
-
-
-class PrintHelp(Exception):
-    """Raised when pytest should print its help to skip the rest of the
-    argument parsing and validation."""

venv/Lib/site-packages/_pytest/config/findpaths.py

@@ -1,350 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterable
-from collections.abc import Sequence
-from dataclasses import dataclass
-from dataclasses import KW_ONLY
-import os
-from pathlib import Path
-import sys
-from typing import Literal
-from typing import TypeAlias
-
-import iniconfig
-
-from .exceptions import UsageError
-from _pytest.outcomes import fail
-from _pytest.pathlib import absolutepath
-from _pytest.pathlib import commonpath
-from _pytest.pathlib import safe_exists
-
-
-@dataclass(frozen=True)
-class ConfigValue:
-    """Represents a configuration value with its origin and parsing mode.
-
-    This allows tracking whether a value came from a configuration file
-    or from a CLI override (--override-ini), which is important for
-    determining precedence when dealing with ini option aliases.
-
-    The mode tracks the parsing mode/data model used for the value:
-    - "ini": from INI files or [tool.pytest.ini_options], where the only
-      supported value types are `str` or `list[str]`.
-    - "toml": from TOML files (not in INI mode), where native TOML types
-       are preserved.
-    """
-
-    value: object
-    _: KW_ONLY
-    origin: Literal["file", "override"]
-    mode: Literal["ini", "toml"]
-
-
-ConfigDict: TypeAlias = dict[str, ConfigValue]
-
-
-def _parse_ini_config(path: Path) -> iniconfig.IniConfig:
-    """Parse the given generic '.ini' file using legacy IniConfig parser, returning
-    the parsed object.
-
-    Raise UsageError if the file cannot be parsed.
-    """
-    try:
-        return iniconfig.IniConfig(str(path))
-    except iniconfig.ParseError as exc:
-        raise UsageError(str(exc)) from exc
-
-
-def load_config_dict_from_file(
-    filepath: Path,
-) -> ConfigDict | None:
-    """Load pytest configuration from the given file path, if supported.
-
-    Return None if the file does not contain valid pytest configuration.
-    """
-    # Configuration from ini files are obtained from the [pytest] section, if present.
-    if filepath.suffix == ".ini":
-        iniconfig = _parse_ini_config(filepath)
-
-        if "pytest" in iniconfig:
-            return {
-                k: ConfigValue(v, origin="file", mode="ini")
-                for k, v in iniconfig["pytest"].items()
-            }
-        else:
-            # "pytest.ini" files are always the source of configuration, even if empty.
-            if filepath.name in {"pytest.ini", ".pytest.ini"}:
-                return {}
-
-    # '.cfg' files are considered if they contain a "[tool:pytest]" section.
-    elif filepath.suffix == ".cfg":
-        iniconfig = _parse_ini_config(filepath)
-
-        if "tool:pytest" in iniconfig.sections:
-            return {
-                k: ConfigValue(v, origin="file", mode="ini")
-                for k, v in iniconfig["tool:pytest"].items()
-            }
-        elif "pytest" in iniconfig.sections:
-            # If a setup.cfg contains a "[pytest]" section, we raise a failure to indicate users that
-            # plain "[pytest]" sections in setup.cfg files is no longer supported (#3086).
-            fail(CFG_PYTEST_SECTION.format(filename="setup.cfg"), pytrace=False)
-
-    # '.toml' files are considered if they contain a [tool.pytest] table (toml mode)
-    # or [tool.pytest.ini_options] table (ini mode) for pyproject.toml,
-    # or [pytest] table (toml mode) for pytest.toml/.pytest.toml.
-    elif filepath.suffix == ".toml":
-        if sys.version_info >= (3, 11):
-            import tomllib
-        else:
-            import tomli as tomllib
-
-        toml_text = filepath.read_text(encoding="utf-8")
-        try:
-            config = tomllib.loads(toml_text)
-        except tomllib.TOMLDecodeError as exc:
-            raise UsageError(f"{filepath}: {exc}") from exc
-
-        # pytest.toml and .pytest.toml use [pytest] table directly.
-        if filepath.name in ("pytest.toml", ".pytest.toml"):
-            pytest_config = config.get("pytest", {})
-            if pytest_config:
-                # TOML mode - preserve native TOML types.
-                return {
-                    k: ConfigValue(v, origin="file", mode="toml")
-                    for k, v in pytest_config.items()
-                }
-            # "pytest.toml" files are always the source of configuration, even if empty.
-            return {}
-
-        # pyproject.toml uses [tool.pytest] or [tool.pytest.ini_options].
-        else:
-            tool_pytest = config.get("tool", {}).get("pytest", {})
-
-            # Check for toml mode config: [tool.pytest] with content outside of ini_options.
-            toml_config = {k: v for k, v in tool_pytest.items() if k != "ini_options"}
-            # Check for ini mode config: [tool.pytest.ini_options].
-            ini_config = tool_pytest.get("ini_options", None)
-
-            if toml_config and ini_config:
-                raise UsageError(
-                    f"{filepath}: Cannot use both [tool.pytest] (native TOML types) and "
-                    "[tool.pytest.ini_options] (string-based INI format) simultaneously. "
-                    "Please use [tool.pytest] with native TOML types (recommended) "
-                    "or [tool.pytest.ini_options] for backwards compatibility."
-                )
-
-            if toml_config:
-                # TOML mode - preserve native TOML types.
-                return {
-                    k: ConfigValue(v, origin="file", mode="toml")
-                    for k, v in toml_config.items()
-                }
-
-            elif ini_config is not None:
-                # INI mode - TOML supports richer data types than INI files, but we need to
-                # convert all scalar values to str for compatibility with the INI system.
-                def make_scalar(v: object) -> str | list[str]:
-                    return v if isinstance(v, list) else str(v)
-
-                return {
-                    k: ConfigValue(make_scalar(v), origin="file", mode="ini")
-                    for k, v in ini_config.items()
-                }
-
-    return None
-
-
-def locate_config(
-    invocation_dir: Path,
-    args: Iterable[Path],
-) -> tuple[Path | None, Path | None, ConfigDict, Sequence[str]]:
-    """Search in the list of arguments for a valid ini-file for pytest,
-    and return a tuple of (rootdir, inifile, cfg-dict, ignored-config-files), where
-    ignored-config-files is a list of config basenames found that contain
-    pytest configuration but were ignored."""
-    config_names = [
-        "pytest.toml",
-        ".pytest.toml",
-        "pytest.ini",
-        ".pytest.ini",
-        "pyproject.toml",
-        "tox.ini",
-        "setup.cfg",
-    ]
-    args = [x for x in args if not str(x).startswith("-")]
-    if not args:
-        args = [invocation_dir]
-    found_pyproject_toml: Path | None = None
-    ignored_config_files: list[str] = []
-
-    for arg in args:
-        argpath = absolutepath(arg)
-        for base in (argpath, *argpath.parents):
-            for config_name in config_names:
-                p = base / config_name
-                if p.is_file():
-                    if p.name == "pyproject.toml" and found_pyproject_toml is None:
-                        found_pyproject_toml = p
-                    ini_config = load_config_dict_from_file(p)
-                    if ini_config is not None:
-                        index = config_names.index(config_name)
-                        for remainder in config_names[index + 1 :]:
-                            p2 = base / remainder
-                            if (
-                                p2.is_file()
-                                and load_config_dict_from_file(p2) is not None
-                            ):
-                                ignored_config_files.append(remainder)
-                        return base, p, ini_config, ignored_config_files
-    if found_pyproject_toml is not None:
-        return found_pyproject_toml.parent, found_pyproject_toml, {}, []
-    return None, None, {}, []
-
-
-def get_common_ancestor(
-    invocation_dir: Path,
-    paths: Iterable[Path],
-) -> Path:
-    common_ancestor: Path | None = None
-    for path in paths:
-        if not path.exists():
-            continue
-        if common_ancestor is None:
-            common_ancestor = path
-        else:
-            if common_ancestor in path.parents or path == common_ancestor:
-                continue
-            elif path in common_ancestor.parents:
-                common_ancestor = path
-            else:
-                shared = commonpath(path, common_ancestor)
-                if shared is not None:
-                    common_ancestor = shared
-    if common_ancestor is None:
-        common_ancestor = invocation_dir
-    elif common_ancestor.is_file():
-        common_ancestor = common_ancestor.parent
-    return common_ancestor
-
-
-def get_dirs_from_args(args: Iterable[str]) -> list[Path]:
-    def is_option(x: str) -> bool:
-        return x.startswith("-")
-
-    def get_file_part_from_node_id(x: str) -> str:
-        return x.split("::", maxsplit=1)[0]
-
-    def get_dir_from_path(path: Path) -> Path:
-        if path.is_dir():
-            return path
-        return path.parent
-
-    # These look like paths but may not exist
-    possible_paths = (
-        absolutepath(get_file_part_from_node_id(arg))
-        for arg in args
-        if not is_option(arg)
-    )
-
-    return [get_dir_from_path(path) for path in possible_paths if safe_exists(path)]
-
-
-def parse_override_ini(override_ini: Sequence[str] | None) -> ConfigDict:
-    """Parse the -o/--override-ini command line arguments and return the overrides.
-
-    :raises UsageError:
-        If one of the values is malformed.
-    """
-    overrides = {}
-    # override_ini is a list of "ini=value" options.
-    # Always use the last item if multiple values are set for same ini-name,
-    # e.g. -o foo=bar1 -o foo=bar2 will set foo to bar2.
-    for ini_config in override_ini or ():
-        try:
-            key, user_ini_value = ini_config.split("=", 1)
-        except ValueError as e:
-            raise UsageError(
-                f"-o/--override-ini expects option=value style (got: {ini_config!r})."
-            ) from e
-        else:
-            overrides[key] = ConfigValue(user_ini_value, origin="override", mode="ini")
-    return overrides
-
-
-CFG_PYTEST_SECTION = "[pytest] section in {filename} files is no longer supported, change to [tool:pytest] instead."
-
-
-def determine_setup(
-    *,
-    inifile: str | None,
-    override_ini: Sequence[str] | None,
-    args: Sequence[str],
-    rootdir_cmd_arg: str | None,
-    invocation_dir: Path,
-) -> tuple[Path, Path | None, ConfigDict, Sequence[str]]:
-    """Determine the rootdir, inifile and ini configuration values from the
-    command line arguments.
-
-    :param inifile:
-        The `--inifile` command line argument, if given.
-    :param override_ini:
-        The -o/--override-ini command line arguments, if given.
-    :param args:
-        The free command line arguments.
-    :param rootdir_cmd_arg:
-        The `--rootdir` command line argument, if given.
-    :param invocation_dir:
-        The working directory when pytest was invoked.
-
-    :raises UsageError:
-    """
-    rootdir = None
-    dirs = get_dirs_from_args(args)
-    ignored_config_files: Sequence[str] = []
-
-    if inifile:
-        inipath_ = absolutepath(inifile)
-        inipath: Path | None = inipath_
-        inicfg = load_config_dict_from_file(inipath_) or {}
-        if rootdir_cmd_arg is None:
-            rootdir = inipath_.parent
-    else:
-        ancestor = get_common_ancestor(invocation_dir, dirs)
-        rootdir, inipath, inicfg, ignored_config_files = locate_config(
-            invocation_dir, [ancestor]
-        )
-        if rootdir is None and rootdir_cmd_arg is None:
-            for possible_rootdir in (ancestor, *ancestor.parents):
-                if (possible_rootdir / "setup.py").is_file():
-                    rootdir = possible_rootdir
-                    break
-            else:
-                if dirs != [ancestor]:
-                    rootdir, inipath, inicfg, _ = locate_config(invocation_dir, dirs)
-                if rootdir is None:
-                    rootdir = get_common_ancestor(
-                        invocation_dir, [invocation_dir, ancestor]
-                    )
-                    if is_fs_root(rootdir):
-                        rootdir = ancestor
-    if rootdir_cmd_arg:
-        rootdir = absolutepath(os.path.expandvars(rootdir_cmd_arg))
-        if not rootdir.is_dir():
-            raise UsageError(
-                f"Directory '{rootdir}' not found. Check your '--rootdir' option."
-            )
-
-    ini_overrides = parse_override_ini(override_ini)
-    inicfg.update(ini_overrides)
-
-    assert rootdir is not None
-    return rootdir, inipath, inicfg, ignored_config_files
-
-
-def is_fs_root(p: Path) -> bool:
-    r"""
-    Return True if the given path is pointing to the root of the
-    file system ("/" on Unix and "C:\\" on Windows for example).
-    """
-    return os.path.splitdrive(str(p))[1] == os.sep

venv/Lib/site-packages/_pytest/debugging.py

@@ -1,404 +0,0 @@
-# mypy: allow-untyped-defs
-# ruff: noqa: T100
-"""Interactive debugging with PDB, the Python Debugger."""
-
-from __future__ import annotations
-
-import argparse
-from collections.abc import Callable
-from collections.abc import Generator
-import functools
-import importlib
-import sys
-import types
-from typing import Any
-
-from _pytest import outcomes
-from _pytest._code import ExceptionInfo
-from _pytest.capture import CaptureManager
-from _pytest.config import Config
-from _pytest.config import ConftestImportFailure
-from _pytest.config import hookimpl
-from _pytest.config import PytestPluginManager
-from _pytest.config.argparsing import Parser
-from _pytest.config.exceptions import UsageError
-from _pytest.nodes import Node
-from _pytest.reports import BaseReport
-from _pytest.runner import CallInfo
-
-
-def _validate_usepdb_cls(value: str) -> tuple[str, str]:
-    """Validate syntax of --pdbcls option."""
-    try:
-        modname, classname = value.split(":")
-    except ValueError as e:
-        raise argparse.ArgumentTypeError(
-            f"{value!r} is not in the format 'modname:classname'"
-        ) from e
-    return (modname, classname)
-
-
-def pytest_addoption(parser: Parser) -> None:
-    group = parser.getgroup("general")
-    group.addoption(
-        "--pdb",
-        dest="usepdb",
-        action="store_true",
-        help="Start the interactive Python debugger on errors or KeyboardInterrupt",
-    )
-    group.addoption(
-        "--pdbcls",
-        dest="usepdb_cls",
-        metavar="modulename:classname",
-        type=_validate_usepdb_cls,
-        help="Specify a custom interactive Python debugger for use with --pdb."
-        "For example: --pdbcls=IPython.terminal.debugger:TerminalPdb",
-    )
-    group.addoption(
-        "--trace",
-        dest="trace",
-        action="store_true",
-        help="Immediately break when running each test",
-    )
-
-
-def pytest_configure(config: Config) -> None:
-    import pdb
-
-    if config.getvalue("trace"):
-        config.pluginmanager.register(PdbTrace(), "pdbtrace")
-    if config.getvalue("usepdb"):
-        config.pluginmanager.register(PdbInvoke(), "pdbinvoke")
-
-    pytestPDB._saved.append(
-        (pdb.set_trace, pytestPDB._pluginmanager, pytestPDB._config)
-    )
-    pdb.set_trace = pytestPDB.set_trace
-    pytestPDB._pluginmanager = config.pluginmanager
-    pytestPDB._config = config
-
-    # NOTE: not using pytest_unconfigure, since it might get called although
-    #       pytest_configure was not (if another plugin raises UsageError).
-    def fin() -> None:
-        (
-            pdb.set_trace,
-            pytestPDB._pluginmanager,
-            pytestPDB._config,
-        ) = pytestPDB._saved.pop()
-
-    config.add_cleanup(fin)
-
-
-class pytestPDB:
-    """Pseudo PDB that defers to the real pdb."""
-
-    _pluginmanager: PytestPluginManager | None = None
-    _config: Config | None = None
-    _saved: list[
-        tuple[Callable[..., None], PytestPluginManager | None, Config | None]
-    ] = []
-    _recursive_debug = 0
-    _wrapped_pdb_cls: tuple[type[Any], type[Any]] | None = None
-
-    @classmethod
-    def _is_capturing(cls, capman: CaptureManager | None) -> str | bool:
-        if capman:
-            return capman.is_capturing()
-        return False
-
-    @classmethod
-    def _import_pdb_cls(cls, capman: CaptureManager | None):
-        if not cls._config:
-            import pdb
-
-            # Happens when using pytest.set_trace outside of a test.
-            return pdb.Pdb
-
-        usepdb_cls = cls._config.getvalue("usepdb_cls")
-
-        if cls._wrapped_pdb_cls and cls._wrapped_pdb_cls[0] == usepdb_cls:
-            return cls._wrapped_pdb_cls[1]
-
-        if usepdb_cls:
-            modname, classname = usepdb_cls
-
-            try:
-                mod = importlib.import_module(modname)
-
-                # Handle --pdbcls=pdb:pdb.Pdb (useful e.g. with pdbpp).
-                parts = classname.split(".")
-                pdb_cls = getattr(mod, parts[0])
-                for part in parts[1:]:
-                    pdb_cls = getattr(pdb_cls, part)
-            except Exception as exc:
-                value = ":".join((modname, classname))
-                raise UsageError(
-                    f"--pdbcls: could not import {value!r}: {exc}"
-                ) from exc
-        else:
-            import pdb
-
-            pdb_cls = pdb.Pdb
-
-        wrapped_cls = cls._get_pdb_wrapper_class(pdb_cls, capman)
-        cls._wrapped_pdb_cls = (usepdb_cls, wrapped_cls)
-        return wrapped_cls
-
-    @classmethod
-    def _get_pdb_wrapper_class(cls, pdb_cls, capman: CaptureManager | None):
-        import _pytest.config
-
-        class PytestPdbWrapper(pdb_cls):
-            _pytest_capman = capman
-            _continued = False
-
-            def do_debug(self, arg):
-                cls._recursive_debug += 1
-                ret = super().do_debug(arg)
-                cls._recursive_debug -= 1
-                return ret
-
-            if hasattr(pdb_cls, "do_debug"):
-                do_debug.__doc__ = pdb_cls.do_debug.__doc__
-
-            def do_continue(self, arg):
-                ret = super().do_continue(arg)
-                if cls._recursive_debug == 0:
-                    assert cls._config is not None
-                    tw = _pytest.config.create_terminal_writer(cls._config)
-                    tw.line()
-
-                    capman = self._pytest_capman
-                    capturing = pytestPDB._is_capturing(capman)
-                    if capturing:
-                        if capturing == "global":
-                            tw.sep(">", "PDB continue (IO-capturing resumed)")
-                        else:
-                            tw.sep(
-                                ">",
-                                f"PDB continue (IO-capturing resumed for {capturing})",
-                            )
-                        assert capman is not None
-                        capman.resume()
-                    else:
-                        tw.sep(">", "PDB continue")
-                assert cls._pluginmanager is not None
-                cls._pluginmanager.hook.pytest_leave_pdb(config=cls._config, pdb=self)
-                self._continued = True
-                return ret
-
-            if hasattr(pdb_cls, "do_continue"):
-                do_continue.__doc__ = pdb_cls.do_continue.__doc__
-
-            do_c = do_cont = do_continue
-
-            def do_quit(self, arg):
-                # Raise Exit outcome when quit command is used in pdb.
-                #
-                # This is a bit of a hack - it would be better if BdbQuit
-                # could be handled, but this would require to wrap the
-                # whole pytest run, and adjust the report etc.
-                ret = super().do_quit(arg)
-
-                if cls._recursive_debug == 0:
-                    outcomes.exit("Quitting debugger")
-
-                return ret
-
-            if hasattr(pdb_cls, "do_quit"):
-                do_quit.__doc__ = pdb_cls.do_quit.__doc__
-
-            do_q = do_quit
-            do_exit = do_quit
-
-            def setup(self, f, tb):
-                """Suspend on setup().
-
-                Needed after do_continue resumed, and entering another
-                breakpoint again.
-                """
-                ret = super().setup(f, tb)
-                if not ret and self._continued:
-                    # pdb.setup() returns True if the command wants to exit
-                    # from the interaction: do not suspend capturing then.
-                    if self._pytest_capman:
-                        self._pytest_capman.suspend_global_capture(in_=True)
-                return ret
-
-            def get_stack(self, f, t):
-                stack, i = super().get_stack(f, t)
-                if f is None:
-                    # Find last non-hidden frame.
-                    i = max(0, len(stack) - 1)
-                    while i and stack[i][0].f_locals.get("__tracebackhide__", False):
-                        i -= 1
-                return stack, i
-
-        return PytestPdbWrapper
-
-    @classmethod
-    def _init_pdb(cls, method, *args, **kwargs):
-        """Initialize PDB debugging, dropping any IO capturing."""
-        import _pytest.config
-
-        if cls._pluginmanager is None:
-            capman: CaptureManager | None = None
-        else:
-            capman = cls._pluginmanager.getplugin("capturemanager")
-        if capman:
-            capman.suspend(in_=True)
-
-        if cls._config:
-            tw = _pytest.config.create_terminal_writer(cls._config)
-            tw.line()
-
-            if cls._recursive_debug == 0:
-                # Handle header similar to pdb.set_trace in py37+.
-                header = kwargs.pop("header", None)
-                if header is not None:
-                    tw.sep(">", header)
-                else:
-                    capturing = cls._is_capturing(capman)
-                    if capturing == "global":
-                        tw.sep(">", f"PDB {method} (IO-capturing turned off)")
-                    elif capturing:
-                        tw.sep(
-                            ">",
-                            f"PDB {method} (IO-capturing turned off for {capturing})",
-                        )
-                    else:
-                        tw.sep(">", f"PDB {method}")
-
-        _pdb = cls._import_pdb_cls(capman)(**kwargs)
-
-        if cls._pluginmanager:
-            cls._pluginmanager.hook.pytest_enter_pdb(config=cls._config, pdb=_pdb)
-        return _pdb
-
-    @classmethod
-    def set_trace(cls, *args, **kwargs) -> None:
-        """Invoke debugging via ``Pdb.set_trace``, dropping any IO capturing."""
-        frame = sys._getframe().f_back
-        _pdb = cls._init_pdb("set_trace", *args, **kwargs)
-        _pdb.set_trace(frame)
-
-
-class PdbInvoke:
-    def pytest_exception_interact(
-        self, node: Node, call: CallInfo[Any], report: BaseReport
-    ) -> None:
-        capman = node.config.pluginmanager.getplugin("capturemanager")
-        if capman:
-            capman.suspend_global_capture(in_=True)
-            out, err = capman.read_global_capture()
-            sys.stdout.write(out)
-            sys.stdout.write(err)
-        assert call.excinfo is not None
-        _enter_pdb(node, call.excinfo, report)
-
-    def pytest_internalerror(self, excinfo: ExceptionInfo[BaseException]) -> None:
-        exc_or_tb = _postmortem_exc_or_tb(excinfo)
-        post_mortem(exc_or_tb)
-
-
-class PdbTrace:
-    @hookimpl(wrapper=True)
-    def pytest_pyfunc_call(self, pyfuncitem) -> Generator[None, object, object]:
-        wrap_pytest_function_for_tracing(pyfuncitem)
-        return (yield)
-
-
-def wrap_pytest_function_for_tracing(pyfuncitem) -> None:
-    """Change the Python function object of the given Function item by a
-    wrapper which actually enters pdb before calling the python function
-    itself, effectively leaving the user in the pdb prompt in the first
-    statement of the function."""
-    _pdb = pytestPDB._init_pdb("runcall")
-    testfunction = pyfuncitem.obj
-
-    # we can't just return `partial(pdb.runcall, testfunction)` because (on
-    # python < 3.7.4) runcall's first param is `func`, which means we'd get
-    # an exception if one of the kwargs to testfunction was called `func`.
-    @functools.wraps(testfunction)
-    def wrapper(*args, **kwargs) -> None:
-        func = functools.partial(testfunction, *args, **kwargs)
-        _pdb.runcall(func)
-
-    pyfuncitem.obj = wrapper
-
-
-def maybe_wrap_pytest_function_for_tracing(pyfuncitem) -> None:
-    """Wrap the given pytestfunct item for tracing support if --trace was given in
-    the command line."""
-    if pyfuncitem.config.getvalue("trace"):
-        wrap_pytest_function_for_tracing(pyfuncitem)
-
-
-def _enter_pdb(
-    node: Node, excinfo: ExceptionInfo[BaseException], rep: BaseReport
-) -> BaseReport:
-    # XXX we reuse the TerminalReporter's terminalwriter
-    # because this seems to avoid some encoding related troubles
-    # for not completely clear reasons.
-    tw = node.config.pluginmanager.getplugin("terminalreporter")._tw
-    tw.line()
-
-    showcapture = node.config.option.showcapture
-
-    for sectionname, content in (
-        ("stdout", rep.capstdout),
-        ("stderr", rep.capstderr),
-        ("log", rep.caplog),
-    ):
-        if showcapture in (sectionname, "all") and content:
-            tw.sep(">", "captured " + sectionname)
-            if content[-1:] == "\n":
-                content = content[:-1]
-            tw.line(content)
-
-    tw.sep(">", "traceback")
-    rep.toterminal(tw)
-    tw.sep(">", "entering PDB")
-    tb_or_exc = _postmortem_exc_or_tb(excinfo)
-    rep._pdbshown = True  # type: ignore[attr-defined]
-    post_mortem(tb_or_exc)
-    return rep
-
-
-def _postmortem_exc_or_tb(
-    excinfo: ExceptionInfo[BaseException],
-) -> types.TracebackType | BaseException:
-    from doctest import UnexpectedException
-
-    get_exc = sys.version_info >= (3, 13)
-    if isinstance(excinfo.value, UnexpectedException):
-        # A doctest.UnexpectedException is not useful for post_mortem.
-        # Use the underlying exception instead:
-        underlying_exc = excinfo.value
-        if get_exc:
-            return underlying_exc.exc_info[1]
-
-        return underlying_exc.exc_info[2]
-    elif isinstance(excinfo.value, ConftestImportFailure):
-        # A config.ConftestImportFailure is not useful for post_mortem.
-        # Use the underlying exception instead:
-        cause = excinfo.value.cause
-        if get_exc:
-            return cause
-
-        assert cause.__traceback__ is not None
-        return cause.__traceback__
-    else:
-        assert excinfo._excinfo is not None
-        if get_exc:
-            return excinfo._excinfo[1]
-
-        return excinfo._excinfo[2]
-
-
-def post_mortem(tb_or_exc: types.TracebackType | BaseException) -> None:
-    p = pytestPDB._init_pdb("post_mortem")
-    p.reset()
-    p.interaction(None, tb_or_exc)
-    if p.quitting:
-        outcomes.exit("Quitting debugger")

venv/Lib/site-packages/_pytest/deprecated.py

@@ -1,139 +0,0 @@
-"""Deprecation messages and bits of code used elsewhere in the codebase that
-is planned to be removed in the next pytest release.
-
-Keeping it in a central location makes it easy to track what is deprecated and should
-be removed when the time comes.
-
-All constants defined in this module should be either instances of
-:class:`PytestWarning`, or :class:`UnformattedWarning`
-in case of warnings which need to format their messages.
-"""
-
-from __future__ import annotations
-
-from warnings import warn
-
-from _pytest.warning_types import PytestDeprecationWarning
-from _pytest.warning_types import PytestRemovedIn10Warning
-from _pytest.warning_types import UnformattedWarning
-
-
-# set of plugins which have been integrated into the core; we use this list to ignore
-# them during registration to avoid conflicts
-DEPRECATED_EXTERNAL_PLUGINS = {
-    "pytest_catchlog",
-    "pytest_capturelog",
-    "pytest_faulthandler",
-    "pytest_subtests",
-}
-
-
-# This could have been removed pytest 8, but it's harmless and common, so no rush to remove.
-YIELD_FIXTURE = PytestDeprecationWarning(
-    "@pytest.yield_fixture is deprecated.\n"
-    "Use @pytest.fixture instead; they are the same."
-)
-
-CLASS_FIXTURE_INSTANCE_METHOD = PytestRemovedIn10Warning(
-    "Class-scoped fixture defined as instance method is deprecated.\n"
-    "Instance attributes set in this fixture will NOT be visible to test methods,\n"
-    "as each test gets a new instance while the fixture runs only once per class.\n"
-    "Use @classmethod decorator and set attributes on cls instead.\n"
-    "See https://docs.pytest.org/en/stable/deprecations.html#class-scoped-fixture-as-instance-method"
-)
-
-# This deprecation is never really meant to be removed.
-PRIVATE = PytestDeprecationWarning("A private pytest class or function was used.")
-
-
-HOOK_LEGACY_MARKING = UnformattedWarning(
-    PytestRemovedIn10Warning,
-    "The hook{type} {fullname} uses old-style configuration options (marks or attributes).\n"
-    "Please use the pytest.hook{type}({hook_opts}) decorator instead\n"
-    " to configure the hooks.\n"
-    " See https://docs.pytest.org/en/latest/deprecations.html"
-    "#configuring-hook-specs-impls-using-markers",
-)
-
-MONKEYPATCH_LEGACY_NAMESPACE_PACKAGES = PytestRemovedIn10Warning(
-    "monkeypatch.syspath_prepend() called with pkg_resources legacy namespace packages detected.\n"
-    "Legacy namespace packages (using pkg_resources.declare_namespace) are deprecated.\n"
-    "Please use native namespace packages (PEP 420) instead.\n"
-    "See https://docs.pytest.org/en/stable/deprecations.html#monkeypatch-fixup-namespace-packages"
-)
-
-PARAMETRIZE_NON_COLLECTION_ITERABLE = UnformattedWarning(
-    PytestRemovedIn10Warning,
-    "Passing a non-Collection iterable to parametrize is deprecated.\n"
-    "Test: {nodeid}, argvalues type: {type_name}\n"
-    "Please convert to a list or tuple.\n"
-    "See https://docs.pytest.org/en/stable/deprecations.html#parametrize-iterators",
-)
-
-CONSOLE_MAIN = PytestRemovedIn10Warning(
-    "pytest.console_main() is deprecated and will be removed in pytest 10.\n"
-    "It was never intended for programmatic use; use pytest.main() instead.\n"
-    "See https://docs.pytest.org/en/stable/deprecations.html#console-main"
-)
-
-CONFIG_INICFG = PytestRemovedIn10Warning(
-    "config.inicfg is deprecated, use config.getini() to access configuration values instead.\n"
-    "See https://docs.pytest.org/en/stable/deprecations.html#config-inicfg"
-)
-
-FIXTURE_GETFIXTUREVALUE_DURING_TEARDOWN = UnformattedWarning(
-    PytestRemovedIn10Warning,
-    'Calling request.getfixturevalue("{argname}") during teardown is deprecated.\n'
-    "Please request the fixture before teardown begins, either by declaring it in the fixture signature "
-    "or by calling request.getfixturevalue() before the fixture yields.\n"
-    "See https://docs.pytest.org/en/stable/deprecations.html#dynamic-fixture-request-during-teardown",
-)
-
-PASTEBIN = PytestRemovedIn10Warning(
-    "The --pastebin option is deprecated. "
-    "The functionality is now available in an external plugin package, pytest-pastebin.\n"
-    "See https://docs.pytest.org/en/stable/deprecations.html#the-pastebin-option"
-)
-
-# You want to make some `__init__` or function "private".
-#
-#   def my_private_function(some, args):
-#       ...
-#
-# Do this:
-#
-#   def my_private_function(some, args, *, _ispytest: bool = False):
-#       check_ispytest(_ispytest)
-#       ...
-#
-# Change all internal/allowed calls to
-#
-#   my_private_function(some, args, _ispytest=True)
-#
-# All other calls will get the default _ispytest=False and trigger
-# the warning (possibly error in the future).
-
-
-FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
-    "Passing baseid to FixtureDef is deprecated. Pass node instead for fixture scoping."
-)
-
-FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
-    "Passing nodeid to _register_fixture is deprecated. "
-    "Pass node instead for fixture scoping."
-)
-
-FIXTUREDEF_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
-    "FixtureDef.has_location is deprecated and will be removed in pytest 10. "
-    "See https://docs.pytest.org/en/stable/deprecations.html#fixturedef-has-location-deprecated"
-)
-
-PARSEFACTORIES_NODEID_DEPRECATED = PytestRemovedIn10Warning(
-    "Passing nodeid string to parsefactories is deprecated. "
-    "Use parsefactories(holder=obj, node=node) instead."
-)
-
-
-def check_ispytest(ispytest: bool) -> None:
-    if not ispytest:
-        warn(PRIVATE, stacklevel=3)