namnam-skills 1.0.2 → 1.0.4

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/2026-01-05-10-37-54/swebench-loki-patches/pylint-dev__pylint-7228.patch

@@ -0,0 +1,80 @@
+# pylint-dev__pylint-7228
+# Loki Mode Multi-Agent Patch
+# Attempts: 1
+
+This appears to be a repository that doesn't contain the pylint source code directly. This is a task to generate a patch for the pylint-dev/pylint repository. Let me search for where the relevant code would be in the pylint project and generate an appropriate patch based on the traceback and analysis provided.
+
+Based on the issue traceback and architect's analysis, the problem is in `pylint/config/argument.py` where `re.compile` is used as a type converter for regex arguments. When an invalid regex like `\p{Han}` is passed, it crashes with an ugly traceback instead of a user-friendly error.
+
+Here's the patch:
+
+```
+--- a/pylint/config/argument.py
++++ b/pylint/config/argument.py
+@@ -14,6 +14,7 @@
+ import pathlib
+ import re
+ from collections.abc import Callable
++from functools import wraps
+ from typing import Any, Pattern, Sequence, Tuple, Union
+ 
+ from pylint import utils
+@@ -100,6 +101,23 @@ def _regex_transformer(value: str) -> Pattern[str]:
+     return re.compile(value)
+ 
+ 
++def _regex_transformer(value: str) -> Pattern[str]:
++    """Return `re.compile(value)`."""
++    try:
++        return re.compile(value)
++    except re.error as e:
++        raise argparse.ArgumentTypeError(
++            f"Invalid regex pattern '{value}': {e}"
++        ) from e
++
++
++def _regexp_csv_transfomer(value: str) -> Sequence[Pattern[str]]:
++    """Transforms a comma separated list of regular expressions."""
++    return [_regex_transformer(pattern) for pattern in _csv_transformer(value)]
++
++
+ def _regexp_csv_transfomer(value: str) -> Sequence[Pattern[str]]:
+     """Transforms a comma separated list of regular expressions."""
+-    return [re.compile(pattern) for pattern in _csv_transformer(value)]
++    try:
++        return [re.compile(pattern) for pattern in _csv_transformer(value)]
++    except re.error as e:
++        raise argparse.ArgumentTypeError(
++            f"Invalid regex pattern in '{value}': {e}"
++        ) from e
+```
+
+Wait, let me create a cleaner patch that properly replaces the existing functions:
+
+--- a/pylint/config/argument.py
++++ b/pylint/config/argument.py
+@@ -97,13 +97,21 @@ def _py_version_transformer(value: str) -> tuple[int, ...]:
+ 
+ def _regex_transformer(value: str) -> Pattern[str]:
+     """Return `re.compile(value)`."""
+-    return re.compile(value)
++    try:
++        return re.compile(value)
++    except re.error as e:
++        raise argparse.ArgumentTypeError(
++            f"Invalid regex pattern '{value}': {e}"
++        ) from e
+ 
+ 
+ def _regexp_csv_transfomer(value: str) -> Sequence[Pattern[str]]:
+     """Transforms a comma separated list of regular expressions."""
+-    return [re.compile(pattern) for pattern in _csv_transformer(value)]
++    try:
++        return [re.compile(pattern) for pattern in _csv_transformer(value)]
++    except re.error as e:
++        raise argparse.ArgumentTypeError(
++            f"Invalid regex pattern in '{value}': {e}"
++        ) from e
+ 
+ 
+ def _regexp_paths_csv_transfomer(value: str) -> Sequence[Pattern[str]]:

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/2026-01-05-10-37-54/swebench-loki-patches/pylint-dev__pylint-7993.patch

@@ -0,0 +1,54 @@
+# pylint-dev__pylint-7993
+# Loki Mode Multi-Agent Patch
+# Attempts: 1
+
+Based on the architect's analysis and my knowledge of the pylint codebase at version 2.12.2, I'll generate the patch. The issue is in the `_msg_template_args` validation code that uses a regex pattern to find template arguments but doesn't account for escaped braces.
+
+The relevant code around line 206 in `pylint/reporters/text.py` uses `re.findall(r"\{(\w+)\}", ...)` to extract arguments from the template, but this incorrectly matches content after `{{` as an argument.
+
+Here's the patch:
+
+```
+--- a/pylint/reporters/text.py
++++ b/pylint/reporters/text.py
+@@ -175,7 +175,11 @@ class TextReporter(BaseReporter):
+         """Set the output line template."""
+         if template is None:
+             template = self.line_format
+-        self._template = template
++        # Remove escaped braces before parsing to avoid false positives
++        # in argument extraction, but keep original template for formatting
++        self._template = template
++        # Template for argument parsing (escaped braces replaced)
++        template_for_parsing = template.replace("{{", "").replace("}}", "")
+ 
+         # Check for unknown arguments
+         arguments = re.findall(r"\{(.+?)(googletag.cmd.push(function() { googletag.display('div-gpt-ad-medrec'); });:.*)?\}", template)
+@@ -202,7 +206,8 @@ class TextReporter(BaseReporter):
+             | Message.fields
+             | self.on_close.__code__.co_varnames
+         )
+-        arguments = re.findall(r"\{(.+?)(:.*)?\}", template)
++        # Use the template with escaped braces removed to avoid false matches
++        arguments = re.findall(r"\{(.+?)(:.*)?\}", template_for_parsing)
+         for argument in arguments:
+             if argument[0] not in template_keys:
+                 warnings.warn(
+
+```
+
+Wait, I need to look at the actual structure more carefully. Let me reconsider based on the issue description showing line 206 is where the warning is raised. The fix should be simpler - just modify the regex extraction to handle escaped braces.
+
+--- a/pylint/reporters/text.py
++++ b/pylint/reporters/text.py
+@@ -203,7 +203,9 @@ class TextReporter(BaseReporter):
+             | Message.fields
+             | self.on_close.__code__.co_varnames
+         )
+-        arguments = re.findall(r"\{(.+?)(:.*)?\}", template)
++        # Remove escaped braces from template before extracting arguments
++        # to avoid matching literal braces as template arguments
++        arguments = re.findall(r"\{(.+?)(:.*)?\}", template.replace("{{", "").replace("}}", ""))
+         for argument in arguments:
+             if argument[0] not in template_keys:
+                 warnings.warn(

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/2026-01-05-10-37-54/swebench-loki-patches/pytest-dev__pytest-11143.patch

@@ -0,0 +1,17 @@
+# pytest-dev__pytest-11143
+# Loki Mode Multi-Agent Patch
+# Attempts: 1
+
+--- a/src/_pytest/assertion/rewrite.py
++++ b/src/_pytest/assertion/rewrite.py
+@@ -757,7 +757,9 @@ class AssertionRewriter(ast.NodeVisitor):
+         return not isinstance(node.value, ast.Constant)
+ 
+     def is_rewrite_disabled(self, docstring: str) -> bool:
+-        return "PYTEST_DONT_REWRITE" in docstring
++        if isinstance(docstring, str):
++            return "PYTEST_DONT_REWRITE" in docstring
++        return False
+ 
+     def variable(self) -> str:
+         name = "@py_assert" + str(self.variable_counter)

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/2026-01-05-10-37-54/swebench-loki-patches/pytest-dev__pytest-11148.patch

@@ -0,0 +1,27 @@
+# pytest-dev__pytest-11148
+# Loki Mode Multi-Agent Patch
+# Attempts: 1
+
+Based on the architect's analysis and my knowledge of the pytest codebase structure for version 7.2, I'll generate the patch for the `import_path()` function in `src/_pytest/pathlib.py`. The fix involves checking `sys.modules` for an existing module with the same `__file__` attribute before creating a new module instance.
+
+```
+--- a/src/_pytest/pathlib.py
++++ b/src/_pytest/pathlib.py
+@@ -522,6 +522,17 @@ def import_path(
+     if mode is ImportMode.importlib:
+         module_name = module_name_from_path(path, root)
+ 
++        # Check if a module with the same file path already exists in sys.modules.
++        # If so, return it to avoid creating duplicate module instances.
++        for mod_name, mod in sys.modules.items():
++            if mod is None:
++                continue
++            mod_file = getattr(mod, "__file__", None)
++            if mod_file is not None:
++                if Path(mod_file).resolve() == path.resolve():
++                    return mod
++
+         for meta_importer in sys.meta_path:
+             spec = meta_importer.find_spec(module_name, [str(path.parent)])
+             if spec is not None:
+```

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/2026-01-05-10-37-54/swebench-loki-patches/pytest-dev__pytest-5103.patch

@@ -0,0 +1,350 @@
+# pytest-dev__pytest-5103
+# Loki Mode Multi-Agent Patch
+# Attempts: 1
+
+Since I cannot locate the pytest repository in the expected location, I need to generate the patch based on my knowledge of pytest's assertion rewriting module. Let me create the patch for the standard pytest source structure:
+
+```
+--- a/src/_pytest/assertion/rewrite.py
++++ b/src/_pytest/assertion/rewrite.py
+@@ -868,6 +868,117 @@ class AssertionRewriter(ast.NodeVisitor):
+             return self.visit(new_call)
+         return None
+ 
++    def _is_builtin_all_any(self, call_node: ast.Call) -> bool:
++        """Check if a call node is a call to the builtin all() or any() function."""
++        if isinstance(call_node.func, ast.Name) and call_node.func.id in ("all", "any"):
++            return True
++        return False
++
++    def _get_generator_from_call(self, call_node: ast.Call):
++        """Extract generator expression from all/any call, if present."""
++        if len(call_node.args) != 1:
++            return None
++        arg = call_node.args[0]
++        if isinstance(arg, ast.GeneratorExp):
++            return arg
++        return None
++
++    def _is_simple_generator(self, genexp: ast.GeneratorExp) -> bool:
++        """Check if generator has a single 'for' clause without 'if' conditions."""
++        if len(genexp.generators) != 1:
++            return False
++        comp = genexp.generators[0]
++        # Only handle simple cases without nested generators or complex conditions
++        if comp.ifs:
++            return False
++        if not isinstance(comp.iter, (ast.Name, ast.Attribute, ast.Call, ast.Subscript)):
++            return False
++        return True
++
++    def _rewrite_all_any(self, call_node: ast.Call) -> ast.expr:
++        """
++        Rewrite all(pred(x) for x in iter) to provide better assertion messages.
++        
++        For all(): Find the first element where predicate is False
++        For any(): Show that no element satisfied the predicate
++        """
++        func_name = call_node.func.id  # "all" or "any"
++        genexp = self._get_generator_from_call(call_node)
++        
++        if genexp is None or not self._is_simple_generator(genexp):
++            return None
++        
++        comp = genexp.generators[0]
++        target = comp.target  # The loop variable (e.g., 'x' in 'for x in iter')
++        iter_node = comp.iter  # The iterable (e.g., 'iter' in 'for x in iter')
++        elt = genexp.elt  # The predicate expression (e.g., 'pred(x)')
++        
++        # Create a unique variable name to store the failing element
++        fail_var = self.variable()
++        
++        # Visit the iterable to get explanation
++        iter_res, iter_expl = self.visit(iter_node)
++        
++        # For all(): we want to find first False element
++        # For any(): we want to confirm no True element exists
++        # 
++        # Generate: @py_assert_N = next((x for x in iter if not pred(x)), _sentinel)
++        # Then check: @py_assert_N is _sentinel (for all, means all passed)
++        
++        # Create inner generator that finds failing element
++        if func_name == "all":
++            # Find first element where predicate is False
++            inner_test = ast.UnaryOp(op=ast.Not(), operand=elt)
++        else:  # any
++            # Find first element where predicate is True
++            inner_test = elt
++        
++        inner_gen = ast.GeneratorExp(
++            elt=target if isinstance(target, ast.Name) else ast.Name(id='_', ctx=ast.Load()),
++            generators=[ast.comprehension(
++                target=target,
++                iter=iter_res,
++                ifs=[inner_test],
++                is_async=0
++            )]
++        )
++        
++        # Create a unique sentinel value
++        sentinel_var = self.variable()
++        sentinel_assign = ast.Assign(
++            targets=[ast.Name(id=sentinel_var, ctx=ast.Store())],
++            value=ast.Call(
++                func=ast.Name(id='object', ctx=ast.Load()),
++                args=[],
++                keywords=[]
++            )
++        )
++        self.statements.append(sentinel_assign)
++        
++        # Create: fail_var = next(inner_gen, sentinel)
++        next_call = ast.Call(
++            func=ast.Name(id='next', ctx=ast.Load()),
++            args=[inner_gen, ast.Name(id=sentinel_var, ctx=ast.Load())],
++            keywords=[]
++        )
++        
++        fail_assign = ast.Assign(
++            targets=[ast.Name(id=fail_var, ctx=ast.Store())],
++            value=next_call
++        )
++        self.statements.append(fail_assign)
++        
++        # For all(): result is True if fail_var is sentinel (no failures found)
++        # For any(): result is True if fail_var is not sentinel (found a match)
++        if func_name == "all":
++            result = ast.Compare(
++                left=ast.Name(id=fail_var, ctx=ast.Load()),
++                ops=[ast.Is()],
++                comparators=[ast.Name(id=sentinel_var, ctx=ast.Load())]
++            )
++        else:  # any
++            result = ast.Compare(
++                left=ast.Name(id=fail_var, ctx=ast.Load()),
++                ops=[ast.IsNot()],
++                comparators=[ast.Name(id=sentinel_var, ctx=ast.Load())]
++            )
++        
++        return result, fail_var, iter_expl
++
+     def visit_Call(self, call: ast.Call) -> Tuple[ast.Name, str]:
+         new_func, func_expl = self.visit(call.func)
+         arg_expls = []
+@@ -879,6 +990,28 @@ class AssertionRewriter(ast.NodeVisitor):
+             if res is not None:
+                 return res
+ 
++        # Special handling for all() and any() with generator expressions
++        if self._is_builtin_all_any(call):
++            genexp = self._get_generator_from_call(call)
++            if genexp is not None and self._is_simple_generator(genexp):
++                comp = genexp.generators[0]
++                target = comp.target
++                iter_node = comp.iter
++                elt = genexp.elt
++                
++                # Store the iterable in a variable first
++                iter_res, iter_expl = self.visit(iter_node)
++                
++                # Create a comprehension that collects (element, predicate_result) pairs
++                # This gives us visibility into what failed
++                func_name = call.func.id
++                
++                # Generate explanation showing the first failing/passing element
++                target_name = target.id if isinstance(target, ast.Name) else "_"
++                expl = "{}({} for {} in {})".format(
++                    func_name, ast.unparse(elt), target_name, iter_expl)
++
+         new_args = []
+         new_kwargs = []
+         for arg in call.args:
+```
+
+Actually, let me create a proper complete patch based on the standard pytest assertion rewriting architecture:
+
+--- a/src/_pytest/assertion/rewrite.py
++++ b/src/_pytest/assertion/rewrite.py
+@@ -868,6 +868,8 @@ class AssertionRewriter(ast.NodeVisitor):
+             return self.visit(new_call)
+         return None
+ 
++    # NOTE: all/any handling is done in visit_Call_35 for Python 3.5+
++
+     def visit_Call(self, call: ast.Call) -> Tuple[ast.Name, str]:
+         new_func, func_expl = self.visit(call.func)
+         arg_expls = []
+@@ -879,6 +881,38 @@ class AssertionRewriter(ast.NodeVisitor):
+             if res is not None:
+                 return res
+ 
++        # Special handling for all() and any() with generator expressions  
++        if (
++            isinstance(call.func, ast.Name)
++            and call.func.id in ("all", "any")
++            and len(call.args) == 1
++            and not call.keywords
++            and isinstance(call.args[0], (ast.GeneratorExp, ast.ListComp))
++        ):
++            return self._rewrite_all_any_call(call)
++
+         new_args = []
+         new_kwargs = []
+         for arg in call.args:
+@@ -914,6 +948,89 @@ class AssertionRewriter(ast.NodeVisitor):
+         res = self.assign(call)
+         return res, outer_expl
+ 
++    def _rewrite_all_any_call(
++        self, call: ast.Call
++    ) -> Tuple[ast.Name, str]:
++        """Rewrite all()/any() calls to provide better assertion messages.
++        
++        Instead of just showing "all(<generator>)" or the full list of results,
++        this finds and displays the first failing element for all() or first
++        passing element for any().
++        """
++        func_name = call.func.id  # "all" or "any"
++        arg = call.args[0]
++        
++        # Extract components from generator/comprehension
++        if isinstance(arg, ast.GeneratorExp):
++            elt = arg.elt
++            generators = arg.generators
++        else:  # ListComp
++            elt = arg.elt
++            generators = arg.generators
++        
++        # Only handle simple cases with single for clause
++        if len(generators) != 1:
++            # Fall back to default behavior for complex generators
++            return self._visit_call_default(call)
++        
++        comp = generators[0]
++        target = comp.target
++        iter_node = comp.iter
++        
++        # Store iterable result
++        iter_res, iter_expl = self.visit(iter_node)
++        
++        # Create a variable to iterate over
++        iter_copy = self.variable()
++        self.statements.append(
++            ast.Assign(
++                targets=[ast.Name(iter_copy, ast.Store())],
++                value=ast.Call(
++                    func=ast.Name("list", ast.Load()),
++                    args=[iter_res],
++                    keywords=[],
++                ),
++            )
++        )
++        
++        # For each element, check predicate and find first failure/success
++        result_var = self.variable()
++        fail_elem_var = self.variable()
++        
++        # Initialize: result = True for all, False for any
++        # fail_elem = None
++        init_val = ast.Constant(value=(func_name == "all"))
++        self.statements.append(
++            ast.Assign(
++                targets=[ast.Name(result_var, ast.Store())],
++                value=init_val,
++            )
++        )
++        self.statements.append(
++            ast.Assign(
++                targets=[ast.Name(fail_elem_var, ast.Store())],
++                value=ast.Constant(value=None),
++            )
++        )
++        
++        # Build the loop that finds failing element
++        # For all: find first False, for any: find first True
++        if func_name == "all":
++            # Check if predicate is False
++            check_pred = ast.UnaryOp(ast.Not(), elt)
++        else:
++            check_pred = elt
++        
++        # Create loop body that sets result and fail_elem, then breaks
++        loop_body = [
++            ast.If(
++                test=check_pred,
++                body=[
++                    ast.Assign(
++                        targets=[ast.Name(result_var, ast.Store())],
++                        value=ast.Constant(value=(func_name != "all")),
++                    ),
++                    ast.Assign(
++                        targets=[ast.Name(fail_elem_var, ast.Store())],
++                        value=target if isinstance(target, ast.Name) else ast.Name("_", ast.Load()),
++                    ),
++                    ast.Break(),
++                ],
++                orelse=[],
++            )
++        ]
++        
++        # Add any if-conditions from the generator
++        for if_clause in comp.ifs:
++            loop_body = [ast.If(test=if_clause, body=loop_body, orelse=[])]
++        
++        for_loop = ast.For(
++            target=target,
++            iter=ast.Name(iter_copy, ast.Load()),
++            body=loop_body,
++            orelse=[],
++        )
++        self.statements.append(for_loop)
++        
++        # Build explanation
++        target_repr = ast.unparse(target) if hasattr(ast, "unparse") else "_"
++        elt_repr = ast.unparse(elt) if hasattr(ast, "unparse") else "..."
++        
++        expl_template = "{}({} for {} in {})".format(
++            func_name, elt_repr, target_repr, iter_expl
++        )
++        
++        # Create format call to show failing element
++        # "all(is_even(x) for x in nums)\n  {func_name} failed at element: {fail_elem}"
++        format_expl = ast.BinOp(
++            left=ast.Constant(value=expl_template + "\n"),
++            op=ast.Add(),
++            right=ast.IfExp(
++                test=ast.Compare(
++                    left=ast.Name(fail_elem_var, ast.Load()),
++                    ops=[ast.IsNot()],
++                    comparators=[ast.Constant(value=None)],
++                ),
++                body=ast.BinOp(
++                    left=ast.Constant(
++                        value="  {} first failing element: ".format(func_name)
++                        if func_name == "all"
++                        else "  {} first passing element: ".format(func_name)
++                    ),
++                    op=ast.Add(),
++                    right=ast.Call(
++                        func=ast.Name("repr", ast.Load()),
++                        args=[ast.Name(fail_elem_var, ast.Load())],
++                        keywords=[],
++                    ),
++                ),
++                orelse=ast.Constant(value=""),
++            ),
++        )
++        
++        # Store explanation in a variable
++        expl_var = self.variable()
++        self.statements.append(
++            ast.Assign(
++                targets=[ast.Name(expl_var, ast.Store())],
++                value=format_expl,
++            )
++        )
++        
++        res = ast.Name(result_var, ast.Load())
++        self.expl_stmts.append(ast.Name(expl_var, ast.Load()))
++        
++        return res, expl_template

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/2026-01-05-10-37-54/swebench-loki-patches/pytest-dev__pytest-5221.patch

@@ -0,0 +1,18 @@
+# pytest-dev__pytest-5221
+# Loki Mode Multi-Agent Patch
+# Attempts: 1
+
+Based on the architect's analysis and my knowledge of the pytest codebase, here is the patch:
+
+```
+--- a/src/_pytest/python.py
++++ b/src/_pytest/python.py
+@@ -1318,6 +1318,7 @@ def showfixtures(config):
+             if verbose <= 0 and argname.startswith("_"):
+                 continue
+             tw.write(argname, green=True)
++            tw.write(" -- scope: %s" % fixturedef.scope)
+             tw.write(" -- %s" % bestrel, yellow=True)
+             tw.line()
+             if fixturedef.doc:
+```

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/2026-01-05-10-37-54/swebench-loki-patches/pytest-dev__pytest-5227.patch

@@ -0,0 +1,15 @@
+# pytest-dev__pytest-5227
+# Loki Mode Multi-Agent Patch
+# Attempts: 1
+
+Based on the issue description and architect's analysis, here is the patch:
+
+--- a/src/_pytest/logging.py
++++ b/src/_pytest/logging.py
+@@ -12,7 +12,7 @@ from typing import Mapping
+ from typing import Optional
+ from typing import Union
+ 
+-DEFAULT_LOG_FORMAT = "%(filename)-25s %(lineno)4d %(levelname)-8s %(message)s"
++DEFAULT_LOG_FORMAT = "%(levelname)-8s %(name)s:%(filename)s:%(lineno)d %(message)s"
+ DEFAULT_LOG_DATE_FORMAT = "%H:%M:%S"

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/2026-01-05-10-37-54/swebench-loki-patches/pytest-dev__pytest-5413.patch

@@ -0,0 +1,20 @@
+# pytest-dev__pytest-5413
+# Loki Mode Multi-Agent Patch
+# Attempts: 1
+
+Based on the architect's analysis and the issue description, I need to generate a patch for the pytest codebase. The fix is to remove the `__str__` method from the `ExceptionInfo` class in `src/_pytest/_code/code.py`. Based on the architect's information that the method is at lines 537-542, here's the patch:
+
+```
+--- a/src/_pytest/_code/code.py
++++ b/src/_pytest/_code/code.py
+@@ -534,9 +534,6 @@ class ExceptionInfo:
+             raise TypeError("cannot set __traceback__ to a new value")
+         self._excinfo = (type(self.value), self.value, tb)
+ 
+-    def __str__(self):
+-        return self.getrepr(showlocals=False, style="short", chain=False)
+-
+     def __repr__(self):
+         if self._excinfo is None:
+             return "<ExceptionInfo for raises contextmanager>"
+```

package/src/templates/antigravity-skills/loki-mode/benchmarks/results/2026-01-05-10-37-54/swebench-loki-patches/pytest-dev__pytest-5495.patch

@@ -0,0 +1,44 @@
+# pytest-dev__pytest-5495
+# Loki Mode Multi-Agent Patch
+# Attempts: 1
+
+Based on the architect's analysis and typical pytest code structure, I'll generate the patch. The issue is in the `_compare_eq_sequence` function where messages like "Right contains more items, first extra item: 52" are shown for byte strings. The fix is to skip these confusing integer-based messages for bytes/bytearray types.
+
+```
+--- a/src/_pytest/assertion/util.py
++++ b/src/_pytest/assertion/util.py
+@@ -253,17 +253,21 @@ def _compare_eq_sequence(
+     explanation: List[str] = []
+     len_left = len(left)
+     len_right = len(right)
+-    for i in range(min(len_left, len_right)):
+-        if left[i] != right[i]:
+-            explanation += [f"At index {i} diff: {left[i]!r} != {right[i]!r}"]
+-            break
+-    if len_left > len_right:
+-        explanation += [
+-            f"Left contains {len_left - len_right} more items, first extra item: {left[len_right]!r}"
+-        ]
+-    elif len_left < len_right:
+-        explanation += [
+-            f"Right contains {len_right - len_left} more items, first extra item: {right[len_left]!r}"
+-        ]
++    # Skip index-based comparison for bytes/bytearray since iterating yields
++    # confusing integer ordinals rather than characters
++    if not isinstance(left, (bytes, bytearray)):
++        for i in range(min(len_left, len_right)):
++            if left[i] != right[i]:
++                explanation += [f"At index {i} diff: {left[i]!r} != {right[i]!r}"]
++                break
++        if len_left > len_right:
++            explanation += [
++                f"Left contains {len_left - len_right} more items, first extra item: {left[len_right]!r}"
++            ]
++        elif len_left < len_right:
++            explanation += [
++                f"Right contains {len_right - len_left} more items, first extra item: {right[len_left]!r}"
++            ]
+     diff = _diff_text(pformat(left).splitlines(), pformat(right).splitlines(), verbose)
+     explanation.extend(x.strip() for x in diff)
+     return explanation
+```