Given following log snippets, their explanation, and nothing else, explain what failure, if any, occurred during build of this package.

  Snippets are in a format of [X] : [Y], where [X] is a log snippet, and [Y] is the explanation.

  Snippets are delimited with '================'.

  Drawing on information from all snippets, provide a concise explanation of the issue and recommend a solution.

  Explanation of the issue, and recommended solution, should take a handful of sentences.

  Snippets:

  [python3-devel          x86_64 3.14.0~a6-1.fc43 copr_base]: [This snippet shows which Python version for development was installed into the buildroot and from what repository. It is version 3.14.0~a6-1.fc43, to which we can refer to as 3.14, from copr repository. ]
=============
[=================================== FAILURES ===================================
________________ test_inspect_builtin_function_except_python311 ________________

    @skip_py313
    @skip_py312
    @skip_py311
    @skip_pypy3
    def test_inspect_builtin_function_except_python311():
        # Pre-3.11 Python versions - print builtin has no signature available
        expected = (
            "â­ââââââââââ <built-in function print> ââââââââââââ®\n"
            "â def print(...)                                 â\n"
            "â                                                â\n"
            "â print(value, ..., sep=' ', end='\\n',           â\n"
            "â file=sys.stdout, flush=False)                  â\n"
            "â                                                â\n"
            "â 29 attribute(s) not shown. Run                 â\n"
            "â inspect(inspect) for options.                  â\n"
            "â°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n"
        )
>       assert render(print) == expected
E       assert "â­ââââââââââ <built-in function print> ââââââââââââ®\nâ def print(*args, sep=' ', end='\\n', file=None, â\nâ flush=False):                                  â\nâ                                                â\nâ Prints the values to a stream, or to           â\nâ sys.stdout by default.                         â\nâ                                                â\nâ 30 attribute(s) not shown. Run                 â\nâ inspect(inspect) for options.                  â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n" == "â­ââââââââââ <built-in function print> ââââââââââââ®\nâ def print(...)                                 â\nâ                                                â\nâ print(value, ..., sep=' ', end='\\n',           â\nâ file=sys.stdout, flush=False)                  â\nâ                                                â\nâ 29 attribute(s) not shown. Run                 â\nâ inspect(inspect) for options.                  â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n"
E         
E           â­ââââââââââ <built-in function print> ââââââââââââ®
E         + â def print(*args, sep=' ', end='\n', file=None, â
E         - â def print(...)                                 â
E         ?   ^ -----------
E         + â flush=False):                                  â
E         ?   ^^^^^^^^^^  ++
E           â                                                â
E         - â print(value, ..., sep=' ', end='\n',           â
E         - â file=sys.stdout, flush=False)                  â
E         + â Prints the values to a stream, or to           â
E         + â sys.stdout by default.                         â
E           â                                                â
E         - â 29 attribute(s) not shown. Run                 â
E         ?   ^^
E         + â 30 attribute(s) not shown. Run                 â
E         ?   ^^
E           â inspect(inspect) for options.                  â
E           â°âââââââââââââââââââââââââââââââââââââââââââââââââ¯

tests/test_inspect.py:159: AssertionError]: [This is the start of the extended test failures output.
This is the first failing test: test_inspect_builtin_function_except_python311.
The output, sometimes also called traceback, shows the test decorators (starting with symbol @), test itself and the error (on the lines starting with capital E). The snippet ends with the file and line of which error happened and the information that it was an AssertionError. Lines of the error can help debug the failure.]
=============
[___________ test_inspect_integer_with_methods_python38_and_python39 ____________]: [Name of the failed test is often accompanied by a series of underscores before and after the test name.]
=============
[    @skip_py310
    @skip_py311
    @skip_py312
    @skip_py313]: [These are the decorators of the test function. Without looking at their implementation, we can fairly guess their meaning: the test is not meant to run on python 3.10, 3.11, 3.12, 3.13. It probably tests features specific for Pythons older than 3.10.]
=============
[    def test_inspect_integer_with_methods_python38_and_python39():
        expected = (
            "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\n"
            "â int([x]) -> integer                            â\n"
            "â int(x, base=10) -> integer                     â\n"
            "â                                                â\n"
            "â      denominator = 1                           â\n"
            "â             imag = 0                           â\n"
            "â        numerator = 1                           â\n"
            "â             real = 1                           â\n"
            "â as_integer_ratio = def as_integer_ratio():     â\n"
            "â                    Return integer ratio.       â\n"
            "â       bit_length = def bit_length(): Number of â\n"
            "â                    bits necessary to represent â\n"
            "â                    self in binary.             â\n"
            "â        conjugate = def conjugate(...) Returns  â\n"
            "â                    self, the complex conjugate â\n"
            "â                    of any int.                 â\n"
            "â       from_bytes = def from_bytes(bytes,       â\n"
            "â                    byteorder, *,               â\n"
            "â                    signed=False): Return the   â\n"
            "â                    integer represented by the  â\n"
            "â                    given array of bytes.       â\n"
            "â         to_bytes = def to_bytes(length,        â\n"
            "â                    byteorder, *,               â\n"
            "â                    signed=False): Return an    â\n"
            "â                    array of bytes representing â\n"
            "â                    an integer.                 â\n"
            "â°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n"
        )]: [This is the test body, containing the function header (the line starting with def and ending with a colon (:)). It contains the expected output of the test function. When running the relevant code, this is how the output should look like.]
=============
[>       assert render(1, methods=True) == expected]: [This line starts with an arrow (>). This indicates the line on which the test problem starts. The test calls a function called render with arguments (1, methods=True) and asserts that what it generated matches literally the output stored in variable "expected". Because there's an arrow at the beginning of the line, we know this assertion was not evaluated to True. The test failed.]
=============
[E       assert "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\nâ int([x]) -> integer                            â\nâ int(x, base=10) -> integer                     â\nâ                                                â\nâ      denominator = 1                           â\nâ             imag = 0                           â\nâ        numerator = 1                           â\nâ             real = 1                           â\nâ as_integer_ratio = def as_integer_ratio():     â\nâ                    Return a pair of integers,  â\nâ                    whose ratio is equal to the â\nâ                    original int.               â\nâ        bit_count = def bit_count(): Number of  â\nâ                    ones in the binary          â\nâ                    representation of the       â\nâ                    absolute value of self.     â\nâ       bit_length = def bit_length(): Number of â\nâ                    bits necessary to represent â\nâ                    self in binary.             â\nâ        conjugate = def conjugate(): Returns    â\nâ                    self, the complex conjugate â\nâ                    of any int.                 â\nâ       from_bytes = def from_bytes(bytes,       â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return the   â\nâ                    integer represented by the  â\nâ                    given array of bytes.       â\nâ       is_integer = def is_integer(): Returns   â\nâ                    True. Exists for duck type  â\nâ                    compatibility with          â\nâ                    float.is_integer.           â\nâ         to_bytes = def to_bytes(length=1,      â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return an    â\nâ                    array of bytes representing â\nâ                    an integer.                 â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n" == "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\nâ int([x]) -> integer                            â\nâ int(x, base=10) -> integer                     â\nâ                                                â\nâ      denominator = 1                           â\nâ             imag = 0                           â\nâ        numerator = 1                           â\nâ             real = 1                           â\nâ as_integer_ratio = def as_integer_ratio():     â\nâ                    Return integer ratio.       â\nâ       bit_length = def bit_length(): Number of â\nâ                    bits necessary to represent â\nâ                    self in binary.             â\nâ        conjugate = def conjugate(...) Returns  â\nâ                    self, the complex conjugate â\nâ                    of any int.                 â\nâ       from_bytes = def from_bytes(bytes,       â\nâ                    byteorder, *,               â\nâ                    signed=False): Return the   â\nâ                    integer represented by the  â\nâ                    given array of bytes.       â\nâ         to_bytes = def to_bytes(length,        â\nâ                    byteorder, *,               â\nâ                    signed=False): Return an    â\nâ                    array of bytes representing â\nâ                    an integer.                 â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n"
E         
E           â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®
E           â int([x]) -> integer                            â
E           â int(x, base=10) -> integer                     â
E           â                                                â
E           â      denominator = 1                           â
E           â             imag = 0                           â
E           â        numerator = 1                           â
E           â             real = 1                           â
E           â as_integer_ratio = def as_integer_ratio():     â
E         - â                    Return integer ratio.       â
E         ?                                    ^^^^^^^^^^^^
E         + â                    Return a pair of integers,  â
E         ?                            ++++++++++        ^^]: [This is extended error output (lines starting with capital E). It shows the diff between the expected and the actual result. The lines of diff are prepended with symbols -, + and ?. The actual output doesn't contain the string "Return integer ratio.", it contains a string "Return a pair of integers,". The difference is made more visible by using the + and ^ symbols in the lines starting with ?, which show exactly what characters are added or missing explicitly.]
=============
[E         - â        conjugate = def conjugate(...) Returns  â
E         ?                                    ---
E         + â        conjugate = def conjugate(): Returns    â
E         ?                                     +          ++]: [That's another error diff line. The actual output misses the "...". The actual output contains an additional colon and two spaces. There's a mismatch of the lines contents.]
=============
[E         - â                    byteorder, *,               â
E         ?                                            ------
E         + â                    byteorder='big', *,         â
E         ?                               ++++++]: [Another error diff line. The actual output misses 6 space characters, because it added 6 other: ='big' (indicated by the + symbols underneath).]
=============
[E         + â       is_integer = def is_integer(): Returns   â
E         + â                    True. Exists for duck type  â
E         + â                    compatibility with          â
E         + â                    float.is_integer.           â]: [This is another error diff snippet. The lines are in the actual output, but not in the expected one. This is indicated by the + characters prepending the lines. There is no matching lines prepended with -, which means the lines were only added, not somehow changed, comparing to the expected output.]
=============
[tests/test_inspect.py:252: AssertionError]: [This line contains the failed test file path (tests/test_inspect.py), the line on which error happened (252) and the type of error: AssertionError]
=============
[_______________ test_inspect_integer_with_methods_python310only ________________

    @skip_py38
    @skip_py39
    @skip_py311
    @skip_py312
    @skip_py313
    def test_inspect_integer_with_methods_python310only():
        expected = (
            "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\n"
            "â int([x]) -> integer                            â\n"
            "â int(x, base=10) -> integer                     â\n"
            "â                                                â\n"
            "â      denominator = 1                           â\n"
            "â             imag = 0                           â\n"
            "â        numerator = 1                           â\n"
            "â             real = 1                           â\n"
            "â as_integer_ratio = def as_integer_ratio():     â\n"
            "â                    Return integer ratio.       â\n"
            "â        bit_count = def bit_count(): Number of  â\n"
            "â                    ones in the binary          â\n"
            "â                    representation of the       â\n"
            "â                    absolute value of self.     â\n"
            "â       bit_length = def bit_length(): Number of â\n"
            "â                    bits necessary to represent â\n"
            "â                    self in binary.             â\n"
            "â        conjugate = def conjugate(...) Returns  â\n"
            "â                    self, the complex conjugate â\n"
            "â                    of any int.                 â\n"
            "â       from_bytes = def from_bytes(bytes,       â\n"
            "â                    byteorder, *,               â\n"
            "â                    signed=False): Return the   â\n"
            "â                    integer represented by the  â\n"
            "â                    given array of bytes.       â\n"
            "â         to_bytes = def to_bytes(length,        â\n"
            "â                    byteorder, *,               â\n"
            "â                    signed=False): Return an    â\n"
            "â                    array of bytes representing â\n"
            "â                    an integer.                 â\n"
            "â°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n"
        )
>       assert render(1, methods=True) == expected
E       assert "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\nâ int([x]) -> integer                            â\nâ int(x, base=10) -> integer                     â\nâ                                                â\nâ      denominator = 1                           â\nâ             imag = 0                           â\nâ        numerator = 1                           â\nâ             real = 1                           â\nâ as_integer_ratio = def as_integer_ratio():     â\nâ                    Return a pair of integers,  â\nâ                    whose ratio is equal to the â\nâ                    original int.               â\nâ        bit_count = def bit_count(): Number of  â\nâ                    ones in the binary          â\nâ                    representation of the       â\nâ                    absolute value of self.     â\nâ       bit_length = def bit_length(): Number of â\nâ                    bits necessary to represent â\nâ                    self in binary.             â\nâ        conjugate = def conjugate(): Returns    â\nâ                    self, the complex conjugate â\nâ                    of any int.                 â\nâ       from_bytes = def from_bytes(bytes,       â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return the   â\nâ                    integer represented by the  â\nâ                    given array of bytes.       â\nâ       is_integer = def is_integer(): Returns   â\nâ                    True. Exists for duck type  â\nâ                    compatibility with          â\nâ                    float.is_integer.           â\nâ         to_bytes = def to_bytes(length=1,      â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return an    â\nâ                    array of bytes representing â\nâ                    an integer.                 â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n" == "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\nâ int([x]) -> integer                            â\nâ int(x, base=10) -> integer                     â\nâ                                                â\nâ      denominator = 1                           â\nâ             imag = 0                           â\nâ        numerator = 1                           â\nâ             real = 1                           â\nâ as_integer_ratio = def as_integer_ratio():     â\nâ                    Return integer ratio.       â\nâ        bit_count = def bit_count(): Number of  â\nâ                    ones in the binary          â\nâ                    representation of the       â\nâ                    absolute value of self.     â\nâ       bit_length = def bit_length(): Number of â\nâ                    bits necessary to represent â\nâ                    self in binary.             â\nâ        conjugate = def conjugate(...) Returns  â\nâ                    self, the complex conjugate â\nâ                    of any int.                 â\nâ       from_bytes = def from_bytes(bytes,       â\nâ                    byteorder, *,               â\nâ                    signed=False): Return the   â\nâ                    integer represented by the  â\nâ                    given array of bytes.       â\nâ         to_bytes = def to_bytes(length,        â\nâ                    byteorder, *,               â\nâ                    signed=False): Return an    â\nâ                    array of bytes representing â\nâ                    an integer.                 â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n"
E         
E           â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®
E           â int([x]) -> integer                            â
E           â int(x, base=10) -> integer                     â
E           â                                                â
E           â      denominator = 1                           â
E           â             imag = 0                           â
E           â        numerator = 1                           â
E           â             real = 1                           â
E           â as_integer_ratio = def as_integer_ratio():     â
E         - â                    Return integer ratio.       â
E         ?                                    ^^^^^^^^^^^^
E         + â                    Return a pair of integers,  â
E         ?                            ++++++++++        ^^
E         + â                    whose ratio is equal to the â
E         + â                    original int.               â
E           â        bit_count = def bit_count(): Number of  â
E           â                    ones in the binary          â
E           â                    representation of the       â
E           â                    absolute value of self.     â
E           â       bit_length = def bit_length(): Number of â
E           â                    bits necessary to represent â
E           â                    self in binary.             â
E         - â        conjugate = def conjugate(...) Returns  â
E         ?                                    ---
E         + â        conjugate = def conjugate(): Returns    â
E         ?                                     +          ++
E           â                    self, the complex conjugate â
E           â                    of any int.                 â
E           â       from_bytes = def from_bytes(bytes,       â
E         - â                    byteorder, *,               â
E         ?                                            ------
E         + â                    byteorder='big', *,         â
E         ?                               ++++++
E           â                    signed=False): Return the   â
E           â                    integer represented by the  â
E           â                    given array of bytes.       â
E         + â       is_integer = def is_integer(): Returns   â
E         + â                    True. Exists for duck type  â
E         + â                    compatibility with          â
E         + â                    float.is_integer.           â
E         - â         to_bytes = def to_bytes(length,        â
E         ?                                          --
E         + â         to_bytes = def to_bytes(length=1,      â
E         ?                                         ++
E         - â                    byteorder, *,               â
E         ?                                            ------
E         + â                    byteorder='big', *,         â
E         ?                               ++++++
E           â                    signed=False): Return an    â
E           â                    array of bytes representing â
E           â                    an integer.                 â
E           â°âââââââââââââââââââââââââââââââââââââââââââââââââ¯

tests/test_inspect.py:294: AssertionError]: [test_inspect_integer_with_methods_python310only is another test that failed with AssertionError because the expected output didn't match the actual one, and the test shows the diff where this happened.]
=============
[_________________ test_inspect_integer_with_methods_python311 __________________

    @skip_py38
    @skip_py39
    @skip_py310
    @skip_py312
    @skip_py313
    def test_inspect_integer_with_methods_python311():
        # to_bytes and from_bytes methods on int had minor signature change -
        # they now, as of 3.11, have default values for all of their parameters
        expected = (
            "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\n"
            "â int([x]) -> integer                            â\n"
            "â int(x, base=10) -> integer                     â\n"
            "â                                                â\n"
            "â      denominator = 1                           â\n"
            "â             imag = 0                           â\n"
            "â        numerator = 1                           â\n"
            "â             real = 1                           â\n"
            "â as_integer_ratio = def as_integer_ratio():     â\n"
            "â                    Return integer ratio.       â\n"
            "â        bit_count = def bit_count(): Number of  â\n"
            "â                    ones in the binary          â\n"
            "â                    representation of the       â\n"
            "â                    absolute value of self.     â\n"
            "â       bit_length = def bit_length(): Number of â\n"
            "â                    bits necessary to represent â\n"
            "â                    self in binary.             â\n"
            "â        conjugate = def conjugate(...) Returns  â\n"
            "â                    self, the complex conjugate â\n"
            "â                    of any int.                 â\n"
            "â       from_bytes = def from_bytes(bytes,       â\n"
            "â                    byteorder='big', *,         â\n"
            "â                    signed=False): Return the   â\n"
            "â                    integer represented by the  â\n"
            "â                    given array of bytes.       â\n"
            "â         to_bytes = def to_bytes(length=1,      â\n"
            "â                    byteorder='big', *,         â\n"
            "â                    signed=False): Return an    â\n"
            "â                    array of bytes representing â\n"
            "â                    an integer.                 â\n"
            "â°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n"
        )
>       assert render(1, methods=True) == expected
E       assert "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\nâ int([x]) -> integer                            â\nâ int(x, base=10) -> integer                     â\nâ                                                â\nâ      denominator = 1                           â\nâ             imag = 0                           â\nâ        numerator = 1                           â\nâ             real = 1                           â\nâ as_integer_ratio = def as_integer_ratio():     â\nâ                    Return a pair of integers,  â\nâ                    whose ratio is equal to the â\nâ                    original int.               â\nâ        bit_count = def bit_count(): Number of  â\nâ                    ones in the binary          â\nâ                    representation of the       â\nâ                    absolute value of self.     â\nâ       bit_length = def bit_length(): Number of â\nâ                    bits necessary to represent â\nâ                    self in binary.             â\nâ        conjugate = def conjugate(): Returns    â\nâ                    self, the complex conjugate â\nâ                    of any int.                 â\nâ       from_bytes = def from_bytes(bytes,       â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return the   â\nâ                    integer represented by the  â\nâ                    given array of bytes.       â\nâ       is_integer = def is_integer(): Returns   â\nâ                    True. Exists for duck type  â\nâ                    compatibility with          â\nâ                    float.is_integer.           â\nâ         to_bytes = def to_bytes(length=1,      â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return an    â\nâ                    array of bytes representing â\nâ                    an integer.                 â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n" == "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\nâ int([x]) -> integer                            â\nâ int(x, base=10) -> integer                     â\nâ                                                â\nâ      denominator = 1                           â\nâ             imag = 0                           â\nâ        numerator = 1                           â\nâ             real = 1                           â\nâ as_integer_ratio = def as_integer_ratio():     â\nâ                    Return integer ratio.       â\nâ        bit_count = def bit_count(): Number of  â\nâ                    ones in the binary          â\nâ                    representation of the       â\nâ                    absolute value of self.     â\nâ       bit_length = def bit_length(): Number of â\nâ                    bits necessary to represent â\nâ                    self in binary.             â\nâ        conjugate = def conjugate(...) Returns  â\nâ                    self, the complex conjugate â\nâ                    of any int.                 â\nâ       from_bytes = def from_bytes(bytes,       â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return the   â\nâ                    integer represented by the  â\nâ                    given array of bytes.       â\nâ         to_bytes = def to_bytes(length=1,      â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return an    â\nâ                    array of bytes representing â\nâ                    an integer.                 â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n"
E         
E           â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®
E           â int([x]) -> integer                            â
E           â int(x, base=10) -> integer                     â
E           â                                                â
E           â      denominator = 1                           â
E           â             imag = 0                           â
E           â        numerator = 1                           â
E           â             real = 1                           â
E           â as_integer_ratio = def as_integer_ratio():     â
E         - â                    Return integer ratio.       â
E         ?                                    ^^^^^^^^^^^^
E         + â                    Return a pair of integers,  â
E         ?                            ++++++++++        ^^
E         + â                    whose ratio is equal to the â
E         + â                    original int.               â
E           â        bit_count = def bit_count(): Number of  â
E           â                    ones in the binary          â
E           â                    representation of the       â
E           â                    absolute value of self.     â
E           â       bit_length = def bit_length(): Number of â
E           â                    bits necessary to represent â
E           â                    self in binary.             â
E         - â        conjugate = def conjugate(...) Returns  â
E         ?                                    ---
E         + â        conjugate = def conjugate(): Returns    â
E         ?                                     +          ++
E           â                    self, the complex conjugate â
E           â                    of any int.                 â
E           â       from_bytes = def from_bytes(bytes,       â
E           â                    byteorder='big', *,         â
E           â                    signed=False): Return the   â
E           â                    integer represented by the  â
E           â                    given array of bytes.       â
E         + â       is_integer = def is_integer(): Returns   â
E         + â                    True. Exists for duck type  â
E         + â                    compatibility with          â
E         + â                    float.is_integer.           â
E           â         to_bytes = def to_bytes(length=1,      â
E           â                    byteorder='big', *,         â
E           â                    signed=False): Return an    â
E           â                    array of bytes representing â
E           â                    an integer.                 â
E           â°âââââââââââââââââââââââââââââââââââââââââââââââââ¯

tests/test_inspect.py:338: AssertionError]: [test_inspect_integer_with_methods_python311 is another test that failed with AssertionError because the expected output didn't match the actual one, and the test shows the diff where this happened.]
=============
[_______________________________ test_inline_code _______________________________

    def test_inline_code():
        markdown = Markdown(
            "inline `import this` code",
            inline_code_lexer="python",
            inline_code_theme="emacs",
        )
        result = render(markdown)
        expected = "inline \x1b[1;38;2;170;34;255;48;2;248;248;248mimport\x1b[0m\x1b[38;2;0;0;0;48;2;248;248;248m \x1b[0m\x1b[1;38;2;0;0;255;48;2;248;248;248mthis\x1b[0m code                                                                             \n"
        print(result)
        print(repr(result))
>       assert result == expected
E       AssertionError: assert 'inline \x1b[1;38;2;170;34;255;48;2;248;248;248mimport\x1b[0m\x1b[38;2;187;187;187;48;2;248;248;248m \x1b[0m\x1b[1;38;2;0;0;255;48;2;248;248;248mthis\x1b[0m code                                                                             \n' == 'inline \x1b[1;38;2;170;34;255;48;2;248;248;248mimport\x1b[0m\x1b[38;2;0;0;0;48;2;248;248;248m \x1b[0m\x1b[1;38;2;0;0;255;48;2;248;248;248mthis\x1b[0m code                                                                             \n'
E         
E         - inline import this code                                                                             
E         ?                                                              ^^^^^^^^^^^^^^^^^^^^^^^
E         + inline import this code                                                                             
E         ?                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

tests/test_markdown.py:116: AssertionError]: [test_inline_code failed with AssertionError because of a differing number of whitespace characters behind the import line (there are 6 more). This test doesn't contain any decorators telling to skip the test with any Python version.]
=============
[______________________________ test_attrs_broken _______________________________

    @skip_py310
    @skip_py311
    @skip_py312
    @skip_py313
    def test_attrs_broken() -> None:
        @attr.define
        class Foo:
            bar: int
    
        foo = Foo(1)
        del foo.bar
        result = pretty_repr(foo)
        print(repr(result))
        expected = "Foo(bar=AttributeError('bar'))"
>       assert result == expected
E       assert 'Foo(\n    bar=AttributeError("\'tests.test_pretty.test_attrs_broken.<locals>.Foo\' object has no attribute \'bar\'")\n)' == "Foo(bar=AttributeError('bar'))"
E         
E         - Foo(bar=AttributeError('bar'))
E         + Foo(
E         +     bar=AttributeError("'tests.test_pretty.test_attrs_broken.<locals>.Foo' object has no attribute 'bar'")
E         + )

tests/test_pretty.py:652: AssertionError]: [test_attrs_broken fails with AssertionError because the actual result doesn't match the expected one. The test is skipped on pythons 3.10, 3.11, 3.12, 3.13.]
=============
[_______________________________ test_blank_lines _______________________________

    def test_blank_lines():
        code = "\n\nimport this\n\n"
        syntax = Syntax(
            code, lexer="python", theme="ascii_light", code_width=30, line_numbers=True
        )
        result = render(syntax)
        print(repr(result))
>       assert (
            result
            == "\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m1 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m2 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m3 \x1b[0m\x1b[1;38;2;0;128;0;48;2;248;248;248mimport\x1b[0m\x1b[38;2;0;0;0;48;2;248;248;248m \x1b[0m\x1b[1;38;2;0;0;255;48;2;248;248;248mthis\x1b[0m\x1b[48;2;248;248;248m                   \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m4 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m5 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n"
        )
E       AssertionError: assert '\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m1 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m2 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m3 \x1b[0m\x1b[1;38;2;0;128;0;48;2;248;248;248mimport\x1b[0m\x1b[38;2;187;187;187;48;2;248;248;248m \x1b[0m\x1b[1;38;2;0;0;255;48;2;248;248;248mthis\x1b[0m\x1b[48;2;248;248;248m                   \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m4 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m5 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n' == '\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m1 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m2 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m3 \x1b[0m\x1b[1;38;2;0;128;0;48;2;248;248;248mimport\x1b[0m\x1b[38;2;0;0;0;48;2;248;248;248m \x1b[0m\x1b[1;38;2;0;0;255;48;2;248;248;248mthis\x1b[0m\x1b[48;2;248;248;248m                   \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m4 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m5 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n'
E         
E             1                               
E             2                               
E         -   3 import this                   
E         ?                                                                                                                                       ^^^^^^^^^^^^^^^^^^^^^^^
E         +   3 import this                   
E         ?                                                                                                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E             4                               
E             5                               
]: [This test fails with AssertionError because the expected output mismatches the actual one. The actual output contains 6 more whitespace characters.]
=============
[___________________ test_python_render_simple_indent_guides ____________________

    @pytest.mark.skipif(OLD_PYGMENTS, reason="Pygments changed their tokenizer")
    def test_python_render_simple_indent_guides():
        syntax = Syntax(
            CODE,
            lexer="python",
            line_numbers=False,
            theme="ansi_light",
            code_width=60,
            word_wrap=False,
            indent_guides=True,
        )
        rendered_syntax = render(syntax)
        print(repr(rendered_syntax))
        expected = '\x1b[34mdef\x1b[0m \x1b[32mloop_first_last\x1b[0m(values: Iterable[T]) -> Iterable[Tuple[\x1b[36mb\x1b[0m\n\x1b[2;37mâ   \x1b[0m\x1b[33m"""Iterate and generate a tuple with a flag for first an\x1b[0m\n\x1b[2mâ   \x1b[0miter_values = \x1b[36miter\x1b[0m(values)\n\x1b[2mâ   \x1b[0m\x1b[34mtry\x1b[0m:\n\x1b[2mâ   â   \x1b[0mprevious_value = \x1b[36mnext\x1b[0m(iter_values)\n\x1b[2mâ   \x1b[0m\x1b[34mexcept\x1b[0m \x1b[36mStopIteration\x1b[0m:\n\x1b[2mâ   â   \x1b[0m\x1b[34mreturn\x1b[0m\n\x1b[2mâ   \x1b[0mfirst = \x1b[34mTrue\x1b[0m\n\x1b[2mâ   \x1b[0m\x1b[34mfor\x1b[0m value \x1b[35min\x1b[0m iter_values:\n\x1b[2mâ   â   \x1b[0m\x1b[34myield\x1b[0m first, \x1b[34mFalse\x1b[0m, previous_value\n\x1b[2mâ   â   \x1b[0mfirst = \x1b[34mFalse\x1b[0m\n\x1b[2mâ   â   \x1b[0mprevious_value = value\n\x1b[2mâ   \x1b[0m\x1b[34myield\x1b[0m first, \x1b[34mTrue\x1b[0m, previous_value\n'
>       assert rendered_syntax == expected
E       assert '\x1b[34mdef\x1b[0m\x1b[37m \x1b[0m\x1b[32mloop_first_last\x1b[0m(values: Iterable[T]) -> Iterable[Tuple[\x1b[36mb\x1b[0m\n\x1b[2;37mâ   \x1b[0m\x1b[33m"""Iterate and generate a tuple with a flag for first an\x1b[0m\n\x1b[2mâ   \x1b[0miter_values = \x1b[36miter\x1b[0m(values)\n\x1b[2mâ   \x1b[0m\x1b[34mtry\x1b[0m:\n\x1b[2mâ   â   \x1b[0mprevious_value = \x1b[36mnext\x1b[0m(iter_values)\n\x1b[2mâ   \x1b[0m\x1b[34mexcept\x1b[0m \x1b[36mStopIteration\x1b[0m:\n\x1b[2mâ   â   \x1b[0m\x1b[34mreturn\x1b[0m\n\x1b[2mâ   \x1b[0mfirst = \x1b[34mTrue\x1b[0m\n\x1b[2mâ   \x1b[0m\x1b[34mfor\x1b[0m value \x1b[35min\x1b[0m iter_values:\n\x1b[2mâ   â   \x1b[0m\x1b[34myield\x1b[0m first, \x1b[34mFalse\x1b[0m, previous_value\n\x1b[2mâ   â   \x1b[0mfirst = \x1b[34mFalse\x1b[0m\n\x1b[2mâ   â   \x1b[0mprevious_value = value\n\x1b[2mâ   \x1b[0m\x1b[34myield\x1b[0m first, \x1b[34mTrue\x1b[0m, previous_value\n' == '\x1b[34mdef\x1b[0m \x1b[32mloop_first_last\x1b[0m(values: Iterable[T]) -> Iterable[Tuple[\x1b[36mb\x1b[0m\n\x1b[2;37mâ   \x1b[0m\x1b[33m"""Iterate and generate a tuple with a flag for first an\x1b[0m\n\x1b[2mâ   \x1b[0miter_values = \x1b[36miter\x1b[0m(values)\n\x1b[2mâ   \x1b[0m\x1b[34mtry\x1b[0m:\n\x1b[2mâ   â   \x1b[0mprevious_value = \x1b[36mnext\x1b[0m(iter_values)\n\x1b[2mâ   \x1b[0m\x1b[34mexcept\x1b[0m \x1b[36mStopIteration\x1b[0m:\n\x1b[2mâ   â   \x1b[0m\x1b[34mreturn\x1b[0m\n\x1b[2mâ   \x1b[0mfirst = \x1b[34mTrue\x1b[0m\n\x1b[2mâ   \x1b[0m\x1b[34mfor\x1b[0m value \x1b[35min\x1b[0m iter_values:\n\x1b[2mâ   â   \x1b[0m\x1b[34myield\x1b[0m first, \x1b[34mFalse\x1b[0m, previous_value\n\x1b[2mâ   â   \x1b[0mfirst = \x1b[34mFalse\x1b[0m\n\x1b[2mâ   â   \x1b[0mprevious_value = value\n\x1b[2mâ   \x1b[0m\x1b[34myield\x1b[0m first, \x1b[34mTrue\x1b[0m, previous_value\n'
E         
E         - def loop_first_last(values: Iterable[T]) -> Iterable[Tuple[b
E         ?             ^
E         + def loop_first_last(values: Iterable[T]) -> Iterable[Tuple[b
E         ?             ^^^^^^^^^^
E           â   """Iterate and generate a tuple with a flag for first an
E           â   iter_values = iter(values)
E           â   try:
E           â   â   previous_value = next(iter_values)
E           â   except StopIteration:
E           â   â   return
E           â   first = True
E           â   for value in iter_values:
E           â   â   yield first, False, previous_value
E           â   â   first = False
E           â   â   previous_value = value
E           â   yield first, True, previous_value

tests/test_syntax.py:123: AssertionError]: [test_python_render_simple_indent_guides is intended to be skipped with OLD_PYGMENTS, which means if the version of pygments library is old, it should be skipped. The test ran, so the version of pygments that's available in buildroot is new enough. The rendered error lines don't show it clearly, but there is a mismatch in the output, visible on the first error line (starting with E assert...). Rendered result starts like that: "\x1b[34mdef\x1b[0m\x1b[37m \x1b[0m\x1b[32mloop_first_last\x1b[0m(values: Iterable[T])", the expected one "\x1b[34mdef\x1b[0m \x1b[32mloop_first_last\x1b[0m(values: Iterable[T])". There is a space character in the expected syntax that was not in the rendered ouput.]
=============
[=========================== short test summary info ============================
FAILED tests/test_inspect.py::test_inspect_builtin_function_except_python311 - assert "â­ââââââââââ <built-in function print> ââââââââââââ®\nâ def print(*args, sep=' ', end='\\n', file=None, â\nâ flush=False):                                  â\nâ                                                â\nâ Prints the values to a stream, or to           â\nâ sys.stdout by default.                         â\nâ                                                â\nâ 30 attribute(s) not shown. Run                 â\nâ inspect(inspect) for options.                  â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n" == "â­ââââââââââ <built-in function print> ââââââââââââ®\nâ def print(...)                                 â\nâ                                                â\nâ print(value, ..., sep=' ', end='\\n',           â\nâ file=sys.stdout, flush=False)                  â\nâ                                                â\nâ 29 attribute(s) not shown. Run                 â\nâ inspect(inspect) for options.                  â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n"
  
    â­ââââââââââ <built-in function print> ââââââââââââ®
  + â def print(*args, sep=' ', end='\n', file=None, â
  - â def print(...)                                 â
  ?   ^ -----------
  + â flush=False):                                  â
  ?   ^^^^^^^^^^  ++
    â                                                â
  - â print(value, ..., sep=' ', end='\n',           â
  - â file=sys.stdout, flush=False)                  â
  + â Prints the values to a stream, or to           â
  + â sys.stdout by default.                         â
    â                                                â
  - â 29 attribute(s) not shown. Run                 â
  ?   ^^
  + â 30 attribute(s) not shown. Run                 â
  ?   ^^
    â inspect(inspect) for options.                  â
    â°âââââââââââââââââââââââââââââââââââââââââââââââââ¯
FAILED tests/test_inspect.py::test_inspect_integer_with_methods_python38_and_python39 - assert "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\nâ int([x]) -> integer                            â\nâ int(x, base=10) -> integer                     â\nâ                                                â\nâ      denominator = 1                           â\nâ             imag = 0                           â\nâ        numerator = 1                           â\nâ             real = 1                           â\nâ as_integer_ratio = def as_integer_ratio():     â\nâ                    Return a pair of integers,  â\nâ                    whose ratio is equal to the â\nâ                    original int.               â\nâ        bit_count = def bit_count(): Number of  â\nâ                    ones in the binary          â\nâ                    representation of the       â\nâ                    absolute value of self.     â\nâ       bit_length = def bit_length(): Number of â\nâ                    bits necessary to represent â\nâ                    self in binary.             â\nâ        conjugate = def conjugate(): Returns    â\nâ                    self, the complex conjugate â\nâ                    of any int.                 â\nâ       from_bytes = def from_bytes(bytes,       â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return the   â\nâ                    integer represented by the  â\nâ                    given array of bytes.       â\nâ       is_integer = def is_integer(): Returns   â\nâ                    True. Exists for duck type  â\nâ                    compatibility with          â\nâ                    float.is_integer.           â\nâ         to_bytes = def to_bytes(length=1,      â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return an    â\nâ                    array of bytes representing â\nâ                    an integer.                 â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n" == "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\nâ int([x]) -> integer                            â\nâ int(x, base=10) -> integer                     â\nâ                                                â\nâ      denominator = 1                           â\nâ             imag = 0                           â\nâ        numerator = 1                           â\nâ             real = 1                           â\nâ as_integer_ratio = def as_integer_ratio():     â\nâ                    Return integer ratio.       â\nâ       bit_length = def bit_length(): Number of â\nâ                    bits necessary to represent â\nâ                    self in binary.             â\nâ        conjugate = def conjugate(...) Returns  â\nâ                    self, the complex conjugate â\nâ                    of any int.                 â\nâ       from_bytes = def from_bytes(bytes,       â\nâ                    byteorder, *,               â\nâ                    signed=False): Return the   â\nâ                    integer represented by the  â\nâ                    given array of bytes.       â\nâ         to_bytes = def to_bytes(length,        â\nâ                    byteorder, *,               â\nâ                    signed=False): Return an    â\nâ                    array of bytes representing â\nâ                    an integer.                 â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n"
  
    â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®
    â int([x]) -> integer                            â
    â int(x, base=10) -> integer                     â
    â                                                â
    â      denominator = 1                           â
    â             imag = 0                           â
    â        numerator = 1                           â
    â             real = 1                           â
    â as_integer_ratio = def as_integer_ratio():     â
  - â                    Return integer ratio.       â
  ?                                    ^^^^^^^^^^^^
  + â                    Return a pair of integers,  â
  ?                            ++++++++++        ^^
  + â                    whose ratio is equal to the â
  + â                    original int.               â
  + â        bit_count = def bit_count(): Number of  â
  + â                    ones in the binary          â
  + â                    representation of the       â
  + â                    absolute value of self.     â
    â       bit_length = def bit_length(): Number of â
    â                    bits necessary to represent â
    â                    self in binary.             â
  - â        conjugate = def conjugate(...) Returns  â
  ?                                    ---
  + â        conjugate = def conjugate(): Returns    â
  ?                                     +          ++
    â                    self, the complex conjugate â
    â                    of any int.                 â
    â       from_bytes = def from_bytes(bytes,       â
  - â                    byteorder, *,               â
  ?                                            ------
  + â                    byteorder='big', *,         â
  ?                               ++++++
    â                    signed=False): Return the   â
    â                    integer represented by the  â
    â                    given array of bytes.       â
  + â       is_integer = def is_integer(): Returns   â
  + â                    True. Exists for duck type  â
  + â                    compatibility with          â
  + â                    float.is_integer.           â
  - â         to_bytes = def to_bytes(length,        â
  ?                                          --
  + â         to_bytes = def to_bytes(length=1,      â
  ?                                         ++
  - â                    byteorder, *,               â
  ?                                            ------
  + â                    byteorder='big', *,         â
  ?                               ++++++
    â                    signed=False): Return an    â
    â                    array of bytes representing â
    â                    an integer.                 â
    â°âââââââââââââââââââââââââââââââââââââââââââââââââ¯
FAILED tests/test_inspect.py::test_inspect_integer_with_methods_python310only - assert "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\nâ int([x]) -> integer                            â\nâ int(x, base=10) -> integer                     â\nâ                                                â\nâ      denominator = 1                           â\nâ             imag = 0                           â\nâ        numerator = 1                           â\nâ             real = 1                           â\nâ as_integer_ratio = def as_integer_ratio():     â\nâ                    Return a pair of integers,  â\nâ                    whose ratio is equal to the â\nâ                    original int.               â\nâ        bit_count = def bit_count(): Number of  â\nâ                    ones in the binary          â\nâ                    representation of the       â\nâ                    absolute value of self.     â\nâ       bit_length = def bit_length(): Number of â\nâ                    bits necessary to represent â\nâ                    self in binary.             â\nâ        conjugate = def conjugate(): Returns    â\nâ                    self, the complex conjugate â\nâ                    of any int.                 â\nâ       from_bytes = def from_bytes(bytes,       â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return the   â\nâ                    integer represented by the  â\nâ                    given array of bytes.       â\nâ       is_integer = def is_integer(): Returns   â\nâ                    True. Exists for duck type  â\nâ                    compatibility with          â\nâ                    float.is_integer.           â\nâ         to_bytes = def to_bytes(length=1,      â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return an    â\nâ                    array of bytes representing â\nâ                    an integer.                 â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n" == "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\nâ int([x]) -> integer                            â\nâ int(x, base=10) -> integer                     â\nâ                                                â\nâ      denominator = 1                           â\nâ             imag = 0                           â\nâ        numerator = 1                           â\nâ             real = 1                           â\nâ as_integer_ratio = def as_integer_ratio():     â\nâ                    Return integer ratio.       â\nâ        bit_count = def bit_count(): Number of  â\nâ                    ones in the binary          â\nâ                    representation of the       â\nâ                    absolute value of self.     â\nâ       bit_length = def bit_length(): Number of â\nâ                    bits necessary to represent â\nâ                    self in binary.             â\nâ        conjugate = def conjugate(...) Returns  â\nâ                    self, the complex conjugate â\nâ                    of any int.                 â\nâ       from_bytes = def from_bytes(bytes,       â\nâ                    byteorder, *,               â\nâ                    signed=False): Return the   â\nâ                    integer represented by the  â\nâ                    given array of bytes.       â\nâ         to_bytes = def to_bytes(length,        â\nâ                    byteorder, *,               â\nâ                    signed=False): Return an    â\nâ                    array of bytes representing â\nâ                    an integer.                 â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n"
  
    â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®
    â int([x]) -> integer                            â
    â int(x, base=10) -> integer                     â
    â                                                â
    â      denominator = 1                           â
    â             imag = 0                           â
    â        numerator = 1                           â
    â             real = 1                           â
    â as_integer_ratio = def as_integer_ratio():     â
  - â                    Return integer ratio.       â
  ?                                    ^^^^^^^^^^^^
  + â                    Return a pair of integers,  â
  ?                            ++++++++++        ^^
  + â                    whose ratio is equal to the â
  + â                    original int.               â
    â        bit_count = def bit_count(): Number of  â
    â                    ones in the binary          â
    â                    representation of the       â
    â                    absolute value of self.     â
    â       bit_length = def bit_length(): Number of â
    â                    bits necessary to represent â
    â                    self in binary.             â
  - â        conjugate = def conjugate(...) Returns  â
  ?                                    ---
  + â        conjugate = def conjugate(): Returns    â
  ?                                     +          ++
    â                    self, the complex conjugate â
    â                    of any int.                 â
    â       from_bytes = def from_bytes(bytes,       â
  - â                    byteorder, *,               â
  ?                                            ------
  + â                    byteorder='big', *,         â
  ?                               ++++++
    â                    signed=False): Return the   â
    â                    integer represented by the  â
    â                    given array of bytes.       â
  + â       is_integer = def is_integer(): Returns   â
  + â                    True. Exists for duck type  â
  + â                    compatibility with          â
  + â                    float.is_integer.           â
  - â         to_bytes = def to_bytes(length,        â
  ?                                          --
  + â         to_bytes = def to_bytes(length=1,      â
  ?                                         ++
  - â                    byteorder, *,               â
  ?                                            ------
  + â                    byteorder='big', *,         â
  ?                               ++++++
    â                    signed=False): Return an    â
    â                    array of bytes representing â
    â                    an integer.                 â
    â°âââââââââââââââââââââââââââââââââââââââââââââââââ¯
FAILED tests/test_inspect.py::test_inspect_integer_with_methods_python311 - assert "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\nâ int([x]) -> integer                            â\nâ int(x, base=10) -> integer                     â\nâ                                                â\nâ      denominator = 1                           â\nâ             imag = 0                           â\nâ        numerator = 1                           â\nâ             real = 1                           â\nâ as_integer_ratio = def as_integer_ratio():     â\nâ                    Return a pair of integers,  â\nâ                    whose ratio is equal to the â\nâ                    original int.               â\nâ        bit_count = def bit_count(): Number of  â\nâ                    ones in the binary          â\nâ                    representation of the       â\nâ                    absolute value of self.     â\nâ       bit_length = def bit_length(): Number of â\nâ                    bits necessary to represent â\nâ                    self in binary.             â\nâ        conjugate = def conjugate(): Returns    â\nâ                    self, the complex conjugate â\nâ                    of any int.                 â\nâ       from_bytes = def from_bytes(bytes,       â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return the   â\nâ                    integer represented by the  â\nâ                    given array of bytes.       â\nâ       is_integer = def is_integer(): Returns   â\nâ                    True. Exists for duck type  â\nâ                    compatibility with          â\nâ                    float.is_integer.           â\nâ         to_bytes = def to_bytes(length=1,      â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return an    â\nâ                    array of bytes representing â\nâ                    an integer.                 â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n" == "â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®\nâ int([x]) -> integer                            â\nâ int(x, base=10) -> integer                     â\nâ                                                â\nâ      denominator = 1                           â\nâ             imag = 0                           â\nâ        numerator = 1                           â\nâ             real = 1                           â\nâ as_integer_ratio = def as_integer_ratio():     â\nâ                    Return integer ratio.       â\nâ        bit_count = def bit_count(): Number of  â\nâ                    ones in the binary          â\nâ                    representation of the       â\nâ                    absolute value of self.     â\nâ       bit_length = def bit_length(): Number of â\nâ                    bits necessary to represent â\nâ                    self in binary.             â\nâ        conjugate = def conjugate(...) Returns  â\nâ                    self, the complex conjugate â\nâ                    of any int.                 â\nâ       from_bytes = def from_bytes(bytes,       â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return the   â\nâ                    integer represented by the  â\nâ                    given array of bytes.       â\nâ         to_bytes = def to_bytes(length=1,      â\nâ                    byteorder='big', *,         â\nâ                    signed=False): Return an    â\nâ                    array of bytes representing â\nâ                    an integer.                 â\nâ°âââââââââââââââââââââââââââââââââââââââââââââââââ¯\n"
  
    â­ââââââââââââââââ <class 'int'> ââââââââââââââââââ®
    â int([x]) -> integer                            â
    â int(x, base=10) -> integer                     â
    â                                                â
    â      denominator = 1                           â
    â             imag = 0                           â
    â        numerator = 1                           â
    â             real = 1                           â
    â as_integer_ratio = def as_integer_ratio():     â
  - â                    Return integer ratio.       â
  ?                                    ^^^^^^^^^^^^
  + â                    Return a pair of integers,  â
  ?                            ++++++++++        ^^
  + â                    whose ratio is equal to the â
  + â                    original int.               â
    â        bit_count = def bit_count(): Number of  â
    â                    ones in the binary          â
    â                    representation of the       â
    â                    absolute value of self.     â
    â       bit_length = def bit_length(): Number of â
    â                    bits necessary to represent â
    â                    self in binary.             â
  - â        conjugate = def conjugate(...) Returns  â
  ?                                    ---
  + â        conjugate = def conjugate(): Returns    â
  ?                                     +          ++
    â                    self, the complex conjugate â
    â                    of any int.                 â
    â       from_bytes = def from_bytes(bytes,       â
    â                    byteorder='big', *,         â
    â                    signed=False): Return the   â
    â                    integer represented by the  â
    â                    given array of bytes.       â
  + â       is_integer = def is_integer(): Returns   â
  + â                    True. Exists for duck type  â
  + â                    compatibility with          â
  + â                    float.is_integer.           â
    â         to_bytes = def to_bytes(length=1,      â
    â                    byteorder='big', *,         â
    â                    signed=False): Return an    â
    â                    array of bytes representing â
    â                    an integer.                 â
    â°âââââââââââââââââââââââââââââââââââââââââââââââââ¯
FAILED tests/test_markdown.py::test_inline_code - AssertionError: assert 'inline \x1b[1;38;2;170;34;255;48;2;248;248;248mimport\x1b[0m\x1b[38;2;187;187;187;48;2;248;248;248m \x1b[0m\x1b[1;38;2;0;0;255;48;2;248;248;248mthis\x1b[0m code                                                                             \n' == 'inline \x1b[1;38;2;170;34;255;48;2;248;248;248mimport\x1b[0m\x1b[38;2;0;0;0;48;2;248;248;248m \x1b[0m\x1b[1;38;2;0;0;255;48;2;248;248;248mthis\x1b[0m code                                                                             \n'
  
  - inline import this code                                                                             
  ?                                                              ^^^^^^^^^^^^^^^^^^^^^^^
  + inline import this code                                                                             
  ?                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
FAILED tests/test_pretty.py::test_attrs_broken - assert 'Foo(\n    bar=AttributeError("\'tests.test_pretty.test_attrs_broken.<locals>.Foo\' object has no attribute \'bar\'")\n)' == "Foo(bar=AttributeError('bar'))"
  
  - Foo(bar=AttributeError('bar'))
  + Foo(
  +     bar=AttributeError("'tests.test_pretty.test_attrs_broken.<locals>.Foo' object has no attribute 'bar'")
  + )
FAILED tests/test_syntax.py::test_blank_lines - AssertionError: assert '\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m1 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m2 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m3 \x1b[0m\x1b[1;38;2;0;128;0;48;2;248;248;248mimport\x1b[0m\x1b[38;2;187;187;187;48;2;248;248;248m \x1b[0m\x1b[1;38;2;0;0;255;48;2;248;248;248mthis\x1b[0m\x1b[48;2;248;248;248m                   \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m4 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m5 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n' == '\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m1 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m2 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m3 \x1b[0m\x1b[1;38;2;0;128;0;48;2;248;248;248mimport\x1b[0m\x1b[38;2;0;0;0;48;2;248;248;248m \x1b[0m\x1b[1;38;2;0;0;255;48;2;248;248;248mthis\x1b[0m\x1b[48;2;248;248;248m                   \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m4 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n\x1b[1;38;2;24;24;24;48;2;248;248;248m  \x1b[0m\x1b[38;2;173;173;173;48;2;248;248;248m5 \x1b[0m\x1b[48;2;248;248;248m                              \x1b[0m\n'
  
      1                               
      2                               
  -   3 import this                   
  ?                                                                                                                                       ^^^^^^^^^^^^^^^^^^^^^^^
  +   3 import this                   
  ?                                                                                                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      4                               
      5                               
FAILED tests/test_syntax.py::test_python_render_simple_indent_guides - assert '\x1b[34mdef\x1b[0m\x1b[37m \x1b[0m\x1b[32mloop_first_last\x1b[0m(values: Iterable[T]) -> Iterable[Tuple[\x1b[36mb\x1b[0m\n\x1b[2;37mâ   \x1b[0m\x1b[33m"""Iterate and generate a tuple with a flag for first an\x1b[0m\n\x1b[2mâ   \x1b[0miter_values = \x1b[36miter\x1b[0m(values)\n\x1b[2mâ   \x1b[0m\x1b[34mtry\x1b[0m:\n\x1b[2mâ   â   \x1b[0mprevious_value = \x1b[36mnext\x1b[0m(iter_values)\n\x1b[2mâ   \x1b[0m\x1b[34mexcept\x1b[0m \x1b[36mStopIteration\x1b[0m:\n\x1b[2mâ   â   \x1b[0m\x1b[34mreturn\x1b[0m\n\x1b[2mâ   \x1b[0mfirst = \x1b[34mTrue\x1b[0m\n\x1b[2mâ   \x1b[0m\x1b[34mfor\x1b[0m value \x1b[35min\x1b[0m iter_values:\n\x1b[2mâ   â   \x1b[0m\x1b[34myield\x1b[0m first, \x1b[34mFalse\x1b[0m, previous_value\n\x1b[2mâ   â   \x1b[0mfirst = \x1b[34mFalse\x1b[0m\n\x1b[2mâ   â   \x1b[0mprevious_value = value\n\x1b[2mâ   \x1b[0m\x1b[34myield\x1b[0m first, \x1b[34mTrue\x1b[0m, previous_value\n' == '\x1b[34mdef\x1b[0m \x1b[32mloop_first_last\x1b[0m(values: Iterable[T]) -> Iterable[Tuple[\x1b[36mb\x1b[0m\n\x1b[2;37mâ   \x1b[0m\x1b[33m"""Iterate and generate a tuple with a flag for first an\x1b[0m\n\x1b[2mâ   \x1b[0miter_values = \x1b[36miter\x1b[0m(values)\n\x1b[2mâ   \x1b[0m\x1b[34mtry\x1b[0m:\n\x1b[2mâ   â   \x1b[0mprevious_value = \x1b[36mnext\x1b[0m(iter_values)\n\x1b[2mâ   \x1b[0m\x1b[34mexcept\x1b[0m \x1b[36mStopIteration\x1b[0m:\n\x1b[2mâ   â   \x1b[0m\x1b[34mreturn\x1b[0m\n\x1b[2mâ   \x1b[0mfirst = \x1b[34mTrue\x1b[0m\n\x1b[2mâ   \x1b[0m\x1b[34mfor\x1b[0m value \x1b[35min\x1b[0m iter_values:\n\x1b[2mâ   â   \x1b[0m\x1b[34myield\x1b[0m first, \x1b[34mFalse\x1b[0m, previous_value\n\x1b[2mâ   â   \x1b[0mfirst = \x1b[34mFalse\x1b[0m\n\x1b[2mâ   â   \x1b[0mprevious_value = value\n\x1b[2mâ   \x1b[0m\x1b[34myield\x1b[0m first, \x1b[34mTrue\x1b[0m, previous_value\n'
  
  - def loop_first_last(values: Iterable[T]) -> Iterable[Tuple[b
  ?             ^
  + def loop_first_last(values: Iterable[T]) -> Iterable[Tuple[b
  ?             ^^^^^^^^^^
    â   """Iterate and generate a tuple with a flag for first an
    â   iter_values = iter(values)
    â   try:
    â   â   previous_value = next(iter_values)
    â   except StopIteration:
    â   â   return
    â   first = True
    â   for value in iter_values:
    â   â   yield first, False, previous_value
    â   â   first = False
    â   â   previous_value = value
    â   yield first, True, previous_value]: [Once again, all failed tests are summarized with only the error lines.]
=============
[=========== 8 failed, 847 passed, 20 skipped, 1 deselected in 4.63s ============]: [8 tests of the package test suite failed. The build failed because the test run was not successful.]
=============
[error: Bad exit status from /var/tmp/rpm-tmp.NbLFbP (%check)]: [Tests are the part of the %check section of the rpm build. The tests failed, ergo the %check section was the one where the build failure happened.]
=============
[INFO: Cleaning up build root ('cleanup_on_failure=True')]: [The last indicator of the failed build ('cleanup_on_failure=True')]

Issue: The build failed because the test suite which is a part of the %check section of the package failed. 8 tests failed, which means the whole test run wasn't successful.
Resolution: Depending on the failure, different approaches are possible.
Some of the tests contain decorators telling to skip the test with Pythons newer than 3.9. We run the tests with Python 3.14 but none of the tests contained a decorator for skipping the version. For tests that had @skip_py313, @skip_py312, @skip_py311 ... we can assume that the tests are meant to be skipped with Python 3.14 too. To fix them, we need to define and add a new decorator @skip_py314 in the source code of the package.

For other tests, it's crucial to determine whether the failure comes from differing versions of dependencies (e.g. pygments), causing the difference in rendered and expected outputs. When knowing that, the tests should be adjusted to expect the actual rendered output or skipped with the particular version of dependency (e.g. pygments, or Python).
When the test run is successful, the build will succeed.