Hacktoberfest 2026: los issues que los mantenedores marcaron para octubre, abiertos y aptos para principiantes. Explorar issues de Hacktoberfest

astep() passes unprocessed inputs to pre_run_step hooks

Abierto Apto para principiantes
  • ¿Algo no está bien?
#979 0 comentarios 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 4 días

@sivakumar-mahalingam ya está trabajando en esto.

Desde el 18/10/2026.

  • #980 de @sivakumar-mahalingam — abierto

Evaluación

Dificultad
2/5
Tiempo estimado
1-3 horas
Aptitud para principiantes
78/100
Tipo de issue
Error
Claridad
Bien especificado
Estado de actividad
Activo
Stack tecnológico
python
Área
backend

Línea de trabajo

Lee las implementaciones síncrona de _step() y asíncrona de _astep(), prestando atención a dónde se ejecuta _process_inputs() en relación con pre_run_step. Añade o adapta pruebas para las entradas procesadas y para las entradas obligatorias que falten, usando como guía los ejemplos del issue. El trabajo estará terminado cuando ambas rutas proporcionen al hook las mismas entradas procesadas que a la acción y omitan el hook si falla la validación.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

status/needs-triage

Application.astep() passes raw, unprocessed inputs to pre_run_step lifecycle hooks, while Application.step() passes the validated and processed inputs that are actually provided to the action. This causes inconsistent lifecycle and tracking behavior between synchronous and asynchronous execution.

Current behavior

Application.step() calls _process_inputs() before invoking the pre_run_step hook. Consequently, undeclared inputs are removed and required inputs are validated before the hook runs.

Application.astep() invokes pre_run_step with the original input dictionary before calling _process_inputs().

For an action that declares no inputs:

step hook inputs:  {}
astep hook inputs: {"unused": 123}

There is also inconsistent behavior when a required input is missing:

pre_run_step calls:
step:  0
astep: 1

This means lifecycle adapters and tracking clients can record inputs that were never passed to the action.

Stack Traces

Not applicable. The inconsistency occurs without an exception when undeclared inputs are supplied.

Screenshots

Not applicable.

Steps to replicate behavior

  1. Run the following script:
import asyncio

from burr.core import ApplicationBuilder, State, action
from burr.lifecycle import PreRunStepHook


class CaptureInputs(PreRunStepHook):
    def __init__(self):
        self.inputs = []

    def pre_run_step(self, *, inputs, **kwargs):
        self.inputs.append(inputs)


@action(reads=[], writes=[])
def noop(state: State) -> State:
    return state


sync_hook = CaptureInputs()
sync_app = (
    ApplicationBuilder()
    .with_actions(noop)
    .with_entrypoint("noop")
    .with_hooks(sync_hook)
    .build()
)
sync_app.step(inputs={"unused": 123})


async_hook = CaptureInputs()
async_app = (
    ApplicationBuilder()
    .with_actions(noop)
    .with_entrypoint("noop")
    .with_hooks(async_hook)
    .build()
)
asyncio.run(async_app.astep(inputs={"unused": 123}))

print("step hook inputs:", sync_hook.inputs)
print("astep hook inputs:", async_hook.inputs)
  1. Observe the output:
step hook inputs: [{}]
astep hook inputs: [{"unused": 123}]

Library & System Information

  • Apache Burr: current main (9088aad8cb6de62b9923816b89eaa562c1162c65)
  • Python 3
  • Reproduced on Linux

Expected behavior

step() and astep() should have consistent lifecycle semantics:

  • Inputs should be validated and processed before pre_run_step is invoked.
  • The hook should receive the processed inputs that will be passed to the action.
  • The same processed input dictionary should be used by both the hook and the action.
  • pre_run_step should not be invoked when input validation fails.

Additional context

In _step(), _process_inputs() is called before pre_run_step, and the resulting action_inputs are passed to both the hook and the action.

In _astep(), pre_run_step currently receives the original inputs dictionary, and _process_inputs() is called later during action execution.

Related issue #36 added action inputs to lifecycle hooks and tracking, but it does not cover this synchronous/asynchronous inconsistency.

Lenguaje dominante
Python
Estrellas
2.6k
Forks
209
Merge medio
8 d 9 h
PR fusionados (30 d)
26

Preparar el entorno

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de apache/burr

Todos los issues de apache/burr

Issues similares

Más issues de Python

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.