credentials. Therefore, you can distribute an application (for example, on mobile devices) that requests temporary security credentials without including MinIO long lasting credentials in the application. Instead, the identity of the caller is validated by using a JWT id_token from the web identity provider. The temporary security credentials returned by this API consists of an access key, a secret key, and a security token. Applications can use these temporary security credentials to sign calls to MinIO...

func.func @identity_terminator(%arg0: tensor<i32>) -> (tensor<*xi32>, tensor<i32>) {
  // CHECK: %[[IDENTITY:.*]] = "tf.Identity"
  %0 = "tf.Identity"(%arg0) : (tensor<i32>) -> tensor<*xi32>
  // CHECK-NOT: "tf.Identity"
  %1 = "tf.Identity"(%arg0) : (tensor<i32>) -> tensor<i32>
  // CHECK: return %[[IDENTITY]], %[[ARG0]]
  func.return %0, %1 : tensor<*xi32>, tensor<i32>
}

// CHECK-LABEL: func @xla_sharding

func.func @while_main(%arg0: tensor<?x256x256xf32>) -> (tensor<i32>, tensor<256x256xf32>, tensor<?x256x256xf32>) attributes {tf.entry_function = {inputs = "input", outputs = "Identity,Identity_1,Identity_2"}} {
  %cst = arith.constant dense<1.000000e+00> : tensor<256x256xf32>
  %cst_0 = arith.constant dense<0> : tensor<i32>
  %cst_1 = arith.constant dense<-1> : tensor<i32>

    return absl::OkStatus();
  }

  // Create a single IdentityN that is dead if and only if
  // `predicate_as_control` is dead.
  //
  // IdentityN is also special in that, unlike `Identity`, it does not place
  // int32 inputs in host memory.  Placing int32 inputs in host memory would
  // defeat the purpose of adding this indirection.
  ops::IdentityN identity_n(root.WithOpName("int32_id_n"), int32_inputs);

    // H2D transfer kernels. So fold the tf.Identity op if:
    // * the identity op is placed on TPU, and
    // * the arg to the identity op is produced by a TPUExecuteOp.
    if (op_device && op_device.getValue().contains("TPU")) {
      return true;
    }

    Operation *def_op = arg.getDefiningOp();
    // If the arg to this identity op is the arg of a function, there's no
    // defining op.

                IdentityContext identityContext = createIdentityContextInternal(work, context);
                Identity identity = identityContext.getIdentity();
                operationContext.setResult(new Operation.Result() {
                    @Override
                    public Identity getIdentity() {
                        return identity;
                    }
                });
                return identityContext;
            },

    if (!all_of(variable_v2_op.getResult().getUsers(), [&variable_v2_op](
                                                           Operation *user) {
          if (!isa<IdentityOp>(user)) {
            variable_v2_op.emitOpError()
                << "expects all users to be 'tf.Identity', but got user "
                << user->getName();
            return false;
          }
          return true;
        })) {

	"net/netip"
	"reflect"
	"testing"
)

func getSANExtension(identites []Identity, t *testing.T) *pkix.Extension {
	ext, err := BuildSANExtension(identites)
	if err != nil {
		t.Errorf("A unexpected error has been encountered (error: %v)", err)
	}
	return ext
}

func TestBuildSubjectAltNameExtension(t *testing.T) {
	uriIdentity := Identity{Type: TypeURI, Value: []byte("spiffe://test.domain.com/ns/default/sa/default")}

  // CHECK-NOT: tf.Identity
  %5 = "tf.Identity"(%4) {T = f32, _output_shapes = ["tfshape$dim { size: 3 } dim { size: 3 }"], device = "/device:CPU:0"} : (tensor<3x3xf32>) -> tensor<3x3xf32>
  // CHECK-NOT: tf.IdentityN

Aditya Manthramurthy <******@****.***> 1714599073 -0700