code: def make_runmeta_and_point_fn(
      *,
      initial_point: Mapping[str, np.ndarray],
      step: Union[CompoundStep, BlockedStep],
      model: Model,
  ) -> Tuple[mcb.RunMeta, PointFunc]:
      variables, point_fn = get_variables_and_point_fn(
          model, initial_point
      )
  
      check_step_emits_tune(step)
  
      # In PyMC the sampler stats are grouped by the sampler.
      sample_stats = []
      steps = flatten_steps(step)
      for s, sm in enumerate(steps):
          for statname, (
              dtype,
              shape,
          ) in sm.stats_dtypes_shapes.items():
              sname = flat_statname(s, statname)
              sshape = [
                  # PyMC uses None to indicate dynamic dims, MCB uses -1
                  (-1 if s is None else s)
                  for s in (shape or [])
              ]
              dt = np.dtype(dtype).name
              # Object types will be pickled by the ChainRecordAdapter!
              if dt == "object":
                  dt = "str"
              svar = mcb.Variable(
                  name=sname,
                  dtype=dt,
                  shape=sshape,
                  undefined_ndim=shape is None,
              )
              sample_stats.append(svar)
  
      coordinates = [
          mcb.Coordinate(
              dname,
              mcb.npproto.utils.ndarray_from_numpy(np.array(cvals)),
          )
          for dname, cvals in model.coords.items()
          if cvals is not None
      ]
      meta = mcb.RunMeta(
          rid=hagelkorn.random(),
          variables=variables,
          coordinates=coordinates,
          sample_stats=sample_stats,
          data=find_data(model),
      )
      return meta, point_fn
  
imports: import base64
  import logging
  import pickle
  from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple, Union, cast
  import hagelkorn
  import mcbackend
  import numpy
  from mcbackend.npproto.utils import ndarray_from_numpy
  from pytensor.compile.sharedvalue import SharedVariable
  from pytensor.graph.basic import Constant
  from pymc.backends.base import IBaseTrace
  from pymc.model import Model
  from pymc.pytensorf import PointFunc
  from pymc.step_methods.compound import BlockedStep, CompoundStep, StatsBijection, check_step_emits_tune, flat_statname, flatten_steps
label_desc: Use image node_id 3 for calling a global function with example usage: make_runmeta_and_point_fn() and returns: meta,  point_fn