programs that TensorFlow executes. TensorFlow programs are encoded as
computation
[**graphs**](https://developers.google.com/machine-learning/glossary/#graph).
Since models are practically programs that TensorFlow executes, using untrusted
models or graphs is equivalent to running untrusted code.

If you need to run untrusted models, execute them inside a

Guillaume Nodet <******@****.***> 1729859506 +0200

     */
    void setInitParameterMap(Map<String, Object> params);

    /**
     * Executes a request and returns the response data.
     *
     * @param data the request data to be executed
     * @return the response data from the executed request
     */
    ResponseData execute(RequestData data);

    /**
     * Closes the crawler client and releases any resources associated with it.

/**
 * This class executes a script.
 */
public class ScriptExecutor extends JobExecutor {

    /**
     * Constructor.
     */
    public ScriptExecutor() {
        super();
    }

    @Override
    public Object execute(final String scriptType, final String script) {
        final Map<String, Object> params = new HashMap<>();
        params.put("executor", this);

      object : Task(name) {
        override fun runOnce(): Long = block()
      },
      delayNanos,
    )
  }

  /**
   * Executes [block] once on a task runner thread.
   *
   * TODO: make this inline once this is fixed: https://github.com/oracle/graal/issues/3466
   */
  fun execute(
    name: String,
    delayNanos: Long = 0L,
    cancelable: Boolean = true,
    block: () -> Unit,
  ) {
    schedule(

package okhttp3.recipes;

import java.io.IOException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import okhttp3.Call;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class CancelCall {
  private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

/**
 * Abstract class representing a request that can be executed to produce a response.
 *
 * @param <T> the type of response produced by this request
 */
public abstract class Request<T extends Response> {
    /**
     * Constructs a new request.
     */
    public Request() {
        // nothing
    }

    /**
     * Executes the request.
     * @param client The OpenSearch client.

     * @param supplier The function to execute and cache the result
     * @return The result from the supplier (either fresh or cached)
     * @throws RuntimeException Any exception thrown by the supplier will be cached and re-thrown on subsequent calls
     */
    <REQ extends Request<?>, REP extends Result<REQ>> REP request(REQ req, Function<REQ, REP> supplier);

    /**

   * @param executor the executor in which the listeners callback methods will be run. For fast,
   *     lightweight listeners that would be safe to execute in any thread, consider {@link
   *     MoreExecutors#directExecutor}.
   * @since 13.0
   */
  void addListener(Listener listener, Executor executor);

  /**
   * The lifecycle states of a service.
   *

 *  * By completing.
 */
class TaskFaker : Closeable {
  val logger = Logger.getLogger("TaskFaker." + instance++)

  /** Though this executor service may hold many threads, they are not executed concurrently. */
  private val tasksExecutor = Executors.newCachedThreadPool(threadFactory("TaskFaker"))

  /**
   * True if this task faker has ever had multiple tasks scheduled to run concurrently. Guarded by
   * `this`.