f_name_attr.set_name(fd.signature().name());
  TF_ASSERT_OK(
      NodeBuilder("B", "StatefulPartitionedCall", &root.graph()->flib_def())
          .Input(inputs)
          .Attr("Tin", {DT_RESOURCE})
          .Attr("Tout", {DT_RESOURCE})
          .Attr("f", f_name_attr)
          .Finalize(root.graph(), &call));
  call->AddAttr(std::string(kMustCompileAttr), true);

  TF_ASSERT_OK(root.ToGraph(&graph));

			getter := NewNodeAuthorizerAttributesGetter(authzTestNodeName)

			req, err := http.NewRequest(test.Method, "https://localhost:1234"+test.Path, nil)
			require.NoError(t, err)
			attrs := getter.GetRequestAttributes(AuthzTestUser(), req)

			test.AssertAttributes(t, attrs)
		})
	}
}

const (
	authzTestNodeName = "test"
	authzTestUserName = "phibby"
)

type AuthzTestCase struct {
	Method, Path string

// with `func_name` and `node_name` to identify the op.
REGISTER_OP("DumpTensor")
    .Input("tensor_data: T")
    .Attr("log_dir_path: string")
    .Attr("file_name: string")
    .Attr("T: type")
    .Attr("enabled: bool")
    .Attr("func_name: string")
    .Attr("node_name: string")
    .SetIsStateful();

class DumpTensorOp : public OpKernel {
 public:

    from pydantic.fields import (  # type: ignore[no-redef,attr-defined]
        Required as Required,  # noqa: F401
    )
    from pydantic.fields import (  # type: ignore[no-redef,attr-defined]
        Undefined as Undefined,
    )
    from pydantic.fields import (  # type: ignore[no-redef, attr-defined]
        UndefinedType as UndefinedType,  # noqa: F401
    )
    from pydantic.schema import (
        field_schema,

    output_tys.push_back(mlir_ty);
  }
  llvm::SmallVector<mlir::NamedAttribute, 4> attrs;
  for (const auto& attr : node_def.attr()) {
    TF_ASSIGN_OR_RETURN(auto mlir_attr,
                        ConvertAttributeValue(attr.second, &builder));
    attrs.push_back({mlir::StringAttr::get(context, attr.first), mlir_attr});
  }

  mlir::Location loc = mlir::UnknownLoc::get(context);

    "'TFLite_Detection_PostProcess:3' type: DT_FLOAT } attr : { name: "
    "'h_scale' type: 'float'} attr : { name: 'max_classes_per_detection' "
    "type: 'int'} attr : { name: 'max_detections' type: 'int'} attr : { "
    "name: 'nms_iou_threshold' type: 'float'} attr : { name: "
    "'nms_score_threshold' type: 'float'} attr : { name: 'num_classes' type: "
    "'int'} attr : { name: 'w_scale' type: 'float'} attr : { name: 'x_scale' "

        $('#section-sign-' + $(this).attr('scenario')).css('opacity', '1');
    }).mouseleave(function () {
        $('#section-sign-' + $(this).attr('scenario')).css('opacity', '0');
    });

    $('.section-sign').click(function () {
        var $temp = $("<input>");
        $("body").append($temp);
        $temp.val(window.location.href.split('#')[0] + $(this).attr('href')).select();
        document.execCommand("copy");

        group = g
        module = m
        version = v
        this.preferredVersion = preferredVersion
        this.strictVersion = strictVersion
        rejects = r?:Collections.<String>emptyList()
        reason = desc
        attributes = attrs
    }

                    div().classAttr("col text-right mt-1");
                        i().classAttr("fa fa-filter").attr("data-toggle", "popover", "data-placement", "bottom").title("Filter by tag").style("cursor: pointer").text(" ").end();
                    end();
                    div().classAttr("col p-0")
                        .attr("data-toggle", "tooltip")
                        .style("font-size: smaller")

  return {"tf.entry_function",
          tf_saved_model::kTfSavedModelInitializerTypeAttr};
}

bool IsEntryFunction(func::FuncOp func) {
  for (const auto &attr : GetEntryFunctionAttributeNames()) {
    if (func->hasAttr(attr)) {
      return true;
    }
  }
  return false;
}

llvm::SmallVector<func::FuncOp> GetEntryFunctions(ModuleOp module) {
  llvm::SmallVector<func::FuncOp> entry_funcs;