code: def transpile(
      *objs: Callable,
      source: Optional[str] = None,
      to: Optional[str] = None,
      with_numpy: bool = True,
      backend_compile: bool = False,
      static_argnums: Optional[Union[int, Iterable[int]]] = None,
      static_argnames: Optional[Union[str, Iterable[str]]] = None,
      compile_mode: Optional[str] = None,
      graph_caching: bool = False,
      modes_to_trace: str = "all",
      stateful: Optional[List] = None,
      arg_stateful_idxs: Optional[List] = None,
      kwarg_stateful_idxs: Optional[List] = None,
      args: Optional[Sequence] = None,
      kwargs: Optional[Mapping] = None,
      params_v=None,
      v=None,
  ):
      """Transpiles Callable objects passed as arguments. If args and kwargs are
      specified, transpilation is performed eagerly, otherwise, transpilation
      will happen lazily.
  
      Parameters
      ----------
      objs
          The native Callables to be transpiled
      source
          The framework that `obj` is from.
      to
          The target framework to transpile `obj` to.
      args
          If specified, arguments that will be used to transpile eagerly.
      kwargs
          If specified, keyword arguments that will be used to transpile eagerly.
  
      Returns
      -------
      Either a transpiled Graph or a non-initialized LazyGraph.
      """
      from ._compiler import transpile as _transpile
  
      return _transpile(
          *objs,
          source=source,
          to=to,
          with_numpy=with_numpy,
          backend_compile=backend_compile,
          static_argnums=static_argnums,
          static_argnames=static_argnames,
          compile_mode=compile_mode,
          graph_caching=graph_caching,
          modes_to_trace=modes_to_trace,
          stateful=stateful,
          arg_stateful_idxs=arg_stateful_idxs,
          kwarg_stateful_idxs=kwarg_stateful_idxs,
          args=args,
          kwargs=kwargs,
          params_v=params_v,
          v=v,
      )
  
label_desc: Use image node_id 2 for calling a global function with example usage: transpile() and returns: _transpile