updates

Backend/venv/lib/python3.12/site-packages/_pytest/assertion/truncate.py

@@ -1,65 +1,51 @@
 """Utilities for truncating assertion output.
 
 Current default behaviour is to truncate assertion explanations at
-terminal lines, unless running with an assertions verbosity level of at least 2 or running on CI.
+~8 terminal lines, unless running in "-vv" mode or running on CI.
 """
+from typing import List
+from typing import Optional
 
-from __future__ import annotations
-
-from _pytest.compat import running_on_ci
-from _pytest.config import Config
+from _pytest.assertion import util
 from _pytest.nodes import Item
 
 
 DEFAULT_MAX_LINES = 8
-DEFAULT_MAX_CHARS = DEFAULT_MAX_LINES * 80
+DEFAULT_MAX_CHARS = 8 * 80
 USAGE_MSG = "use '-vv' to show"
 
 
-def truncate_if_required(explanation: list[str], item: Item) -> list[str]:
+def truncate_if_required(
+    explanation: List[str], item: Item, max_length: Optional[int] = None
+) -> List[str]:
     """Truncate this assertion explanation if the given test item is eligible."""
-    should_truncate, max_lines, max_chars = _get_truncation_parameters(item)
-    if should_truncate:
-        return _truncate_explanation(
-            explanation,
-            max_lines=max_lines,
-            max_chars=max_chars,
-        )
+    if _should_truncate_item(item):
+        return _truncate_explanation(explanation)
     return explanation
 
 
-def _get_truncation_parameters(item: Item) -> tuple[bool, int, int]:
-    """Return the truncation parameters related to the given item, as (should truncate, max lines, max chars)."""
-    # We do not need to truncate if one of conditions is met:
-    # 1. Verbosity level is 2 or more;
-    # 2. Test is being run in CI environment;
-    # 3. Both truncation_limit_lines and truncation_limit_chars
-    #    .ini parameters are set to 0 explicitly.
-    max_lines = item.config.getini("truncation_limit_lines")
-    max_lines = int(max_lines if max_lines is not None else DEFAULT_MAX_LINES)
-
-    max_chars = item.config.getini("truncation_limit_chars")
-    max_chars = int(max_chars if max_chars is not None else DEFAULT_MAX_CHARS)
-
-    verbose = item.config.get_verbosity(Config.VERBOSITY_ASSERTIONS)
-
-    should_truncate = verbose < 2 and not running_on_ci()
-    should_truncate = should_truncate and (max_lines > 0 or max_chars > 0)
-
-    return should_truncate, max_lines, max_chars
+def _should_truncate_item(item: Item) -> bool:
+    """Whether or not this test item is eligible for truncation."""
+    verbose = item.config.option.verbose
+    return verbose < 2 and not util.running_on_ci()
 
 
 def _truncate_explanation(
-    input_lines: list[str],
-    max_lines: int,
-    max_chars: int,
-) -> list[str]:
+    input_lines: List[str],
+    max_lines: Optional[int] = None,
+    max_chars: Optional[int] = None,
+) -> List[str]:
     """Truncate given list of strings that makes up the assertion explanation.
 
-    Truncates to either max_lines, or max_chars - whichever the input reaches
+    Truncates to either 8 lines, or 640 characters - whichever the input reaches
     first, taking the truncation explanation into account. The remaining lines
     will be replaced by a usage message.
     """
+    if max_lines is None:
+        max_lines = DEFAULT_MAX_LINES
+    if max_chars is None:
+        max_chars = DEFAULT_MAX_CHARS
+
     # Check if truncation required
     input_char_count = len("".join(input_lines))
     # The length of the truncation explanation depends on the number of lines
@@ -84,23 +70,16 @@ def _truncate_explanation(
     ):
         return input_lines
     # Truncate first to max_lines, and then truncate to max_chars if necessary
-    if max_lines > 0:
-        truncated_explanation = input_lines[:max_lines]
-    else:
-        truncated_explanation = input_lines
+    truncated_explanation = input_lines[:max_lines]
     truncated_char = True
     # We reevaluate the need to truncate chars following removal of some lines
-    if len("".join(truncated_explanation)) > tolerable_max_chars and max_chars > 0:
+    if len("".join(truncated_explanation)) > tolerable_max_chars:
         truncated_explanation = _truncate_by_char_count(
             truncated_explanation, max_chars
         )
     else:
         truncated_char = False
 
-    if truncated_explanation == input_lines:
-        # No truncation happened, so we do not need to add any explanations
-        return truncated_explanation
-
     truncated_line_count = len(input_lines) - len(truncated_explanation)
     if truncated_explanation[-1]:
         # Add ellipsis and take into account part-truncated final line
@@ -111,15 +90,14 @@ def _truncate_explanation(
     else:
         # Add proper ellipsis when we were able to fit a full line exactly
         truncated_explanation[-1] = "..."
-    return [
-        *truncated_explanation,
+    return truncated_explanation + [
         "",
         f"...Full output truncated ({truncated_line_count} line"
         f"{'' if truncated_line_count == 1 else 's'} hidden), {USAGE_MSG}",
     ]
 
 
-def _truncate_by_char_count(input_lines: list[str], max_chars: int) -> list[str]:
+def _truncate_by_char_count(input_lines: List[str], max_chars: int) -> List[str]:
     # Find point at which input length exceeds total allowed length
     iterated_char_count = 0
     for iterated_index, input_line in enumerate(input_lines):