Print a formatted section header.

Runs a multi-step streaming action. E.G. one with a run/reduce step. This API is internal-facing. Note that this converts the shape of a multi

Runs the reducer, returning the new state. Note this restricts the keys in the state to only those that the function writes. :param reducer:

Runs a single step streaming action. This API is internal-facing. This normalizes + validates the output.

Call the Haystack `Component.run()` method. :param state: State object of the application. It contains some input values for ``Com

Creates a new pydantic model that is a subset of the original model. This is just to make it more efficient, as we can dynamically alter pydantic

Adjusts the output of a single step action to be a tuple of (result, state) or just state

Runs a multi-step streaming action in async. See the synchronous version for more details.

Cascades the desired adapter given the specified behavior (cascade, None, or an adapter). If shared_instance is specified (non-null) as well as `c

Print formatted section header.

Processes inputs, injecting the common inputs and ensuring that all required inputs are present.

Run a subprocess command with consistent error handling and output. Args: cmd: Command and arguments as list description: What we

Verify artifact and its signature/checksum files.

Gets a list of actions given a tag. Note that, if no tags match the action a ValueError will be raised.

Returns whether or not there is a next action to run. :return: True if there is a next action, False otherwise

Creates a model from the state object -- capturing just the fields that are relevant to the model itself. :param model: model type to create

Utility function to enter a span. Starts, sets the current context, and adds it to the token stack. See this for some background on why start_spa

Ditto with _enter_span, but for exiting the span. Pops the token off the stack and detaches the context.

Gets a connection - either the dedicated one or one from the pool.

Releases a connection back to the pool if it was acquired.

This is a utility function to remap the __dunder parameters to the mangled version in the function signature. Python mangles __parameter names in

Runs a function, returning the result of running the function. Note this restricts the keys in the state to only those that the function reads

Sign artifact with GPG (unless skipped) and create SHA512 checksum.

Applies a given operation to the state, returning a new state

Indicates that an input should come from a literal (variable/constant) value. Use this if you just want to fix a parameter into the Hamilton DAG.

Check if this backend is configured for event-driven updates.

Merges a pydantic model that is a subset of the new state back into the state TODO -- implement TODO -- consider validating that the entire st

Validates that the application is meant to run async. This validation is performed in synchronous application methods.

Represents an input action -- this reads something from an input then writes that directly to state. This is a convenience class for when you

Runs a function, returning the result of running the function. Async version of the above.

Computes the backend spec from the current backend configuration.

Parse EventBridge-wrapped or native S3 notification bodies from SQS. Returns None if the format is not recognized. Multiple S3 records in one

Internal utility function to determine whether or not to halt during iteration

Updates the internal state values of the new state.

Validate that requested version matches pyproject.toml.

Verify script is running from project root.

Returns a generator that calls step() in a row, enabling you to see the state of the system as it updates. This is the asynchronous version so

Realize an async generator or async iterable to a list. :param maybe_async_generator: async generator or async iterable :return: list of item

Convert a sync generator to an async generator. :param generator: sync generator :return: async generator

* Get Annotations * @param projectId * @param appId * @param partitionKey * @param stepSequenceId * @returns AnnotationOut Successful R

* Get App Spec * @returns BackendSpec Successful Response * @throws ApiError

* Get Application Logs * Lists steps for a given App. * TODO: add streaming capabilities for bi-directional communication * TODO: add paginat

This says whether or not the action is async. Note you have to override this if you have async tasks and want to use asyncio.gather on them. O

Returns a generator that calls step() in a row, enabling you to see the state of the system as it updates. Note this returns a generator, and

Loads the state for a given app_id :param partition_key: the partition key. Note this could be None, but it's up to the persistor to whether

Load the state data for a given partition key, app id, and sequence id. If the sequence id is not given, it will be looked up in the Redis da

Instantiates a streaming result container that just passes through the given results This is to be used internally -- it allows us to wrap non

Registers a custom serializer + deserializer for a field globally. This is useful for really controlling how a field is serialized and deserializ

Streaming version of the run and update function. This return type is a generator that streams in a result, has no "send" value, and r

Updates state -- this is meant to be called if you need to do anything with the state. For example: 1. Reset it (after going through a

Sets the 'spawning' parent application that created this app. This is used for tracking purposes. Doing this creates a parent/child relationsh

Moves to the next state in the streaming result

Check git working tree status and warn if dirty.