Hook

lazyllm.hook.LazyLLMHook

Bases: ABC

Abstract base class for LazyLLM's hook system, used to insert custom logic before and after function or method execution.

This class is an abstract base class (ABC) that defines the basic interface for the hook system. By inheriting from this class and implementing its abstract methods, you can create custom hooks to monitor, log, or modify function execution processes.

Parameters:

• obj –

  The object to monitor (usually a function or method). This object will be stored in the hook instance for use by other methods.

Note: This class is an abstract base class and cannot be instantiated directly. You must inherit from this class and implement all abstract methods to use it.

Source code in lazyllm/hook.py

class LazyLLMHook(ABC):
    """Abstract base class for LazyLLM's hook system, used to insert custom logic before and after function or method execution.

This class is an abstract base class (ABC) that defines the basic interface for the hook system. By inheriting from this class and implementing its abstract methods, you can create custom hooks to monitor, log, or modify function execution processes.

Args:
    obj: The object to monitor (usually a function or method). This object will be stored in the hook instance for use by other methods.

**Note**: This class is an abstract base class and cannot be instantiated directly. You must inherit from this class and implement all abstract methods to use it.
"""
    __hook_priority__ = 100
    __hook_error_mode__ = 'warn'

    @abstractmethod
    def __init__(self, obj):
        pass

    @abstractmethod
    def pre_hook(self, *args, **kwargs):
        """Pre-hook method, called before the monitored function executes.

This is an abstract method and must be implemented in subclasses.

Args:
    *args: Positional arguments passed to the monitored function.
    **kwargs: Keyword arguments passed to the monitored function.
"""
        pass

    @abstractmethod
    def post_hook(self, output):
        """Post-hook method, called after the monitored function executes.

This is an abstract method and must be implemented in subclasses.

Args:
    output: The return value of the monitored function.
"""
        pass

    def on_error(self, exc):
        """Error-handling hook, called when the monitored function raises an exception.

The default implementation is a no-op. Subclasses can override it to record error status,
attach diagnostic information, or perform cleanup.

Args:
    exc: The exception raised by the monitored function.
"""
        return None

    def finalize(self):
        """Run the final cleanup logic of the hook lifecycle.

This method is called at the end of the hook lifecycle and is intended for cleanup,
resource release, or final reporting.

This is the preferred final-phase interface. For backward compatibility, ``report`` is
still supported and treated as a legacy alias of ``finalize``.
"""
        raise NotImplementedError

finalize()

Run the final cleanup logic of the hook lifecycle.

This method is called at the end of the hook lifecycle and is intended for cleanup, resource release, or final reporting.

This is the preferred final-phase interface. For backward compatibility, report is still supported and treated as a legacy alias of finalize.

Source code in lazyllm/hook.py

    def finalize(self):
        """Run the final cleanup logic of the hook lifecycle.

This method is called at the end of the hook lifecycle and is intended for cleanup,
resource release, or final reporting.

This is the preferred final-phase interface. For backward compatibility, ``report`` is
still supported and treated as a legacy alias of ``finalize``.
"""
        raise NotImplementedError

on_error(exc)

Error-handling hook, called when the monitored function raises an exception.

The default implementation is a no-op. Subclasses can override it to record error status, attach diagnostic information, or perform cleanup.

Parameters:

• exc –

  The exception raised by the monitored function.

Source code in lazyllm/hook.py

    def on_error(self, exc):
        """Error-handling hook, called when the monitored function raises an exception.

The default implementation is a no-op. Subclasses can override it to record error status,
attach diagnostic information, or perform cleanup.

Args:
    exc: The exception raised by the monitored function.
"""
        return None

post_hook(output) abstractmethod

Post-hook method, called after the monitored function executes.

This is an abstract method and must be implemented in subclasses.

Parameters:

• output –

  The return value of the monitored function.

Source code in lazyllm/hook.py

    @abstractmethod
    def post_hook(self, output):
        """Post-hook method, called after the monitored function executes.

This is an abstract method and must be implemented in subclasses.

Args:
    output: The return value of the monitored function.
"""
        pass

pre_hook(*args, **kwargs) abstractmethod

Pre-hook method, called before the monitored function executes.

This is an abstract method and must be implemented in subclasses.

Parameters:

• *args –

  Positional arguments passed to the monitored function.

• **kwargs –

  Keyword arguments passed to the monitored function.

Source code in lazyllm/hook.py

    @abstractmethod
    def pre_hook(self, *args, **kwargs):
        """Pre-hook method, called before the monitored function executes.

This is an abstract method and must be implemented in subclasses.

Args:
    *args: Positional arguments passed to the monitored function.
    **kwargs: Keyword arguments passed to the monitored function.
"""
        pass

lazyllm.hook.LazyLLMFuncHook

Bases: LazyLLMHook

Helper class for hooking functions. if the function is a generator function, statements before yield will be executed as pre_hook, and statements after yield will be executed as post_hook.

Parameters:

• func –

  The function to hook.

Source code in lazyllm/hook.py

class LazyLLMFuncHook(LazyLLMHook):
    """Helper class for hooking functions. if the function is a generator function, statements before yield
will be executed as pre_hook, and statements after yield will be executed as post_hook.

Args:
    func: The function to hook.
"""
    def __init__(self, func):
        self._func = func
        self._isgeneratorfunction = inspect.isgeneratorfunction(func)
        if self._isgeneratorfunction:
            self._left_count = _check_and_get_pre_assign_number(func)

    def pre_hook(self, *args, **kwargs):
        if self._isgeneratorfunction:
            self._generator = self._func(*args, **kwargs)
            next(self._generator)
        else:
            self._func(*args, **kwargs)

    def post_hook(self, output):
        assert self._isgeneratorfunction, 'post_hook is only supported for generator functions'
        try:
            self._generator.send(output) if self._left_count == 1 else next(self._generator)
        except StopIteration: pass