chore: improve error output when call unwrap_or_return on a function …

[acostapazo]

…withou @early_return or @async_early_return decorators

[acostapazo]

I guess this depends on some ruff configuration. 🤔

[fgsalomon]

New versions of ruff handle things differently to older versions.

[acostapazo]

I've tried to guess if caller is a regular function or an async one with something like the following:

import inspect
from typing import Union

class WaitingForEarlyReturn(Exception):
    result: 'AnyResult'  # Replace with the actual class/type if AnyResult is not defined
    called_from: Union[str, None]
    called_from_coroutine: bool = False

    def __init__(self, result: 'AnyResult') -> None:
        self.result = result
        try:
            # Get the stack frame
            stack = inspect.stack()[2]
            frame = stack.frame
            function_name = frame.f_code.co_name  # Get the name of the function
            filename = stack.filename.split("/")[-1]

            # We can't retrieve the actual function object, so we check by name
            self.called_from_coroutine = frame.f_globals.get(function_name) and inspect.iscoroutinefunction(frame.f_globals[function_name])

            # Create a descriptive string for where this was called from
            if self.called_from_coroutine:
                self.called_from = f"{function_name} (async) on {filename}"
            else:
                self.called_from = f"{function_name} on {filename}"

        except Exception:  # noqa
            self.called_from = None

        # Call the base class initializer
        Exception.__init__(self)

But, I think is not possible.

[fgsalomon]

I don't know why you say it doesn't work 🤔

[acostapazo]

Because frame.frame.f_globals.get(func) is alway None, so called_from_coroutine is always False.

This is because func is a string not an actual Callable.

If you modify the test, you'll notice the code never pass through called_from_coroutine positive if:

    @pytest.mark.asyncio
    async def should_log_hint_when_called_async_from_class_function_and_not_early_return(self):
        class MyClass:
            async def execute(self) -> AnyResult:
                result = Failure(Error())
                result.unwrap_or_return()
                return isSuccess

        with pytest.raises(
            WaitingForEarlyReturn,
            match=expected_error(
                "Error",
                called_from="execute (async) on test_waiting_for_early_return.py",  # <-------- THIS
                escape=True,
            ),
        ):
            await MyClass().execute()

[fgsalomon]

I think I found a way (not very elegant). Check my last commit