Skip to content

Commit 8687c2a

Browse files
authored
feat(frontend): accept $variable references in loop blocks (apache#8640)
### What changes were proposed in this PR? Inside a control block (`Loop Start ... Loop End`), any primitive property of an operator (string, integer, number, boolean) can now hold a loop-variable reference such as `$i`. The frontend sends the literal string `"$i"` unchanged. The backend marks it as a placeholder when it compiles the plan and binds it when the iteration's state message reaches the worker (apache#8639). Operators outside every block behave as before. ``` Loop Start (i = 0) -> Limit(limit: "$i") -> Loop End ^ panel offers $i; canvas valid; sent as "$i" rename i to j in the Loop Start -> Limit warns "$i is not a variable of an enclosing block; ..."; Run stays enabled delete a link upstream -> Limit outside the block -> "must be integer" disable the Loop End -> the same: the backend compiles and runs only enabled operators ``` | Piece | What it does | |---|---| | Block membership (`enclosingLoopStarts`, `loop-block.util.ts`) | Worked out in the frontend from the graph as it stands: every enabled operator, valid or not, and the links between them, which is the plan the backend compiles and runs (`WorkflowGraph.getSubDAG`). It is a port of the backend's `LogicalPlan.enclosingLoopStarts` (apache#8639), with the same treatment of a Loop Start that no Loop End closes, nested and sequential blocks, branches, and outermost-first order. `LogicalPlanSpec` and `loop-block.util.spec.ts` both run one shared fixture (`common/workflow-compiler/src/test/resources/loop-blocks.json`: named cases plus random graphs, with the backend's answers), so the two cannot drift apart, and a change to the fixture runs the frontend stack too (`labeler.yml`). An unfinished operator elsewhere on the canvas no longer keeps an operator in a block it has left. | | Loop variables (`extractLoopVariables`, `loopVariablesInScope`) | Reads the variables from each enclosing Loop Start's `initialization` code, following Python's module-level binding: assignments at any depth outside a `def`/`class` body, for-loop targets, one-line compound bodies such as `try: k = 1`, and names an import binds (`from math import pi`, `import numpy as np`, relative modules, parenthesized lists). | | Property panel | Inside a block, each plain primitive field becomes a text box that offers `$name` for every variable in scope. So does a field whose accepted values depend on another field of its row (value rules, as on the sklearn trainers' hyperparameter values): its rules still judge every value that is not a reference, and the text box suggests the values they accept after the variables. Enums, arrays and custom widgets keep their own controls, and so does a property the backend marks `"noLoopVariable": true` (apache#8750: settings the plan is built from, such as Projection's columns), together with everything nested under it. A `$name` that no enclosing block declares gets a warning under the field; the operator stays valid, and the run itself reports the name if no Loop Start sets it. | | Canvas validation | Inside a block, the schema `type` error is waived exactly where a reference sits in a primitive-typed property. `loopScopeChangeStream` emits on every edit that can change an operator's scope: an operator or link added or deleted, an operator disabled or enabled, or a Loop Start's properties changed. On each one, validation re-validates every operator that holds a reference, so the Run button follows edits two hops away. | | Open panel | Rebuilt on `loopScopeChangeStream` when the operator's scope changed. | | Shared editing (`updateYTypeFromObject`) | A string now replaces a number or boolean instead of throwing, which storing `"$i"` over a number needs. | Panel behavior for a field inside a block: | Field type | Typed text | Stored value | |---|---|---| | integer | `7` | `7` (number) | | integer / number / boolean | `$i` | `"$i"` | | number | `0.5`, typed one key at a time | `0.5`; partial text such as `7.` stays text until complete | | boolean | `true` / `FALSE` | `true` / `false`; other text is flagged | | string | `hello` / `$i` | `"hello"` / `"$i"` | | value rules (e.g. `C`, which must be > 0) | `$i` / `1.0` / `-1` | `"$i"` / `"1.0"` / `"-1"`, flagged by the rules | | any | `$foo` (undeclared) | `"$foo"`, with a warning; the operator stays valid | **Related.** apache#8639 (on `main`) binds the references and computes the blocks. apache#8750 (on `main`) adds the `noLoopVariable` marks. **Screenshots.** The Limit outside the loop keeps the number field it has on `main`. The Limit inside the loop gets a text box that suggests the loop's variables and flags a name the loop does not declare. The third shot predates the change of that flag to a warning, which leaves Run enabled. | Before: outside a loop (same as `main`) | After: inside a loop | After: an undeclared name | |---|---|---| | ![Limit outside the loop: number field holding 3](https://raw.githubusercontent.com/aglinxinyuan/texera/390db38157491c992db75f25dc703bad05b4ab65/panel-before-outside-loop.png) | ![Limit inside the loop: $i with the $i suggestion](https://raw.githubusercontent.com/aglinxinyuan/texera/390db38157491c992db75f25dc703bad05b4ab65/panel-after-inside-loop.png) | ![Limit inside the loop: $foo flagged as not a variable of an enclosing block](https://raw.githubusercontent.com/aglinxinyuan/texera/390db38157491c992db75f25dc703bad05b4ab65/panel-after-undeclared.png) | The workflow in the shots: `Text Input -> Loop Start (i = 0) -> Limit ($i) -> Loop End`, plus a second Limit fed straight from Text Input, outside the loop. ![Workflow with the in-loop Limit selected and its panel suggesting $i](https://raw.githubusercontent.com/aglinxinyuan/texera/390db38157491c992db75f25dc703bad05b4ab65/after-inside-loop-suggests.png) ### Any related issues, documentation, discussions? Closes apache#8636 ### How was this PR tested? New and updated Vitest specs, run from `frontend/`: | Spec | Covers | |---|---| | `LogicalPlanSpec` (backend) | `enclosingLoopStarts` on every case and random graph of the shared fixture, outermost first. The fixture's Loop Start and Loop End are read by the backend's JSON type names, so a renamed type fails here. The walk-based check on named cases and 400 random DAGs stays. | | `loop-block.util.spec.ts` (new) | The frontend's port on every case and random graph of the same fixture, and on every operator type it names. A graph with a cycle, which the backend rejects but the canvas allows, ends and counts as outside every block. A link to an operator it was not given is ignored. | | `loop-variable.util.spec.ts` | Assignment forms; if/else, try/except, while and for bodies; for targets; one-line compound bodies; import forms (`from ... import`, aliases, relative modules, parenthesized lists, `import a.b`, several on one line; `*` binds nothing); def/class bodies and with/except-as names excluded; Python keywords never taken for names. `loopVariablesInScope`: outermost first without duplicates, undefined outside every block, a disabled operator and its links left out. `loopScopeChangeStream` emits on adds, deletes, disables, enables and Loop Start property changes, and on nothing else. | | `loop-variable-field.util.spec.ts` | Complete vs partial numerals (`7.`, `-0.`, `1e-` kept as text); the parser sets the control without redrawing the box; the string `""` default; the boolean validator rejects `maybe`. On a field with value rules: a reference passes the rules, every other value is still judged by them, the re-validation hook survives, and `props` stays the one object `templateOptions` names. An unknown name gives a warning, not a validation error. `inheritNoLoopVariable` carries a mark to every schema under it, through each keyword that holds a schema and through `$ref`s, without marking a definition an unmarked property shares. | | `loop-variable-input.component.spec.ts` (new) | Rendered through a real formly form: typing `1.05`, `-0.5` and `7.5` one key at a time stores the right number and keeps the box as typed; `$i` and integers; formly attributes reach the input. An unknown name shows the warning. With value rules: the suggestions add the accepted values of the row's parameter (empty box, typed prefix in either case, `$` prefix), and a changed parameter re-judges the value. | | `validation-workflow.service.spec.ts` | The waiver applies only to primitive types. An unknown name leaves the operator valid. Canvas state follows each edit at once: a block opened or closed, and an operator moved out of its block and back while another operator is invalid. Edits two hops away are covered too: an upstream link deleted, a block closed by a link between two other operators, an operator inserted into the body, and a Loop End disabled and enabled again. Each of these four fails if validation stops listening to `loopScopeChangeStream`. | | `operator-property-edit-frame.component.spec.ts` | Primitive fields converted inside a block; file picker, enum and array keep their controls; the form rebuilds when a link, a disabled or enabled operator, or the Loop Start's variables change its scope, and only then. The open operator leaves its block and comes back while another operator on the canvas is invalid. A value-rules field takes `$i` inside a block and keeps its own control outside; with a schema enum or a custom widget it keeps its control inside too. A `noLoopVariable` property, and a field nested under one, keeps its control inside a block. Typing `$` into a number field inside a block keeps the form as it is. | | `shared-editing.interface.spec.ts` | A string replaces a number in a Y.Map instead of throwing. | Each new behavior spec was checked red against the pre-fix code before the final run. ``` yarn ng test --watch=false --include=<the 7 loop and shared-editing specs> # 488 passed, 1 skipped (existing it.skip) yarn ng test --watch=false # 240 files, 6815 passed, 1 skipped (existing it.skip) yarn exec tsc --noEmit -p src/tsconfig.app.json (and src/tsconfig.spec.json) # clean yarn exec ngc -p src/tsconfig.app.json --noEmit # AOT + strictTemplates clean yarn prettier-eslint --list-different <changed files> && yarn eslint <changed files> # clean sbt "WorkflowCompiler/testOnly *LogicalPlanSpec" # 27 passed sbt scalafmtCheckAll "WorkflowCompiler/scalafixAll --check" # clean ``` `yarn ng build` did not complete locally, because the worktree's `node_modules` is a symlink; CI's frontend build passes on macOS, Ubuntu and Windows. An earlier revision was checked by hand on a local deployment with apache#8639 and apache#8642 (the test branch in apache#8645): the loop workflow runs, and the panel behaves as in the screenshots. The changes since (membership from the whole graph, imports, the warning, `noLoopVariable`) are covered by the specs above. Manual steps for the reviewer (Chrome, desktop): link `Loop Start -> Limit -> Loop End` and set the Loop Start initialization to `i = 0`. Open `Limit`: its integer field is a text box, typing `$` offers `$i`, and choosing it keeps the operator valid. Typing `$foo` shows a warning, "$foo is not a variable of an enclosing block; ...", and Run stays enabled. Delete a link so `Limit` leaves the block, or disable the Loop End: the field is a number box again and `$i` is a type error. ### Was this PR authored or co-authored using generative AI tooling? Generated-by: Claude Code (Claude Fable 5.1, Claude Opus 5.5) 🤖 Generated with [Claude Code](https://claude.com/claude-code)
1 parent f674649 commit 8687c2a

24 files changed

Lines changed: 3835 additions & 28 deletions

‎.github/labeler.yml‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,11 @@ frontend:
1818
- changed-files:
1919
- any-glob-to-any-file:
2020
- 'frontend/**'
21+
# Shared with the backend's LogicalPlanSpec: loop-block.util.spec.ts
22+
# runs the frontend's port of LogicalPlan.enclosingLoopStarts against
23+
# it, so a change to it (as after a change to LogicalPlan) must run
24+
# the frontend stack too, not only the `common` ones.
25+
- 'common/workflow-compiler/src/test/resources/loop-blocks.json'
2126

2227
pyright-language-service:
2328
# Standalone Pyright LSP bridge served to the frontend code editor. It is

‎common/workflow-compiler/src/main/scala/org/apache/texera/common/compiler/model/LogicalPlan.scala‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -93,9 +93,9 @@ case class LogicalPlan(
9393
* whose two ends match, each with the LoopStarts of the blocks it is inside: those with a path
9494
* to it on which no LoopEnd closes their block (a LoopEnd closes the innermost block the path
9595
* opened). A control operator is not inside its own block, but an inner block's are inside the
96-
* outer one. The property panel decides where it offers `$K` with its own walk from each
97-
* operator (`getEnclosingLoopStarts`, loop-block.util.ts); `LogicalPlanSpec` checks that the
98-
* two agree on the same graph.
96+
* outer one. The property panel decides where it offers `$K` with a port of this
97+
* (`enclosingLoopStarts`, loop-block.util.ts); `LogicalPlanSpec` and the port's spec run the same
98+
* cases (loop-blocks.json), so the two agree.
9999
*/
100100
lazy val enclosingLoopStarts: Map[OperatorIdentity, Set[OperatorIdentity]] = {
101101
val order = getTopologicalOpIds.asScala.toList

‎common/workflow-compiler/src/test/resources/loop-blocks.json‎

Lines changed: 239 additions & 0 deletions
Large diffs are not rendered by default.

‎common/workflow-compiler/src/test/scala/org/apache/texera/common/compiler/LogicalPlanSpec.scala‎

Lines changed: 72 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,7 @@ import org.apache.texera.amber.operator.udf.python.DualInputPortsPythonUDFOpDesc
3434
import org.apache.texera.amber.operator.udf.python.source.PythonUDFSourceOpDescV2
3535
import org.apache.texera.amber.operator.union.UnionOpDesc
3636
import org.apache.texera.amber.operator.{LogicalOp, TestOperators}
37+
import org.apache.texera.amber.util.JSONUtils.objectMapper
3738
import org.apache.texera.common.compiler.model.{LogicalLink, LogicalPlan, LogicalPlanPojo}
3839
import org.scalatest.flatspec.AnyFlatSpec
3940

@@ -282,7 +283,7 @@ class LogicalPlanSpec extends AnyFlatSpec {
282283
}
283284

284285
// ---------------------------------------------------------------------------
285-
// operatorsInsideLoopBlocks: the cases mirror the frontend's `getEnclosingLoopStarts` spec
286+
// operatorsInsideLoopBlocks; loop-blocks.json holds cases the frontend's port runs too
286287
// ---------------------------------------------------------------------------
287288

288289
private def loopStart(id: String): LogicalOp = named(new LoopStartOpDesc, id)
@@ -291,31 +292,28 @@ class LogicalPlanSpec extends AnyFlatSpec {
291292

292293
/**
293294
* The ids of the operators inside a loop block, `edges` as "from" -> "to" ids, checked against
294-
* the property panel's walk, as are the LoopStarts around each (`enclosingLoopStarts`).
295+
* a walk from each operator, as are the LoopStarts around each (`enclosingLoopStarts`).
295296
*/
296297
private def inside(operators: List[LogicalOp], edges: (String, String)*): Set[String] = {
297298
val plan = LogicalPlan(
298299
operators,
299300
edges.toList.map { case (from, to) => link(OperatorIdentity(from), OperatorIdentity(to)) }
300301
)
301302
val around = plan.enclosingLoopStarts.map { case (id, starts) => id.id -> starts.map(_.id) }
302-
val byPanel = enclosingByPanel(operators, edges)
303+
val byWalk = enclosingByWalk(operators, edges)
303304
assert(
304-
around == byPanel,
305-
s"the panel's walk finds $byPanel, not $around, in ${operators.map(_.operatorIdentifier.id)} " +
305+
around == byWalk,
306+
s"the walk finds $byWalk, not $around, in ${operators.map(_.operatorIdentifier.id)} " +
306307
s"with $edges"
307308
)
308309
plan.operatorsInsideLoopBlocks.map(_.id)
309310
}
310311

311312
/**
312-
* A port of the property panel's `getEnclosingLoopStarts` (frontend loop-block.util.ts), which
313-
* decides where the panel offers `$K`: each operator with an enclosing LoopStart, and those
314-
* LoopStarts. It walks from each operator where `enclosingLoopStarts` folds over the plan. It
315-
* leaves out the panel's hop counts, which only order the LoopStarts, and its cap on open
316-
* blocks, which binds only on a cycle.
313+
* Each operator with an enclosing LoopStart, and those LoopStarts, found another way: it walks
314+
* from each operator where `enclosingLoopStarts` folds over the plan.
317315
*/
318-
private def enclosingByPanel(
316+
private def enclosingByWalk(
319317
operators: List[LogicalOp],
320318
edges: Seq[(String, String)]
321319
): Map[String, Set[String]] = {
@@ -425,7 +423,7 @@ class LogicalPlanSpec extends AnyFlatSpec {
425423
)
426424
}
427425

428-
it should "agree with the property panel's walk on random graphs of loop and plain operators" in {
426+
it should "agree with a walk from each operator on random graphs of loop and plain operators" in {
429427
val random = new Random(8640)
430428
(1 to 400).foreach { _ =>
431429
val size = 2 + random.nextInt(11)
@@ -440,6 +438,68 @@ class LogicalPlanSpec extends AnyFlatSpec {
440438
}
441439
}
442440

441+
/**
442+
* The LoopStarts around each operator inside a block, outermost first, as the property panel
443+
* lists them: fewer LoopStarts around a LoopStart first, then by id.
444+
*/
445+
private def outermostFirst(plan: LogicalPlan): Map[String, List[String]] = {
446+
val around = plan.enclosingLoopStarts.map { case (id, starts) => id.id -> starts.map(_.id) }
447+
around.map {
448+
case (id, starts) =>
449+
id -> starts.toList.sortBy(start => (around.get(start).map(_.size).getOrElse(0), start))
450+
}
451+
}
452+
453+
"LogicalPlan.enclosingLoopStarts" should "give the answer of every case the frontend's port shares" in {
454+
// loop-blocks.json, which loop-block.util.spec.ts runs against the frontend's port too.
455+
val fixture = objectMapper.readTree(getClass.getResourceAsStream("/loop-blocks.json"))
456+
val cases = (fixture.get("cases").elements().asScala ++
457+
fixture.get("randomGraphs").elements().asScala).toList
458+
assert(cases.size > 100, "the fixture lost its cases")
459+
val mismatches = cases.flatMap { testCase =>
460+
val operators = testCase.get("operators").elements().asScala.toList.map { operator =>
461+
val id = operator.get("id").asText()
462+
operator.get("type").asText() match {
463+
case "Operator" => op(id)
464+
// Read by the backend's own JSON type name, which the frontend's operators carry and its
465+
// port matches, so the fixture cannot name a LoopStart or a LoopEnd any other way.
466+
case controlType =>
467+
val json = s"""{"operatorType": "$controlType"}"""
468+
val control = objectMapper.readValue(json, classOf[LogicalOp])
469+
assert(
470+
control.isInstanceOf[LoopStartOpDesc] || control.isInstanceOf[LoopEndOpDesc],
471+
s"$controlType reads as ${control.getClass.getSimpleName} in ${testCase.get("name")}"
472+
)
473+
named(control, id)
474+
}
475+
}
476+
val ends = testCase.get("links").elements().asScala.toList.map { link =>
477+
link.get("from").asText() -> link.get("to").asText()
478+
}
479+
// A second link into an operator arrives on a port of its own.
480+
val links = ends.zipWithIndex.map {
481+
case ((from, to), index) =>
482+
link(
483+
OperatorIdentity(from),
484+
OperatorIdentity(to),
485+
toPort = ends.take(index).count(_._2 == to)
486+
)
487+
}
488+
val expected = testCase
489+
.get("enclosingLoopStarts")
490+
.fields()
491+
.asScala
492+
.map(entry => entry.getKey -> entry.getValue.elements().asScala.map(_.asText()).toList)
493+
.toMap
494+
val answer = outermostFirst(LogicalPlan(operators, links))
495+
Option.when(answer != expected) {
496+
s"${testCase.get("name").asText()}: the fixture says ${objectMapper.writeValueAsString(expected)}, " +
497+
s"the plan ${objectMapper.writeValueAsString(answer)}"
498+
}
499+
}
500+
if (mismatches.nonEmpty) fail(mismatches.mkString("\n"))
501+
}
502+
443503
// ---------------------------------------------------------------------------
444504
// resolveScanSourceOpFileName
445505
// ---------------------------------------------------------------------------

‎frontend/src/app/app.module.ts‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -107,6 +107,7 @@ import { HuggingFaceImageUploadComponent } from "./workspace/component/hugging-f
107107
import { HuggingFaceComponent } from "./workspace/component/hugging-face/hugging-face.component";
108108
import { HuggingFaceAudioUploadComponent } from "./workspace/component/hugging-face-audio-upload/hugging-face-audio-upload.component";
109109
import { DatasetFileSelectorComponent } from "./workspace/component/dataset-file-selector/dataset-file-selector.component";
110+
import { LoopVariableInputComponent } from "./workspace/component/loop-variable-input/loop-variable-input.component";
110111
import { DatasetVersionSelectorComponent } from "./workspace/component/dataset-version-selector/dataset-version-selector.component";
111112
import { DatasetSelectionModalComponent } from "./workspace/component/dataset-selection-modal/dataset-selection-modal.component";
112113
import { ReActStepDetailModalComponent } from "./workspace/component/agent/agent-panel/react-step-detail-modal/react-step-detail-modal.component";
@@ -325,6 +326,7 @@ registerLocaleData(en);
325326
HuggingFaceAudioUploadComponent,
326327
HuggingFaceImageUploadComponent,
327328
DatasetFileSelectorComponent,
329+
LoopVariableInputComponent,
328330
DatasetVersionSelectorComponent,
329331
DatasetSelectionModalComponent,
330332
ReActStepDetailModalComponent,

‎frontend/src/app/common/formly/formly-config.ts‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,8 @@ import { ResourceValueSelectorComponent } from "../../workspace/component/resour
3939
import { HuggingFaceImageUploadComponent } from "../../workspace/component/hugging-face-image-upload/hugging-face-image-upload.component";
4040
import { HuggingFaceComponent } from "../../workspace/component/hugging-face/hugging-face.component";
4141
import { HuggingFaceAudioUploadComponent } from "../../workspace/component/hugging-face-audio-upload/hugging-face-audio-upload.component";
42+
import { LoopVariableInputComponent } from "../../workspace/component/loop-variable-input/loop-variable-input.component";
43+
import { LOOP_VARIABLE_INPUT_TYPE } from "../../workspace/util/loop-variable-field.util";
4244

4345
/**
4446
* Configuration for using Json Schema with Formly.
@@ -89,6 +91,7 @@ export const TEXERA_FORMLY_CONFIG = {
8991
{ name: "multischema", component: MultiSchemaTypeComponent },
9092
{ name: "codearea", component: CodeareaCustomTemplateComponent },
9193
{ name: "inputautocomplete", component: DatasetFileSelectorComponent, wrappers: ["form-field"] },
94+
{ name: LOOP_VARIABLE_INPUT_TYPE, component: LoopVariableInputComponent, wrappers: ["form-field"] },
9295
{ name: "datasetversionselector", component: DatasetVersionSelectorComponent, wrappers: ["form-field"] },
9396
{ name: "huggingface", component: HuggingFaceComponent, wrappers: ["form-field"] },
9497
{ name: "huggingface-audio-upload", component: HuggingFaceAudioUploadComponent, wrappers: ["form-field"] },
Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
<!--
2+
Licensed to the Apache Software Foundation (ASF) under one
3+
or more contributor license agreements. See the NOTICE file
4+
distributed with this work for additional information
5+
regarding copyright ownership. The ASF licenses this file
6+
to you under the Apache License, Version 2.0 (the
7+
"License"); you may not use this file except in compliance
8+
with the License. You may obtain a copy of the License at
9+
10+
http://www.apache.org/licenses/LICENSE-2.0
11+
12+
Unless required by applicable law or agreed to in writing,
13+
software distributed under the License is distributed on an
14+
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15+
KIND, either express or implied. See the License for the
16+
specific language governing permissions and limitations
17+
under the License.
18+
-->
19+
<input
20+
nz-input
21+
[formControl]="formControl"
22+
[formlyAttributes]="field"
23+
[nzAutocomplete]="loopVariables" />
24+
<nz-autocomplete
25+
#loopVariables
26+
[nzBackfill]="false">
27+
<nz-auto-option
28+
*ngFor="let option of suggestions"
29+
[nzValue]="option"
30+
[nzLabel]="option">
31+
{{ option }}
32+
</nz-auto-option>
33+
</nz-autocomplete>
34+
<div
35+
*ngIf="warning as message"
36+
class="ant-form-item-explain">
37+
<div
38+
role="alert"
39+
class="ant-form-item-explain-warning">
40+
{{ message }}
41+
</div>
42+
</div>

0 commit comments

Comments
 (0)