# https://github.com/tensorflow/tensorflow/actions/workflows/release-branch-cherrypick.yml
# and click "Run Workflow." Leave "Use Workflow From" set to "master", then
# input the branch name and paste the cherry-pick commit and click Run. A PR
# will be created.

name: Release Branch Cherrypick
on:
  workflow_dispatch:
    inputs:
      # We use this instead of the "run on branch" argument because GitHub looks

name: Upload SIG Build docker containers modified for release branches

on:
  workflow_dispatch:
  push:
    paths:
      - '.github/workflows/sigbuild-docker-branch.yml'
      - 'tensorflow/tools/tf_sig_build_dockerfiles/**'
      - '!tensorflow/tools/tf_sig_build_dockerfiles/README.md'
    branches:
      - "r[1-9].[0-9]+"

permissions:
  contents: read

jobs:

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * A bunch of information about the request that launched the current build.
 */
@ServiceScope(Scope.BuildSession.class)
public interface BuildRequestMetaData {

    /**
     * Returns the meta-data about the client used to launch this build.
     */
    BuildClientMetaData getClient();

    /**

def LaunchToDeviceAttributePass : Pass<"tf-launch-to-device-attribute", "mlir::func::FuncOp"> {
  let summary = "Hoists and annotates device launch inner ops with associated device attribute.";

  let description = [{
    This pass hoists a `tf_device.launch` body and assigns a `device` attribute
    to each TensorFlow dialect op in the body based on the `device` attribute on
    the `tf_device.launch`. If a TensorFlow dialect op already has a device

    }

    if (!devices.has_value()) return WalkResult::advance();

    // Map aliased devices to explicit devices based on replica.
    if (auto launch = dyn_cast<tf_device::LaunchOp>(op))
      if (auto device_by_replica = devices.value().get(launch.getDevice()))
        launch->setAttr(
            kDeviceAttr,
            device_by_replica.cast<ArrayAttr>()[replica_id].cast<StringAttr>());

    return WalkResult::advance();

	p = obj.Appendp(p, c.newprog)

	p.As = AJAL
	p.To.Type = obj.TYPE_BRANCH
	if c.cursym.CFunc() {
		p.To.Sym = c.ctxt.Lookup("runtime.morestackc")
	} else if !c.cursym.Func().Text.From.Sym.NeedCtxt() {
		p.To.Sym = c.ctxt.Lookup("runtime.morestack_noctxt")
	} else {
		p.To.Sym = c.ctxt.Lookup("runtime.morestack")
	}
	p.Mark |= BRANCH

	p = c.cursym.Func().UnspillRegisterArgs(p, c.newprog)

      branch: release-1.27
    - repository: client-go
      branch: release-1.27
    - repository: apiserver
      branch: release-1.27
    - repository: component-base
      branch: release-1.27
    - repository: kms
      branch: release-1.27
    - repository: code-generator
      branch: release-1.27
    source:
      branch: release-1.27
      dirs:
      - staging/src/k8s.io/kube-aggregator

  // Forward launch inner op results to launch op results.
  launch.replaceAllUsesWith(launch.GetBody().getTerminator()->getOperands());

  // For all inner ops, assign the launch device as a `device` attribute.
  if (failed(AssignDevicesInRegion(tf_dialect, launch, launch.getBody())))
    return failure();

  // Move all inner ops of the launch to the block containing the launch.

  // CHECK-NOT: "tf_device.launch"
  // CHECK: "tf.opA"
  "tf.opA"() {device = ""} : () -> tensor<i1>
  func.return
}

// Tests that an op not in tf dialect (tf_device.launch) with device attribute is not wrapped in `tf_device.launch`.
// Also tests that a `tf_device.launch` is not rewrapped.
// CHECK-LABEL: func @non_tf_op
func.func @non_tf_op() {
  // CHECK: "tf_device.launch"
  // CHECK-NOT "tf_device.launch"
  // CHECK: "tf.opA"

        buildFile << """
model {
    binaries {
        all {
            if (flavor == flavors.french) {
                cppCompiler.define "FRENCH"
            }
        }
    }
    components {
        main { targetFlavors "french" }
        hello { targetFlavors "french" }
        greetings { targetFlavors "french" }
    }
}
"""
        when:
        succeeds "installMainExecutable"

        then: