class_docstr: A ``Linker`` that JIT compiles a ``FunctionGraph`` into a single runnable thunk.
  
  The entirety of ``Linker.fgraph`` is converted into a single JIT compiled
  thunk that is run by an PyTensor ``VM``.
class_docstr_tok: ["A","``","Linker","``","that","JIT","compiles","a","``","FunctionGraph","``","into","a","single","runnable","thunk",".","The","entirety","of","``","Linker.fgraph","``","is","converted","into","a","single","JIT","compiled","thunk","that","is","run","by","an","PyTensor","``","VM","``","."]
docstr: Create a thunk for each output of the `Linker`\s `FunctionGraph`.
  
  This is differs from the other thunk-making function in that it only
  produces thunks for the `FunctionGraph` output nodes.
  
  Parameters
  ----------
  compute_map: dict
      The compute map dictionary.
  order
  input_storage
  output_storage
  storage_map: dict
      The storage map dictionary.
  
  Returns
  -------
  thunks: list
      A tuple containing the thunks.
  output_nodes: list and their
      A tuple containing the output nodes.
  jit_fn: callable
      The JITed function that performs the computations.
docstr_tok: ["Create","a","thunk","for","each","output","of","the","`","Linker","`","\\s","`","FunctionGraph","`",".","This","is","differs","from","the","other","thunk-making","function","in","that","it","only","produces","thunks","for","the","`","FunctionGraph","`","output","nodes",".","Parameters","--","--","--","--","--","compute_map",":","dict","The","compute","map","dictionary",".","order","input_storage","output_storage","storage_map",":","dict","The","storage","map","dictionary",".","Returns","--","--","--","-","thunks",":","list","A","tuple","containing","the","thunks",".","output_nodes",":","list","and","their","A","tuple","containing","the","output","nodes",".","jit_fn",":","callable","The","JITed","function","that","performs","the","computations","."]
code: def create_jitable_thunk(
      self,
      compute_map,
      order,
      input_storage,
      output_storage,
      storage_map,
  ):
      r"""Create a thunk for each output of the `Linker`\s `FunctionGraph`.
  
      This is differs from the other thunk-making function in that it only
      produces thunks for the `FunctionGraph` output nodes.
  
      Parameters
      ----------
      compute_map: dict
          The compute map dictionary.
      order
      input_storage
      output_storage
      storage_map: dict
          The storage map dictionary.
  
      Returns
      -------
      thunks: list
          A tuple containing the thunks.
      output_nodes: list and their
          A tuple containing the output nodes.
      jit_fn: callable
          The JITed function that performs the computations.
  
      """
      # This is a bit hackish, but we only return one of the output nodes
      output_nodes = [
          o.owner for o in self.fgraph.outputs if o.owner is not None
      ][:1]
  
      converted_fgraph = self.fgraph_convert(
          self.fgraph,
          order=order,
          input_storage=input_storage,
          output_storage=output_storage,
          storage_map=storage_map,
      )
  
      thunk_inputs = self.create_thunk_inputs(storage_map)
  
      thunks = []
  
      thunk_outputs = [storage_map[n] for n in self.fgraph.outputs]
  
      fgraph_jit = self.jit_compile(converted_fgraph)
  
      def thunk(
          fgraph=self.fgraph,
          fgraph_jit=fgraph_jit,
          thunk_inputs=thunk_inputs,
          thunk_outputs=thunk_outputs,
      ):
          outputs = fgraph_jit(*[x[0] for x in thunk_inputs])
  
          for o_var, o_storage, o_val in zip(
              fgraph.outputs, thunk_outputs, outputs
          ):
              compute_map[o_var][0] = True
              o_storage[0] = self.output_filter(o_var, o_val)
          return outputs
  
      thunk.inputs = thunk_inputs
      thunk.outputs = thunk_outputs
      thunk.lazy = False
  
      thunks.append(thunk)
  
      return thunks, output_nodes, fgraph_jit
  
imports: from abc import ABC, abstractmethod
  from collections.abc import Sequence
  from copy import copy, deepcopy
  from typing import TYPE_CHECKING, Any, Callable, Optional, Union
  from pytensor.configdefaults import config
  from pytensor.graph.basic import Apply, Variable
  from pytensor.graph.fg import FunctionGraph
  from pytensor.graph.type import Type
  from pytensor.link.utils import gc_helper, map_storage, raise_with_op, streamline
  from pytensor.utils import difference
label_desc: Use image node_id 5 for calling the JITLinker obj's underlying member method code with example usage: obj.create_jitable_thunk(compute_map, order, input_storage, output_storage, storage_map) and returns: thunks,  output_nodes,  fgraph_jit, outputs