fleche.call

Attributes

AnyCall

Classes

Ignored	Type wrapper to mark a function argument as ignored for caching.
Required	Type wrapper to mark a function argument as required for caching.
FunctionProfile	All static per-function metadata, cached once per callable.
Call	Represents a function call, capturing its name, arguments, and keyword arguments.
DigestedCall	A Call where arguments and result are Digest pointers into a value store.
LazyCall
QueryCall

Functions

bind(func, args, kwargs[, apply_defaults, partial])

Thin wrapper around inspect.Signature.bind() / bind_partial().

Module Contents

class fleche.call.Ignored

Type wrapper to mark a function argument as ignored for caching.

Can be used as a type hint: arg: fleche.Ignored or arg: fleche.Ignored[int].

classmethod __class_getitem__(item)

class fleche.call.Required

Type wrapper to mark a function argument as required for caching.

Arguments marked as required must be explicitly provided by the caller as keyword arguments (i.e. not via their default value) for the result to be cached. This is useful for arguments like random seeds or iteration counts, where using the default value might lead to non-deterministic or otherwise undesirable caching behavior.

This is mainly useful when wrapping third-party functions where you do not control the default arguments.

Can be used as a type hint: arg: fleche.Required or arg: fleche.Required[int].

classmethod __class_getitem__(item)

class fleche.call.FunctionProfile

All static per-function metadata, cached once per callable.

signature: inspect.Signature

qualname: str

module: str

version: str | int | None

code_digest: fleche.digest.Digest | None

ignored: frozenset[str]

required: frozenset[str]

classmethod of(func) → FunctionProfile

Compute a FunctionProfile for func without caching.

strip_for_key(bound: dict) → None

Remove ignored arguments from a bound arguments dict in-place.

check_required(args: tuple, kwargs: dict) → list[str]

Return names of required args not explicitly provided as keyword arguments.

fleche.call.bind(func, args, kwargs, apply_defaults=False, partial=False)

Thin wrapper around inspect.Signature.bind() / bind_partial().

Parameters:

• func – The callable whose signature to bind against.

• args – Positional arguments.

• kwargs – Keyword arguments.

• apply_defaults – If True, fill in default values for parameters that were not explicitly supplied.

• partial – If True, use bind_partial(), which allows required arguments to be omitted (treated as wildcards).

Returns:

inspect.BoundArguments.arguments — an OrderedDict containing the supplied (and, when requested, defaulted) values.

class fleche.call.Call

Represents a function call, capturing its name, arguments, and keyword arguments.

module and version can be optionally set to be included in the hash of the call. version should be a plain integer and monotonically increase. Each different version will completely change the hash of the call, invalidating previously cached results.

name: str

arguments: dict[str, Any]

metadata: dict[str, dict[str, Any]]

module: str | None = None

version: str | int | None = None

code_digest: str | None = None

result: Any = None

classmethod from_call(func, *args, **kwargs)

to_lookup_key() → fleche.digest.Digest

_to_digested(save_fn: Callable[[Any], fleche.digest.Digest]) → DigestedCall

Generic conversion to DigestedCall using save_fn to handle each value.

stash(values) → DigestedCall

Save arguments and result into values, returning a DigestedCall.

Result save errors propagate to the caller. Argument save errors fall back to a digest-only reference (the value is hashed but not stored).

Parameters:

values – A ValueStorage instance to persist values into.

Returns:

A DigestedCall with all argument values and the result replaced by their Digest keys.

See also

digest() for a variant that does not write to storage.

digest() → DigestedCall

Digest arguments and result without saving to storage, returning a DigestedCall.

Equivalent to stash() but uses digest() instead of values.save, so no data is written anywhere.

class fleche.call.DigestedCall

A Call where arguments and result are Digest pointers into a value store.

Produced by Call.stash() or Call.digest(); represents a call whose values have been replaced by their content-addressed keys.

name: str

arguments: dict[str, fleche.digest.Digest]

result: fleche.digest.Digest | None = None

metadata: dict[str, dict[str, Any]]

module: str | None = None

version: str | int | None = None

code_digest: str | None = None

__eq__(other: object) → bool

__digest__()

to_lookup_key() → fleche.digest.Digest

fetch(cache) → LazyCall

Wrap this DigestedCall in a LazyCall backed by cache.

Parameters:

cache – A cache instance (e.g. Cache) whose value storage will be used to load argument and result values on demand.

Returns:

A LazyCall that loads values lazily from cache.

class fleche.call.LazyCall

name: str

_arguments: dict[str, Any]

_result: Any

_cache: Any

metadata: dict[str, dict[str, Any]]

module: str | None = None

version: str | int | None = None

code_digest: str | None = None

property arguments

property result

to_lookup_key() → str

fetch() → Call

Reconstruct a full Call object by loading all values from the cache.

detach() → DigestedCall

Return the cache-free DigestedCall shadow of this LazyCall.

The inverse of DigestedCall.fetch(): strips the _cache reference so the result can cross process boundaries (e.g. over the wire in fleche.remote) without carrying a live cache pointer.

__digest__()

class fleche.call.QueryCall

name: StrQueryType = None

arguments: dict[str, AnyQueryType] | None = None

metadata: dict[str, dict[str, StrQueryType]] | None = None

module: str | None = None

version: str | int | None = None

code_digest: fleche.digest.Digest | None = None

result: AnyQueryType = None

classmethod from_call(func, *args, **kwargs)

matches(other: Call | LazyCall | DigestedCall) → bool

Check if this call matches another call, treating None as a wildcard in this object.

fleche.call.AnyCall