Provides the context-local application context. You can use this instead of declaring `__context` in an application. You really should

Appends to the state with a set of key-value pairs. Each one must correspond to a list-like object, or an error will be raised. This

Builds/finalizes the graph. :return: The graph object

Returns a copy of the given action with the given name. Why do we need this? We instantiate actions without names, and then set them later. Th

Adds transitions to the graph. Transitions are specified as tuples of either: 1. (from, to, condition) 2. (from, to) -- condi

Adds an action to the application. The actions are granted names (using the with_name) method post-adding, using the kw argument. If it alread

Returns a list of the state keys only (without values for cleaner display). Returns: list: A list of state keys

Returns the entire state, realize as a dictionary. This is a copy.

Adds an entrypoint to the application. This is the action that will be run first. This can only be called once. :param action: The na

Adds a "tracker" to the application. The tracker specifies a project name (used for disambiguating groups of tracers), and plugs into the

Assigns various identifiers to the application. This is used for tracking, persistence, etc... :param app_id: Application ID -- this will be

Returns a condition that evaluates the given expression. Expression must use only state variables and Python operators. Do not trust that anyt

Sets initial values in the state. If you want to load from a prior state, you can do so here and pass the values in. TODO -- enable p

Creates a RunnableGraph from a callable/action. This will create a single-node runnable graph, so we can wrap it up in a task. :param

Select the best model based on the validation metrics.

Visualizes the graph using graphviz. This will render the graph. :param output_file_path: The path to save this to, None if you don't want to

Initializes the application we will build from some prior state object. Note (1) that you can *either* call this or use `with_state` and `wit

Converts the state to a JSON serializable object

Initializes the app for saving, set up any databases, etc.. you want to here.

This is deprecated, please use .cleanup()

Performs a single step, advancing the state machine along. This returns a tuple of the action that was run, the result of running the

Creates a new instance of the SQLitePersister from passed in values. :param db_path: the path the DB will be stored. :param table_nam

Logs a set of attributes to the UI. Note that this must be paired with a tracker or a tracking hook to be useful, otherwise it will be

Returns a subset of the state, with only the given keys

Returns a condition that checks state values using optional operators. You can also refer to this as ``from burr.core import when`` in the AP

Converts a dictionary representing a JSON object back into a state

Updates the state with a set of key-value pairs Does an upsert operation (if the keys exist their value will be overwritten, otherwise

Adds an existing graph to the builder. Note that if you have any name clashes this will error out. This would happen if you add actions with t

Print error message and exit.

Runs your application through until completion, using async. Does not give access to the state along the way -- if you want that, use iterate(

Adds a state persister to the application. This is a way to persist state out to a database, file, etc... at the specified interval. This is o

Factory function to create an action. This is meant to be called by the ApplicationBuilder, and not by the user. The internal API may change.

Calls all the lifecycle hooks in this group, by hook name (stage) :param hook_name: Name of the hooks to call :param kwargs: Keyword

Wipes the state, either by deleting the keys in delete and keeping everything else or keeping the keys in keep. and deleting everything else.

Adds a lifecycle adapter to the application. This is a way to add hooks to the application so that they are run at the appropriate times. You

Extends the state with a set of key-value pairs. Each one must correspond to a list-like object, or an error will be raised. This is

Indicates that an input should come from state. Specify "missing" to allow for missing keys to be dropped or raise an error. :param key: Key

Closes the connection to the database.

Calls all the lifecycle hooks in this group, by hook name (stage). :param hook_name: Name of the hook

Streams a result out in an asynchronous manner. :param halt_after: The list of actions/tags to halt after execution of. It will halt on the f

At the update step of a Hamilton Action, call state.update to the key field of state. Used with outputs= parameter of Hamilton(...) :param ke

Streams a result out. :param halt_after: The list of actions/tags to halt after execution of. It will halt on the first one. :param h

Asynchronous version of step. :param inputs: Inputs to the action -- this is if this action requires an input that is passed in f

Saves the state for a given app_id, sequence_id, position (PK, App_id, sequence_id, position) are a unique identifier for the state. Why not

This is the default implementation for serializing a value. All other implementations should be registered with the `@serialize.register` decorat

Runs a simple command

Print a formatted step header.

Derives inputs from the function, given the bound parameters. This assumes that the function has inputs named `state`, as well as any number of ot

Utility function to convert a pydantic model to a dictionary.

Runs a single step action in async. See the synchronous version for more details.

Print error message and exit.

Utility function to clean out iterate params so we have less duplication between iterate/aiterate and the logic is cleaner later.

Runs a single step action. This API is internal-facing and a bit in flux, but it corresponds to the SingleStepAction class. :param action: Ac

Utility function to validate halt conditions

Builds the application for asynchronous runs. We support both synchronous and asynchronous applications. To save/load in an asynchronous

Helper function to add namespace to partition key.

Main function to deserialize a value. Looks for a key in the value if it's a dictionary and calls the appropriate deserializer function.

Runs your application through until completion. Does not give access to the state along the way -- if you want that, use iterate(). N

Send error response to client. Args: status_code: HTTP error status code message: Error message string to include in

Updates the state with the results of the hamilton action, as specified in the outputs. :param result: The results of the hamilton DAG

Validates the inputs to the function. This is a convenience method to allow for validation of inputs before running the function. :pa

Sets the typing system for the application. This is used to enforce typing on the state. :param typing_system: Typing system to use :

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