```Python hl_lines="15"
    {!> ../../../docs_src/dependencies/tutorial012.py!}
    ```

Und alle Ideen aus dem Abschnitt über das [Hinzufügen von `dependencies` zu den *Pfadoperation-Dekoratoren*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} gelten weiterhin, aber in diesem Fall für alle *Pfadoperationen* in der Anwendung.

## Abhängigkeiten für Gruppen von *Pfadoperationen*

  // CHECK: "tf.StatefulPartitionedCall"
  // CHECK-SAME: f = @callee
  %call = "tf.StatefulPartitionedCall"(%stack, %arg0) {f = @callee, config = "", config_proto = "", executor_type = ""}
    : (tensor<!tf_type.resource>, tensor<i1>) -> tensor<!tf_type.resource>
  // CHECK: "tf.PartitionedCall"
  // CHECK-SAME: f = @callee
  %call2 = "tf.PartitionedCall"(%stack, %arg0) {f = @callee, config = "", config_proto = "", executor_type = ""}

  # CHECK-NOT:    tf_saved_model.exported_names

  @tf.function(input_signature=[tf.TensorSpec([], tf.float32)])
  def callee(self, x):
    return x, self.v

  @tf.function(input_signature=[tf.TensorSpec([], tf.float32)])
  def caller(self, x):
    return self.callee(x)


if __name__ == '__main__':

  // cluster ops.
  while (!function_worklist.empty()) {
    func::FuncOp caller = function_worklist.front();
    function_worklist.pop();
    for (auto callee : caller_callee_map[caller]) {
      if (reachable_functions.insert(callee).second)
        function_worklist.push(callee);
    }
  }
}

// Applies patterns locally on ops within `cluster` until convergence or

    for (auto callee : {&if_op.getThenBranch(), &if_op.getElseBranch()}) {
      work_list->push_back(std::make_pair(callee, argument_index));
    }
  } else if (auto while_op = dyn_cast<TF::WhileOp>(user_op)) {
    (*arguments_to_erase)[while_op].push_back(argument_index);
    for (auto callee : {while_op.cond_function(), while_op.body_function()}) {
      (*arguments_to_erase)[callee].push_back(argument_index);

type Ctr interface {
	Count() int
}

type Conc struct {
	X int
}

func (c *Conc) Count() int {
	return c.X
}

func DoCall(c *Conc) {
	c2 := Callee(c)
	println(c2.Count())
}

func Callee(ii Ctr) Ctr {
	q := ii.Count()
	return &Conc{X: q}
}
-- main/main.go --
package main

import (
	"M/a"
	"M/b"
)

func MFunc() string {
	return "42"

## `HTTPSRedirectMiddleware`

Erzwingt, dass alle eingehenden Requests entweder `https` oder `wss` sein müssen.

Alle eingehenden Requests an `http` oder `ws` werden stattdessen an das sichere Schema umgeleitet.

```Python hl_lines="2  6"
{!../../../docs_src/advanced_middleware/tutorial001.py!}
```

## `TrustedHostMiddleware`

  if (!emplace_res.second) {
    // This callee was handled before.
    if (!info.signature_change) return success();
    return recreate_caller();
  }
  // Rewrite the callee.
  llvm::SmallDenseMap<Value, SizeInfo> callee_map;
  func::FuncOp lowered_callee = callee;
  if (!callee.isPrivate()) {
    // Clone non-private callee in case of signature change.
    lowered_callee = callee.clone();
    lowered_callee.setPrivate();

  auto calls_entry_functions = [&](SymbolUserOpInterface op) {
    llvm::SmallVector<func::FuncOp> callees;
    if (GetCallees(op, symtab, callees).failed()) {
      return false;
    }
    for (auto &callee : callees) {
      if (IsEntryFunction(callee)) {
        return true;
      }
    }
    return false;
  };

  for (auto &entry_func : entry_funcs) {
    llvm::SmallVector<SymbolUserOpInterface> calls;

func.func @test_xla_call_module_with_host_communicative_subcomputation() {
  "tf.XlaCallModule"() {Sout = [], device = "", dim_args_spec = [], function_list = [@callee], module = "", platforms = [], version = 4 : i64} : () -> ()
  func.return
}

// CHECK-LABEL: callee
func.func private @callee(%arg0: tensor<i32>) {