discovery

Class info

Classes

Name	Children	Inherits
NodeFunction llmling_agent.running.discovery Metadata for a function that uses nodes.		object

🛈 DocStrings

Function discovery and metadata handling.

NodeFunction dataclass

Metadata for a function that uses nodes.

Source code in src/llmling_agent/running/discovery.py

@dataclass
class NodeFunction:
    """Metadata for a function that uses nodes."""

    func: AnyCallable
    """The actual function to execute."""

    depends_on: list[str] = field(default_factory=list)
    """Names of functions this one depends on."""

    deps: Any = None
    """Node dependencies."""

    default_inputs: dict[str, Any] = field(default_factory=dict)
    """Default parameter values."""

    name: str = field(init=False)
    """Function name (from function.__name__)."""

    def __post_init__(self):
        """Set name and validate dependencies."""
        self.name = self.func.__name__
        # Extract default inputs from function signature

        sig = inspect.signature(self.func)
        self.default_inputs = {
            name: param.default
            for name, param in sig.parameters.items()
            if param.default is not param.empty
        }
        msg = "Registered node function %s (deps=%s)"
        logger.debug(msg, self.name, self.depends_on)

default_inputs class-attribute instance-attribute

default_inputs: dict[str, Any] = field(default_factory=dict)

Default parameter values.

depends_on class-attribute instance-attribute

depends_on: list[str] = field(default_factory=list)

Names of functions this one depends on.

deps class-attribute instance-attribute

deps: Any = None

Node dependencies.

func instance-attribute

func: AnyCallable

The actual function to execute.

name class-attribute instance-attribute

name: str = field(init=False)

Function name (from function.name).

__post_init__

__post_init__()

Set name and validate dependencies.

Source code in src/llmling_agent/running/discovery.py

def __post_init__(self):
    """Set name and validate dependencies."""
    self.name = self.func.__name__
    # Extract default inputs from function signature

    sig = inspect.signature(self.func)
    self.default_inputs = {
        name: param.default
        for name, param in sig.parameters.items()
        if param.default is not param.empty
    }
    msg = "Registered node function %s (deps=%s)"
    logger.debug(msg, self.name, self.depends_on)

node_function

node_function(
    func: Callable | None = None,
    *,
    deps: Any | None = None,
    depends_on: str | Sequence[str | Callable] | Callable | None = None,
) -> Callable

Mark a function for automatic node execution.

Can be used as simple decorator or with arguments:

@node_function async def func(): ...

@node_function(order=1, depends_on="other_func") async def func(): ...

Parameters:

Name	Type	Description	Default
func	Callable | None	Function to mark	None
deps	Any | None	Dependencies to inject into all Agent parameters	None
depends_on	str | Sequence[str | Callable] | Callable | None	Names of functions this one depends on	None

Returns:

Type	Description
Callable	Decorated function

Source code in src/llmling_agent/running/discovery.py

def node_function(
    func: Callable | None = None,
    *,
    deps: Any | None = None,
    depends_on: str | Sequence[str | Callable] | Callable | None = None,
) -> Callable:
    """Mark a function for automatic node execution.

    Can be used as simple decorator or with arguments:

    @node_function
    async def func(): ...

    @node_function(order=1, depends_on="other_func")
    async def func(): ...

    Args:
        func: Function to mark
        deps: Dependencies to inject into all Agent parameters
        depends_on: Names of functions this one depends on

    Returns:
        Decorated function
    """

    def decorator(func: Callable) -> Callable:
        match depends_on:
            case None:
                depends_on_ = []
            case str():
                depends_on_ = [depends_on]
            case Callable():
                depends_on_ = [depends_on.__name__]

            case [*items]:
                depends_on_ = [
                    i.__name__ if isinstance(i, Callable) else str(i)  # type: ignore[union-attr, arg-type]
                    for i in items
                ]
            case _:
                msg = f"Invalid depends_on: {depends_on}"
                raise ValueError(msg)
        # TODO: we still need to inject the deps in execution part.
        metadata = NodeFunction(func=func, depends_on=depends_on_ or [], deps=deps)
        func._node_function = metadata  # type: ignore
        return func

    return decorator(func) if func is not None else decorator