}

	funcs := createFuncs(i)
	for _, f := range funcs {
		b.AddFunc(f)
	}
	drws := &slicewriter.WriteSeeker{}
	b.Emit(drws)
	return drws.BytesWritten()
}

func createMetaDataBlobs(t *testing.T, nb int) [][]byte {
	res := [][]byte{}
	for i := 0; i < nb; i++ {
		res = append(res, createBlob(t, i))
	}
	return res
}

func TestMetaDataWriterReader(t *testing.T) {

  ModuleOp module = getOperation();
  auto& side_effect_analysis = getAnalysis<TF::SideEffectAnalysis>();
  SmallVector<func::FuncOp> funcs(module.getOps<func::FuncOp>());
  int func_count = -1;
  for (auto func : funcs) {
    const auto& info = side_effect_analysis.GetAnalysisForFunc(func);
    for (auto& block : func) {
      OpBuilder builder = OpBuilder::atBlockBegin(&block);
      RaiseTargetSubgraphsForBlock(block, builder, module,

  "func.func"() ({
  ^bb0(%arg0: tensor<i32>):
    "func.return"(%arg0) : (tensor<i32>) -> ()
  }) {sym_name = "main_while_body_4225150", sym_visibility = "private", tf._input_shapes = [#tf_type.shape<>], tf.signature.is_stateful, function_type = (tensor<i32>) -> (tensor<i32>)} : () -> ()
  "func.func"() ({
  ^bb0(%arg0: tensor<i32>):

```Python hl_lines="10"
{!../../../docs_src/security/tutorial001.py!}
```

Esse dependência vai fornecer uma `str` que é atribuído ao parâmetro `token da *função do path operation*

A **FastAPI** saberá que pode usar essa dependência para definir um "esquema de segurança" no esquema da OpenAPI (e na documentação da API automática).

!!! info "Detalhes técnicos"

    and use the standardized MLIR `sym_name` attribute to hold it.

    This dialect annotates func ops with two argument attributes
    `tf_saved_model.index_path` and `tf_saved_model.bound_input` in order to
    model the calling API of a function with SavedModel semantics.
    In particular, func's in SavedModel are called with a structured value, and
    return a structured value. A structured value consists of arbitrarily nested

    // results and arguments.
    llvm::DenseMap<OpValue, int> operand_states_;
    llvm::DenseMap<OpValue, int> result_states_;
  };

  func::FuncOp func_;

  DeviceTarget target_spec_;

  StatesManager states_manager_;
};

}  // namespace quant
}  // namespace mlir

    // Insert a call to the reducer in the region of the mhlo op.
    mlir::SymbolRefAttr func = op.getComputation();
    auto func_op = cast<mlir::func::FuncOp>(SymbolTable::lookupSymbolIn(
        op->getParentOfType<mlir::ModuleOp>(), func));
    auto func_ty = func_op.getFunctionType();
    BuildBodyWithCall(rewriter, loc, func, func_ty,
                      &reduce_window_op.getBody());

  // Quantizer via the tf_quant.composite_function UnitAttr attached to
  // func ops. We remove this attribute as this interferes with VHLO conversion.
  // Remove this temporary hack.
  for (auto func_op : module_op.getOps<func::FuncOp>()) {
    func_op->removeAttr(kFusedFunctionAttr);
  }
}

}  // namespace

# This check that we don't error out when importing GraphDef containing
# functions with arg name that are the same as the graph input name

# CHECK: func @main(%arg0: tensor<{{.*}}i32>) -> tensor<{{.*}}i32>
# CHECK: func private @while_body
# CHECK: func private @while_cond

node {
  name: "input"
  op: "Placeholder"
  attr {
    key: "_user_specified_name"
    value {
      s: "input"
    }
  }

// `ExtractSubgraphToFunc` adds exactly two "new" `Operations`, a FuncOp and
// a CallOp. Pass these back to the caller for setting more specific attributes
// after graph mutation has taken place.
struct OpsAdded {
  mlir::func::FuncOp func_op;
  mlir::func::CallOp call_op;
};

// Given a `Subgraph` containing a sequence of adjacent `Operations` from