filter(scala.Function1); public final Object filterNot(scala.Function1); public final scala.Tuple2 partition(scala.Function1); public final scala.Option headOption(); public final Object tail(); public final Object last(); public final scala.Option lastOption(); public final Object sliceWithKnownDelta$1796fe1c(int, int); public final Object sliceWithKnownBound(int, int); public final Object to(scala.collection.generic.CanBuildFrom); public final String stringPrefix(); public final int size(); public...

           "the attribute `tf._noinline = true`. This attributes the function "
           "from being inlined by the `InlinerPass`.";
  }

  void runOnOperation() override;

 private:
  ListOption<std::string> CreateNoinlineFunctionsOption(
      const ArrayRef<std::string> noinline_functions) {
    return {*this, "noinline-functions",
            llvm::cl::desc(

             "bool", "false",
             "Use legacy quantize mode in test. Valid when `-legacy-quantize` is set.">,
      ListOption<"ops_blocklist_flag_", "ops-blocklist",
             "std::string", "Names of ops to blocklist from quantization">,
      ListOption<"nodes_blocklist_flag_", "locs-blocklist",
             "std::string", "Names of location to blocklist from quantization">,

 private:
  void runOnFunction() override;
  void SetTargetAnnotation(Operation* op,
                           llvm::ArrayRef<std::string> device_specs,
                           OpBuilder* builder);

  ListOption<std::string> device_specs_flag_{
      *this, "device-specs",
      llvm::cl::desc(
          "comma separated list of device specs, like CPU, GPU, Hexagon."),
      llvm::cl::ZeroOrMore};

    Finds all `CustomAggregator` ops in the each function and add a single
    `CalibrationStatisticsSaver` op at the end of the function to collect their
    statistics.
  }];
  let options = [
    ListOption<"aggregator_ops_to_ignore_", "aggregator-ops-to-ignore", "std::string",
               "Ops to ignore when inserting CalibrationStatisticsSaver.">,
    Option<"calibration_data_dir_", "calibration-data-dir",

      OpBuilder* builder);

  // Apply any device-specific optimizations.
  void Optimize(func::FuncOp func, const std::string& hardware);

  ListOption<std::string> device_specs_flag_{
      *this, "device-specs",
      llvm::cl::desc(
          "comma separated list of device specs, like CPU, GPU, DPS."),
      llvm::cl::ZeroOrMore};
};

					return nil
				},
			}
			assert.NoError(t, kubelet.updateNodeStatus(ctx))

			actions := kubeClient.Actions()
			lastAction := actions[len(actions)-1]
			assert.IsType(t, core.PatchActionImpl{}, lastAction)
			patchAction := lastAction.(core.PatchActionImpl)

			updatedNode, err := applyNodeStatusPatch(oldNode, patchAction.GetPatch())
			require.NoError(t, err)

      }
      return %graph : tensor<i32>
    }
    ```
  }];

  let constructor = "tf_executor::CreateTFExecutorGraphPruningPass()";

  let options = [
   ListOption<"ops_to_preserve_", "ops-to-preserve", "std::string",
               "Comma separated list of ops that should not be pruned "
               "regardless of reachability">
  ];
}

- Implemented API for streaming for the `etcd` store implementation.

- Implemented API streaming for the `watch-cache`