//CHECK: %0 = "vhlo.convolution_v1"(%arg0, %arg1) <{
//CHECK-SAME: batch_group_count = #vhlo.integer_v1<1 : i64>,
//CHECK-SAME: feature_group_count = #vhlo.integer_v1<32 : i64>,
//CHECK-SAME: input_batch_dimension = #vhlo.integer_v1<0 : i64>,
//CHECK-SAME: input_feature_dimension = #vhlo.integer_v1<3 : i64>,
//CHECK-SAME: input_spatial_dimensions = #vhlo.tensor_v1<dense<[1, 2]> : tensor<2xi64>>,
//CHECK-SAME: kernel_input_feature_dimension = #vhlo.integer_v1<2 : i64>,

[[concepts_repeatable_task_outputs]]
== Repeatable task outputs

Assume that you have a code generator task as part of your build.
When you have a fully up to date build and you clean and re-run the code generator task on the same code base it should generate _exactly the same output_, so anything that depends on that output will stay up-to-date.

On top of that, an async framework could run some sync code in a threadpool (using `asyncio.run_in_executor`), but belonging to the same request.

Dependency version alignment allows different modules belonging to the same logical group (a _platform_) to have identical versions in a dependency graph.

== Handling inconsistent module versions

Gradle supports aligning versions of modules which belong to the same "platform".
It is often preferable, for example, that the API and implementation modules of a component are using the same version.

  %cst_0 = "tf.Const"() {value = dense<0.500000e+00> : tensor<2xf32>} : () -> tensor<2xf32>
  %0 = "tf.Conv2D"(%arg0, %cst) {data_format = "NHWC", dilations = [1, 1, 2, 1], explicit_paddings = [], padding = "SAME", strides = [1, 1, 2, 1], use_cudnn_on_gpu = true} : (tensor<1x3x4x3xf32>, tensor<2x3x3x2xf32>) -> tensor<1x3x2x2xf32>
  %1 = "tf.AddV2"(%0, %cst_0) : (tensor<1x3x2x2xf32>, tensor<2xf32>) -> tensor<1x3x2x2xf32>

            }
        }
        createTar('test2.tar') {
            subdir1 {
                file ('file.txt').text = 'original text 1' // Same name in same dir
            }
            subdir3 {
                file('file3.txt').text = 'original text 3' // Same name in same different nested dir
                file ('file4.txt').text =  'original text 4'
            }
        }

  // CHECK-LABEL: func @head_single_outside_compiled_op
  func.func @head_single_outside_compiled_op(%arg0: tensor<i32>) {
    // CHECK:      "tf_device.launch"
    // CHECK-SAME: device = "/job:worker/replica:0/task:0/device:CPU:0"
    // CHECK-NEXT:   "tf.A"
    // CHECK-NOT:    _xla_outside_compilation
    // CHECK-NEXT:   tf_device.return
    //
    // CHECK:      "tf_device.cluster"

// RUN: odml-to-stablehlo-opt %s --transpose-commute-ops | FileCheck %s
// CHECK-LABEL:   func.func @commute_transpose_pad(
// CHECK-SAME:          %[[INPUT:.*]]: tensor<1x112x112x64xf32>,
// CHECK-SAME:          %[[PAD_VAL:.*]]: tensor<f32>) -> tensor<1x64x114x114xf32> {
// CHECK:           %[[PAD:.*]] = stablehlo.pad %[[INPUT]], %[[PAD_VAL]],
// CHECK:               low = [0, 1, 1, 0], high = [0, 1, 1, 0], interior = [0, 0, 0, 0]

// CHECK: tfrt_fallback_async.set_resource
// CHECK-SAME: {device = "/device:CPU:0", index = 0 : i64}


// CHECK-LABEL: func @init
// CHECK-SAME: {tfrt.cost_threshold = 1 : i64}
func.func @func_init() attributes {tf_saved_model.exported_names = ["init"]} {
  func.return
}

// CHECK-LABEL: func @basic
// CHECK-SAME: ([[in_chain:%.*]]: !tfrt.chain
// CHECK-SAME: [[arg0:%.*]]: !tfrt_fallback.tf_tensor,

But it's still part of the same **FastAPI** application/web API (it's part of the same "Python Package").

You can create the *path operations* for that module using `APIRouter`.

### Import `APIRouter`

You import it and create an "instance" the same way you would with the class `FastAPI`:

```Python hl_lines="1  3" title="app/routers/users.py"