remove venv/cache junk from failed first upload

.pytest_cache/.gitignore

@@ -1,2 +0,0 @@
-# Created by pytest automatically.
-*

.pytest_cache/CACHEDIR.TAG

@@ -1,4 +0,0 @@
-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

.pytest_cache/README.md

@@ -1,8 +0,0 @@
-# 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.

.pytest_cache/v/cache/lastfailed

@@ -1 +0,0 @@
-{}

.pytest_cache/v/cache/nodeids

@@ -1,71 +0,0 @@
-[
-  "tests/test_decision.py::test_accuracy_vs_coverage_monotone",
-  "tests/test_decision.py::test_bucket_abstention_curve",
-  "tests/test_decision.py::test_bucket_for",
-  "tests/test_decision.py::test_conflict_attenuated",
-  "tests/test_decision.py::test_majority_outweighs_minority",
-  "tests/test_decision.py::test_unanimous_high_vote",
-  "tests/test_decision.py::test_unanimous_low_abstains",
-  "tests/test_decision.py::test_unknown_bucket_abstains_above_zero_threshold",
-  "tests/test_decision.py::test_weighted_tally",
-  "tests/test_dpo_lfm2.py::test_apo_term_rewards_absolute_gap",
-  "tests/test_dpo_lfm2.py::test_margin_increases_loss_for_close_pairs",
-  "tests/test_dpo_lfm2.py::test_plain_dpo_special_case",
-  "tests/test_dpo_lr_schedule.py::test_constant_schedule_keeps_lr",
-  "tests/test_dpo_lr_schedule.py::test_cosine_warmup_then_decay",
-  "tests/test_dpo_lr_schedule.py::test_warmup_frac_scales",
-  "tests/test_eval_summary.py::test_scored_ids_whole_file",
-  "tests/test_eval_summary.py::test_summarize_dedupes_resume_sections",
-  "tests/test_eval_summary.py::test_summarize_exact",
-  "tests/test_guardrails.py::test_clean_research_input_passes",
-  "tests/test_guardrails.py::test_instruction_override_flagged",
-  "tests/test_guardrails.py::test_offtopic_flagged",
-  "tests/test_guardrails.py::test_output_abstain_mismatch_flagged",
-  "tests/test_guardrails.py::test_output_clean_passes",
-  "tests/test_guardrails.py::test_output_valid_missing_confidence_flagged",
-  "tests/test_guardrails.py::test_pii_redacted",
-  "tests/test_guardrails.py::test_roleplay_extraction_flagged",
-  "tests/test_helix_memory.py::test_helix_forget_and_stats",
-  "tests/test_helix_memory.py::test_helix_recall_bridges_cases_and_keeps_receipts",
-  "tests/test_journalism.py::test_casefile_roundtrip",
-  "tests/test_journalism.py::test_editorial_review_clean",
-  "tests/test_journalism.py::test_editorial_review_flags",
-  "tests/test_journalism.py::test_entitygraph_edges_and_centrality",
-  "tests/test_journalism.py::test_framing_omissions",
-  "tests/test_journalism.py::test_framing_passive_loaded_hedges",
-  "tests/test_journalism.py::test_patterns_shared_rungs_and_themes",
-  "tests/test_journalism.py::test_provenance_chain_and_single_source",
-  "tests/test_journalism.py::test_provenance_credibility_tiers",
-  "tests/test_journalism.py::test_source_policy_rejects_untraceable_or_duplicate_leads",
-  "tests/test_journalism.py::test_source_policy_requires_independent_traceable_corroboration",
-  "tests/test_journalism.py::test_suite_report_end_to_end",
-  "tests/test_journalism.py::test_suite_report_fails_closed_without_source_policy_metadata",
-  "tests/test_journalism.py::test_timeline_anachronism",
-  "tests/test_journalism.py::test_timeline_gaps_and_cliffs",
-  "tests/test_lora_fold.py::test_fold_preserves_bias",
-  "tests/test_merges.py::test_soup_taskarith_intersect_keys",
-  "tests/test_merges.py::test_ties_merge_ignores_missing_task_keys",
-  "tests/test_merges.py::test_trim_delta_preserves_top_fraction_shape",
-  "tests/test_mtp.py::test_forward_mtp_shapes",
-  "tests/test_mtp.py::test_mtp_checkpoint_roundtrip",
-  "tests/test_mtp.py::test_mtp_loss_backward",
-  "tests/test_mtp.py::test_train_lm_mtp_smoke",
-  "tests/test_posttrain.py::test_rlvr_card_trace",
-  "tests/test_posttrain.py::test_rlvr_reward_abstain_is_zero",
-  "tests/test_posttrain.py::test_rlvr_reward_correct_with_citation",
-  "tests/test_posttrain.py::test_rlvr_reward_false_citation_penalty",
-  "tests/test_posttrain.py::test_rlvr_reward_wrong_verdict",
-  "tests/test_posttrain.py::test_ties_sign_consensus",
-  "tests/test_posttrain.py::test_trim_keeps_topk",
-  "tests/test_verify_loop.py::test_plan_checks_extracts_values",
-  "tests/test_verify_loop.py::test_run_checks_no_evidence",
-  "tests/test_verify_loop.py::test_run_checks_refutes",
-  "tests/test_verify_loop.py::test_run_checks_supports",
-  "tests/test_verify_loop.py::test_strict_policy_fails_closed_on_a_single_untraceable_lead",
-  "tests/test_verify_loop.py::test_strict_policy_overrides_an_incorrect_model_draft",
-  "tests/test_verify_loop.py::test_verify_case_defaults_to_fail_closed_source_policy",
-  "tests/test_verify_loop.py::test_verify_case_rule_refuted_wins",
-  "tests/test_verify_loop.py::test_verify_case_rule_verified",
-  "tests/test_verify_loop.py::test_verify_case_unresolved_downgrades_high",
-  "tests/test_verify_loop.py::test_verify_case_unresolved_keeps_low"
-]

.venv/bin/Activate.ps1

@@ -1,247 +0,0 @@
-<#
-.Synopsis
-Activate a Python virtual environment for the current PowerShell session.
-
-.Description
-Pushes the python executable for a virtual environment to the front of the
-$Env:PATH environment variable and sets the prompt to signify that you are
-in a Python virtual environment. Makes use of the command line switches as
-well as the `pyvenv.cfg` file values present in the virtual environment.
-
-.Parameter VenvDir
-Path to the directory that contains the virtual environment to activate. The
-default value for this is the parent of the directory that the Activate.ps1
-script is located within.
-
-.Parameter Prompt
-The prompt prefix to display when this virtual environment is activated. By
-default, this prompt is the name of the virtual environment folder (VenvDir)
-surrounded by parentheses and followed by a single space (ie. '(.venv) ').
-
-.Example
-Activate.ps1
-Activates the Python virtual environment that contains the Activate.ps1 script.
-
-.Example
-Activate.ps1 -Verbose
-Activates the Python virtual environment that contains the Activate.ps1 script,
-and shows extra information about the activation as it executes.
-
-.Example
-Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
-Activates the Python virtual environment located in the specified location.
-
-.Example
-Activate.ps1 -Prompt "MyPython"
-Activates the Python virtual environment that contains the Activate.ps1 script,
-and prefixes the current prompt with the specified string (surrounded in
-parentheses) while the virtual environment is active.
-
-.Notes
-On Windows, it may be required to enable this Activate.ps1 script by setting the
-execution policy for the user. You can do this by issuing the following PowerShell
-command:
-
-PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
-
-For more information on Execution Policies: 
-https://go.microsoft.com/fwlink/?LinkID=135170
-
-#>
-Param(
-    [Parameter(Mandatory = $false)]
-    [String]
-    $VenvDir,
-    [Parameter(Mandatory = $false)]
-    [String]
-    $Prompt
-)
-
-<# Function declarations --------------------------------------------------- #>
-
-<#
-.Synopsis
-Remove all shell session elements added by the Activate script, including the
-addition of the virtual environment's Python executable from the beginning of
-the PATH variable.
-
-.Parameter NonDestructive
-If present, do not remove this function from the global namespace for the
-session.
-
-#>
-function global:deactivate ([switch]$NonDestructive) {
-    # Revert to original values
-
-    # The prior prompt:
-    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
-        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
-        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
-    }
-
-    # The prior PYTHONHOME:
-    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
-        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
-        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
-    }
-
-    # The prior PATH:
-    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
-        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
-        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
-    }
-
-    # Just remove the VIRTUAL_ENV altogether:
-    if (Test-Path -Path Env:VIRTUAL_ENV) {
-        Remove-Item -Path env:VIRTUAL_ENV
-    }
-
-    # Just remove VIRTUAL_ENV_PROMPT altogether.
-    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
-        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
-    }
-
-    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
-    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
-        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
-    }
-
-    # Leave deactivate function in the global namespace if requested:
-    if (-not $NonDestructive) {
-        Remove-Item -Path function:deactivate
-    }
-}
-
-<#
-.Description
-Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
-given folder, and returns them in a map.
-
-For each line in the pyvenv.cfg file, if that line can be parsed into exactly
-two strings separated by `=` (with any amount of whitespace surrounding the =)
-then it is considered a `key = value` line. The left hand string is the key,
-the right hand is the value.
-
-If the value starts with a `'` or a `"` then the first and last character is
-stripped from the value before being captured.
-
-.Parameter ConfigDir
-Path to the directory that contains the `pyvenv.cfg` file.
-#>
-function Get-PyVenvConfig(
-    [String]
-    $ConfigDir
-) {
-    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
-
-    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
-    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
-
-    # An empty map will be returned if no config file is found.
-    $pyvenvConfig = @{ }
-
-    if ($pyvenvConfigPath) {
-
-        Write-Verbose "File exists, parse `key = value` lines"
-        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
-
-        $pyvenvConfigContent | ForEach-Object {
-            $keyval = $PSItem -split "\s*=\s*", 2
-            if ($keyval[0] -and $keyval[1]) {
-                $val = $keyval[1]
-
-                # Remove extraneous quotations around a string value.
-                if ("'""".Contains($val.Substring(0, 1))) {
-                    $val = $val.Substring(1, $val.Length - 2)
-                }
-
-                $pyvenvConfig[$keyval[0]] = $val
-                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
-            }
-        }
-    }
-    return $pyvenvConfig
-}
-
-
-<# Begin Activate script --------------------------------------------------- #>
-
-# Determine the containing directory of this script
-$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
-$VenvExecDir = Get-Item -Path $VenvExecPath
-
-Write-Verbose "Activation script is located in path: '$VenvExecPath'"
-Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
-Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
-
-# Set values required in priority: CmdLine, ConfigFile, Default
-# First, get the location of the virtual environment, it might not be
-# VenvExecDir if specified on the command line.
-if ($VenvDir) {
-    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
-}
-else {
-    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
-    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
-    Write-Verbose "VenvDir=$VenvDir"
-}
-
-# Next, read the `pyvenv.cfg` file to determine any required value such
-# as `prompt`.
-$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
-
-# Next, set the prompt from the command line, or the config file, or
-# just use the name of the virtual environment folder.
-if ($Prompt) {
-    Write-Verbose "Prompt specified as argument, using '$Prompt'"
-}
-else {
-    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
-    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
-        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
-        $Prompt = $pyvenvCfg['prompt'];
-    }
-    else {
-        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
-        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
-        $Prompt = Split-Path -Path $venvDir -Leaf
-    }
-}
-
-Write-Verbose "Prompt = '$Prompt'"
-Write-Verbose "VenvDir='$VenvDir'"
-
-# Deactivate any currently active virtual environment, but leave the
-# deactivate function in place.
-deactivate -nondestructive
-
-# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
-# that there is an activated venv.
-$env:VIRTUAL_ENV = $VenvDir
-
-if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
-
-    Write-Verbose "Setting prompt to '$Prompt'"
-
-    # Set the prompt to include the env name
-    # Make sure _OLD_VIRTUAL_PROMPT is global
-    function global:_OLD_VIRTUAL_PROMPT { "" }
-    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
-    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
-
-    function global:prompt {
-        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
-        _OLD_VIRTUAL_PROMPT
-    }
-    $env:VIRTUAL_ENV_PROMPT = $Prompt
-}
-
-# Clear PYTHONHOME
-if (Test-Path -Path Env:PYTHONHOME) {
-    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
-    Remove-Item -Path Env:PYTHONHOME
-}
-
-# Add the venv to the PATH
-Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
-$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

.venv/bin/activate

@@ -1,70 +0,0 @@
-# This file must be used with "source bin/activate" *from bash*
-# You cannot run it directly
-
-deactivate () {
-    # reset old environment variables
-    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
-        PATH="${_OLD_VIRTUAL_PATH:-}"
-        export PATH
-        unset _OLD_VIRTUAL_PATH
-    fi
-    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
-        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
-        export PYTHONHOME
-        unset _OLD_VIRTUAL_PYTHONHOME
-    fi
-
-    # Call hash to forget past commands. Without forgetting
-    # past commands the $PATH changes we made may not be respected
-    hash -r 2> /dev/null
-
-    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
-        PS1="${_OLD_VIRTUAL_PS1:-}"
-        export PS1
-        unset _OLD_VIRTUAL_PS1
-    fi
-
-    unset VIRTUAL_ENV
-    unset VIRTUAL_ENV_PROMPT
-    if [ ! "${1:-}" = "nondestructive" ] ; then
-    # Self destruct!
-        unset -f deactivate
-    fi
-}
-
-# unset irrelevant variables
-deactivate nondestructive
-
-# on Windows, a path can contain colons and backslashes and has to be converted:
-if [ "${OSTYPE:-}" = "cygwin" ] || [ "${OSTYPE:-}" = "msys" ] ; then
-    # transform D:\path\to\venv to /d/path/to/venv on MSYS
-    # and to /cygdrive/d/path/to/venv on Cygwin
-    export VIRTUAL_ENV=$(cygpath /root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv)
-else
-    # use the path as-is
-    export VIRTUAL_ENV=/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv
-fi
-
-_OLD_VIRTUAL_PATH="$PATH"
-PATH="$VIRTUAL_ENV/"bin":$PATH"
-export PATH
-
-# unset PYTHONHOME if set
-# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
-# could use `if (set -u; : $PYTHONHOME) ;` in bash
-if [ -n "${PYTHONHOME:-}" ] ; then
-    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
-    unset PYTHONHOME
-fi
-
-if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
-    _OLD_VIRTUAL_PS1="${PS1:-}"
-    PS1='(.venv) '"${PS1:-}"
-    export PS1
-    VIRTUAL_ENV_PROMPT='(.venv) '
-    export VIRTUAL_ENV_PROMPT
-fi
-
-# Call hash to forget past commands. Without forgetting
-# past commands the $PATH changes we made may not be respected
-hash -r 2> /dev/null

.venv/bin/activate.csh

@@ -1,27 +0,0 @@
-# This file must be used with "source bin/activate.csh" *from csh*.
-# You cannot run it directly.
-
-# Created by Davide Di Blasi <davidedb@gmail.com>.
-# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
-
-alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
-
-# Unset irrelevant variables.
-deactivate nondestructive
-
-setenv VIRTUAL_ENV /root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv
-
-set _OLD_VIRTUAL_PATH="$PATH"
-setenv PATH "$VIRTUAL_ENV/"bin":$PATH"
-
-
-set _OLD_VIRTUAL_PROMPT="$prompt"
-
-if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
-    set prompt = '(.venv) '"$prompt"
-    setenv VIRTUAL_ENV_PROMPT '(.venv) '
-endif
-
-alias pydoc python -m pydoc
-
-rehash

.venv/bin/activate.fish

@@ -1,69 +0,0 @@
-# This file must be used with "source <venv>/bin/activate.fish" *from fish*
-# (https://fishshell.com/). You cannot run it directly.
-
-function deactivate  -d "Exit virtual environment and return to normal shell environment"
-    # reset old environment variables
-    if test -n "$_OLD_VIRTUAL_PATH"
-        set -gx PATH $_OLD_VIRTUAL_PATH
-        set -e _OLD_VIRTUAL_PATH
-    end
-    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
-        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
-        set -e _OLD_VIRTUAL_PYTHONHOME
-    end
-
-    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
-        set -e _OLD_FISH_PROMPT_OVERRIDE
-        # prevents error when using nested fish instances (Issue #93858)
-        if functions -q _old_fish_prompt
-            functions -e fish_prompt
-            functions -c _old_fish_prompt fish_prompt
-            functions -e _old_fish_prompt
-        end
-    end
-
-    set -e VIRTUAL_ENV
-    set -e VIRTUAL_ENV_PROMPT
-    if test "$argv[1]" != "nondestructive"
-        # Self-destruct!
-        functions -e deactivate
-    end
-end
-
-# Unset irrelevant variables.
-deactivate nondestructive
-
-set -gx VIRTUAL_ENV /root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv
-
-set -gx _OLD_VIRTUAL_PATH $PATH
-set -gx PATH "$VIRTUAL_ENV/"bin $PATH
-
-# Unset PYTHONHOME if set.
-if set -q PYTHONHOME
-    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
-    set -e PYTHONHOME
-end
-
-if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
-    # fish uses a function instead of an env var to generate the prompt.
-
-    # Save the current fish_prompt function as the function _old_fish_prompt.
-    functions -c fish_prompt _old_fish_prompt
-
-    # With the original prompt function renamed, we can override with our own.
-    function fish_prompt
-        # Save the return status of the last command.
-        set -l old_status $status
-
-        # Output the venv prompt; color taken from the blue of the Python logo.
-        printf "%s%s%s" (set_color 4B8BBE) '(.venv) ' (set_color normal)
-
-        # Restore the return status of the previous command.
-        echo "exit $old_status" | .
-        # Output the original/"old" prompt.
-        _old_fish_prompt
-    end
-
-    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
-    set -gx VIRTUAL_ENV_PROMPT '(.venv) '
-end

.venv/bin/debugpy

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from debugpy.server.cli import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/debugpy-adapter

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from debugpy.adapter.__main__ import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/f2py

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from numpy.f2py.f2py2e import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/gguf-convert-endian

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from gguf.scripts.gguf_convert_endian import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/gguf-dump

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from gguf.scripts.gguf_dump import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/gguf-editor-gui

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from gguf.scripts.gguf_editor_gui import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/gguf-new-metadata

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from gguf.scripts.gguf_new_metadata import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/gguf-set-metadata

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from gguf.scripts.gguf_set_metadata import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/hf

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from huggingface_hub.cli.hf import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/httpx

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from httpx import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/huggingface-cli

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from huggingface_hub.cli.deprecated_cli import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/idna

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from idna.cli import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/isympy

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from isympy import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/markdown-it

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from markdown_it.cli.parse import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/normalizer

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from charset_normalizer.cli import cli_detect
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(cli_detect())

.venv/bin/numpy-config

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from numpy._configtool import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/pip

@@ -1,8 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from pip._internal.cli.main import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

.venv/bin/pip3

@@ -1,8 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from pip._internal.cli.main import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

.venv/bin/pip3.12

@@ -1,8 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from pip._internal.cli.main import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

.venv/bin/py-spy

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

.venv/bin/py.test

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from _pytest.config import _console_main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(_console_main())

.venv/bin/pygmentize

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from pygments.cmdline import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/pytest

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from _pytest.config import _console_main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(_console_main())

.venv/bin/python

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6242e0e8650d7dbdebbc25e08bf4c9359ddaf65f54fcae0e57fa99395fa5357a
-size 7845032

.venv/bin/python3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6242e0e8650d7dbdebbc25e08bf4c9359ddaf65f54fcae0e57fa99395fa5357a
-size 7845032

.venv/bin/python3.12

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6242e0e8650d7dbdebbc25e08bf4c9359ddaf65f54fcae0e57fa99395fa5357a
-size 7845032

.venv/bin/tiny-agents

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from huggingface_hub.inference._mcp.cli import app
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(app())

.venv/bin/torchfrtrace

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from torch.distributed.flight_recorder.fr_trace import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/torchrun

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from torch.distributed.run import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/tqdm

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from tqdm.cli import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/transformers

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from transformers.cli.transformers import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/typer

@@ -1,6 +0,0 @@
-#!/root/Documents/Codex/2026-07-31/so-i-ve-got-a-task/.venv/bin/python3
-import sys
-from typer.cli import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/lib/python3.12/site-packages/_distutils_hack/__init__.py

@@ -1,239 +0,0 @@
-# don't import any costly modules
-import os
-import sys
-
-report_url = (
-    "https://github.com/pypa/setuptools/issues/new?template=distutils-deprecation.yml"
-)
-
-
-def warn_distutils_present():
-    if 'distutils' not in sys.modules:
-        return
-    import warnings
-
-    warnings.warn(
-        "Distutils was imported before Setuptools, but importing Setuptools "
-        "also replaces the `distutils` module in `sys.modules`. This may lead "
-        "to undesirable behaviors or errors. To avoid these issues, avoid "
-        "using distutils directly, ensure that setuptools is installed in the "
-        "traditional way (e.g. not an editable install), and/or make sure "
-        "that setuptools is always imported before distutils."
-    )
-
-
-def clear_distutils():
-    if 'distutils' not in sys.modules:
-        return
-    import warnings
-
-    warnings.warn(
-        "Setuptools is replacing distutils. Support for replacing "
-        "an already imported distutils is deprecated. In the future, "
-        "this condition will fail. "
-        f"Register concerns at {report_url}"
-    )
-    mods = [
-        name
-        for name in sys.modules
-        if name == "distutils" or name.startswith("distutils.")
-    ]
-    for name in mods:
-        del sys.modules[name]
-
-
-def enabled():
-    """
-    Allow selection of distutils by environment variable.
-    """
-    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local')
-    if which == 'stdlib':
-        import warnings
-
-        warnings.warn(
-            "Reliance on distutils from stdlib is deprecated. Users "
-            "must rely on setuptools to provide the distutils module. "
-            "Avoid importing distutils or import setuptools first, "
-            "and avoid setting SETUPTOOLS_USE_DISTUTILS=stdlib. "
-            f"Register concerns at {report_url}"
-        )
-    return which == 'local'
-
-
-def ensure_local_distutils():
-    import importlib
-
-    clear_distutils()
-
-    # With the DistutilsMetaFinder in place,
-    # perform an import to cause distutils to be
-    # loaded from setuptools._distutils. Ref #2906.
-    with shim():
-        importlib.import_module('distutils')
-
-    # check that submodules load as expected
-    core = importlib.import_module('distutils.core')
-    assert '_distutils' in core.__file__, core.__file__
-    assert 'setuptools._distutils.log' not in sys.modules
-
-
-def do_override():
-    """
-    Ensure that the local copy of distutils is preferred over stdlib.
-
-    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
-    for more motivation.
-    """
-    if enabled():
-        warn_distutils_present()
-        ensure_local_distutils()
-
-
-class _TrivialRe:
-    def __init__(self, *patterns) -> None:
-        self._patterns = patterns
-
-    def match(self, string):
-        return all(pat in string for pat in self._patterns)
-
-
-class DistutilsMetaFinder:
-    def find_spec(self, fullname, path, target=None):
-        # optimization: only consider top level modules and those
-        # found in the CPython test suite.
-        if path is not None and not fullname.startswith('test.'):
-            return None
-
-        method_name = 'spec_for_{fullname}'.format(**locals())
-        method = getattr(self, method_name, lambda: None)
-        return method()
-
-    def spec_for_distutils(self):
-        if self.is_cpython():
-            return None
-
-        import importlib
-        import importlib.abc
-        import importlib.util
-
-        try:
-            mod = importlib.import_module('setuptools._distutils')
-        except Exception:
-            # There are a couple of cases where setuptools._distutils
-            # may not be present:
-            # - An older Setuptools without a local distutils is
-            #   taking precedence. Ref #2957.
-            # - Path manipulation during sitecustomize removes
-            #   setuptools from the path but only after the hook
-            #   has been loaded. Ref #2980.
-            # In either case, fall back to stdlib behavior.
-            return None
-
-        class DistutilsLoader(importlib.abc.Loader):
-            def create_module(self, spec):
-                mod.__name__ = 'distutils'
-                return mod
-
-            def exec_module(self, module):
-                pass
-
-        return importlib.util.spec_from_loader(
-            'distutils', DistutilsLoader(), origin=mod.__file__
-        )
-
-    @staticmethod
-    def is_cpython():
-        """
-        Suppress supplying distutils for CPython (build and tests).
-        Ref #2965 and #3007.
-        """
-        return os.path.isfile('pybuilddir.txt')
-
-    def spec_for_pip(self):
-        """
-        Ensure stdlib distutils when running under pip.
-        See pypa/pip#8761 for rationale.
-        """
-        if sys.version_info >= (3, 12) or self.pip_imported_during_build():
-            return
-        clear_distutils()
-        self.spec_for_distutils = lambda: None
-
-    @classmethod
-    def pip_imported_during_build(cls):
-        """
-        Detect if pip is being imported in a build script. Ref #2355.
-        """
-        import traceback
-
-        return any(
-            cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None)
-        )
-
-    @staticmethod
-    def frame_file_is_setup(frame):
-        """
-        Return True if the indicated frame suggests a setup.py file.
-        """
-        # some frames may not have __file__ (#2940)
-        return frame.f_globals.get('__file__', '').endswith('setup.py')
-
-    def spec_for_sensitive_tests(self):
-        """
-        Ensure stdlib distutils when running select tests under CPython.
-
-        python/cpython#91169
-        """
-        clear_distutils()
-        self.spec_for_distutils = lambda: None
-
-    sensitive_tests = (
-        [
-            'test.test_distutils',
-            'test.test_peg_generator',
-            'test.test_importlib',
-        ]
-        if sys.version_info < (3, 10)
-        else [
-            'test.test_distutils',
-        ]
-    )
-
-
-for name in DistutilsMetaFinder.sensitive_tests:
-    setattr(
-        DistutilsMetaFinder,
-        f'spec_for_{name}',
-        DistutilsMetaFinder.spec_for_sensitive_tests,
-    )
-
-
-DISTUTILS_FINDER = DistutilsMetaFinder()
-
-
-def add_shim():
-    DISTUTILS_FINDER in sys.meta_path or insert_shim()
-
-
-class shim:
-    def __enter__(self) -> None:
-        insert_shim()
-
-    def __exit__(self, exc: object, value: object, tb: object) -> None:
-        _remove_shim()
-
-
-def insert_shim():
-    sys.meta_path.insert(0, DISTUTILS_FINDER)
-
-
-def _remove_shim():
-    try:
-        sys.meta_path.remove(DISTUTILS_FINDER)
-    except ValueError:
-        pass
-
-
-if sys.version_info < (3, 12):
-    # DistutilsMetaFinder can only be disabled in Python < 3.12 (PEP 632)
-    remove_shim = _remove_shim

.venv/lib/python3.12/site-packages/_distutils_hack/override.py

@@ -1 +0,0 @@
-__import__('_distutils_hack').do_override()

.venv/lib/python3.12/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/python3.12/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/python3.12/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/python3.12/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/python3.12/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/python3.12/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/python3.12/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)