Improve ArgThat repr with resilient predicate labeling

Make ArgThat repr informative by labeling predicate kind and optional source
line, e.g. "def is_positive at line N", "lambda at line N", and callable
instance labels. This improves diagnostics without requiring custom ArgThat
subclasses.

Add defensive introspection fallbacks so odd/broken callables do not break
repr generation. Handle functools.partial explicitly, and add regression tests
covering builtins, numpy ufuncs, partial numpy functions, and broken
__name__ introspection.

Author: kaste

mockito/matchers.py

@@ -60,6 +60,7 @@
 """
 
 from abc import ABC, abstractmethod
+import functools
 import re
 builtin_any = any
 
@@ -223,7 +224,83 @@ def matches(self, arg):
         return self.predicate(arg)
 
     def __repr__(self):
-        return "<ArgThat>"
+        return "<ArgThat: %s>" % _arg_that_predicate_label(self.predicate)
+
+
+def _arg_that_predicate_label(predicate):
+    try:
+        return _arg_that_predicate_label_unchecked(predicate)
+    except Exception:
+        predicate_class = _safe_getattr(
+            _safe_getattr(predicate, '__class__'),
+            '__name__',
+        )
+        if predicate_class is None:
+            return 'callable'
+
+        return 'callable %s' % predicate_class
+
+
+def _arg_that_predicate_label_unchecked(predicate):
+    if isinstance(predicate, functools.partial):
+        return _arg_that_partial_label(predicate)
+
+    function_line = _line_of_callable(predicate)
+    function_name = _safe_getattr(predicate, '__name__')
+    if function_name is not None:
+        if function_name == '<lambda>':
+            return _label_with_line('lambda', function_line)
+        return _label_with_line('def %s' % function_name, function_line)
+
+    predicate_class = _safe_getattr(
+        _safe_getattr(predicate, '__class__'),
+        '__name__',
+    )
+    if predicate_class is None:
+        predicate_class = 'object'
+
+    call = _safe_getattr(predicate, '__call__')
+    call_line = _line_of_callable(call)
+    return _label_with_line(
+        'callable %s.__call__' % predicate_class,
+        call_line,
+    )
+
+
+def _arg_that_partial_label(predicate):
+    partial_func = _safe_getattr(predicate, 'func')
+    partial_name = _safe_getattr(partial_func, '__name__')
+
+    if partial_name is not None:
+        return 'partial %s' % partial_name
+
+    return 'partial'
+
+
+def _line_of_callable(value):
+    if value is None:
+        return None
+
+    func = _safe_getattr(value, '__func__', value)
+    code = _safe_getattr(func, '__code__')
+    if code is None:
+        return None
+
+    return _safe_getattr(code, 'co_firstlineno')
+
+
+def _safe_getattr(value, name, default=None):
+    try:
+        return getattr(value, name)
+    except Exception:
+        return default
+
+
+def _label_with_line(label, line_number):
+    if line_number is None:
+        return label
+
+    return '%s at line %s' % (label, line_number)
 
 
 class Contains(Matcher):

tests/matcher_repr_test.py

@@ -1,6 +1,9 @@
+from functools import partial
 import re
 
-from mockito import and_, any as any_, contains, eq, gt, matches, not_, or_
+import numpy as np
+
+from mockito import and_, any as any_, arg_that, contains, eq, gt, matches, not_, or_
 
 
 def test_value_matchers_use_repr_for_string_values():
@@ -26,3 +29,83 @@ def test_matches_repr_shows_only_explicit_flags():
     assert repr(matches("f..", re.IGNORECASE)) == (
         f"<Matches: 'f..' flags={int(re.IGNORECASE)}>"
     )
+
+
+def test_arg_that_repr_includes_named_function_name():
+    # Predicate display name: "def is_positive"
+    def is_positive(value):
+        return value > 0
+
+    matcher = arg_that(is_positive)
+
+    assert repr(matcher) == (
+        f"<ArgThat: def is_positive at line {is_positive.__code__.co_firstlineno}>"
+    )
+
+
+def test_arg_that_repr_includes_lambda_name():
+    # Predicate display name: "lambda"
+    predicate = lambda value: value > 0
+    matcher = arg_that(predicate)
+
+    assert repr(matcher) == (
+        f"<ArgThat: lambda at line {predicate.__code__.co_firstlineno}>"
+    )
+
+
+def test_arg_that_repr_for_callable_instance_includes_class_name():
+    # Predicate display name: "callable IsPositive.__call__"
+    class IsPositive:
+        def __call__(self, value):
+            return value > 0
+
+    predicate = IsPositive()
+    matcher = arg_that(predicate)
+
+    assert repr(matcher) == (
+        "<ArgThat: callable IsPositive.__call__ at line "
+        f"{predicate.__call__.__func__.__code__.co_firstlineno}>"
+    )
+
+
+def test_arg_that_repr_for_builtin_callable_has_no_line_number():
+    matcher = arg_that(len)
+
+    assert repr(matcher) == "<ArgThat: def len>"
+
+
+def test_arg_that_repr_for_partial_uses_underlying_function_name():
+    predicate = partial(pow, exp=2)
+    matcher = arg_that(predicate)
+
+    assert repr(matcher) == "<ArgThat: partial pow>"
+
+
+def test_arg_that_repr_for_numpy_ufunc_uses_function_name_without_line():
+    matcher = arg_that(np.isfinite)
+
+    assert repr(matcher) == "<ArgThat: def isfinite>"
+
+
+def test_arg_that_repr_for_partial_numpy_function_uses_wrapped_name():
+    predicate = partial(np.allclose, b=0.0)
+    matcher = arg_that(predicate)
+
+    assert repr(matcher) == "<ArgThat: partial allclose>"
+
+
+def test_arg_that_repr_handles_callables_with_broken_name_introspection():
+    class BrokenNameCallable:
+        def __getattribute__(self, name):
+            if name == '__name__':
+                raise RuntimeError("boom")
+            return super().__getattribute__(name)
+
+        def __call__(self, value):
+            return value > 0
+
+    matcher = arg_that(BrokenNameCallable())
+
+    matcher_repr = repr(matcher)
+    assert matcher_repr.startswith("<ArgThat: callable BrokenNameCallable")
+    assert "__name__" not in matcher_repr