code: def batch_filter(
      x,
      P,
      zs,
      Fs,
      Qs,
      Hs,
      Rs,
      Bs=None,
      us=None,
      update_first=False,
      saver=None,
  ):
      """
      Batch processes a sequences of measurements.
  
      Parameters
      ----------
  
      zs : list-like
          list of measurements at each time step. Missing measurements must be
          represented by None.
  
      Fs : list-like
          list of values to use for the state transition matrix matrix.
  
      Qs : list-like
          list of values to use for the process error
          covariance.
  
      Hs : list-like
          list of values to use for the measurement matrix.
  
      Rs : list-like
          list of values to use for the measurement error
          covariance.
  
      Bs : list-like, optional
          list of values to use for the control transition matrix;
          a value of None in any position will cause the filter
          to use `self.B` for that time step.
  
      us : list-like, optional
          list of values to use for the control input vector;
          a value of None in any position will cause the filter to use
          0 for that time step.
  
      update_first : bool, optional
          controls whether the order of operations is update followed by
          predict, or predict followed by update. Default is predict->update.
  
          saver : filterpy.common.Saver, optional
              filterpy.common.Saver object. If provided, saver.save() will be
              called after every epoch
  
      Returns
      -------
  
      means : np.array((n,dim_x,1))
          array of the state for each time step after the update. Each entry
          is an np.array. In other words `means[k,:]` is the state at step
          `k`.
  
      covariance : np.array((n,dim_x,dim_x))
          array of the covariances for each time step after the update.
          In other words `covariance[k,:,:]` is the covariance at step `k`.
  
      means_predictions : np.array((n,dim_x,1))
          array of the state for each time step after the predictions. Each
          entry is an np.array. In other words `means[k,:]` is the state at
          step `k`.
  
      covariance_predictions : np.array((n,dim_x,dim_x))
          array of the covariances for each time step after the prediction.
          In other words `covariance[k,:,:]` is the covariance at step `k`.
  
      Examples
      --------
  
      .. code-block:: Python
  
          zs = [t + random.randn()*4 for t in range (40)]
          Fs = [kf.F for t in range (40)]
          Hs = [kf.H for t in range (40)]
  
          (mu, cov, _, _) = kf.batch_filter(zs, Rs=R_list, Fs=Fs, Hs=Hs, Qs=None,
                                            Bs=None, us=None, update_first=False)
          (xs, Ps, Ks, Pps) = kf.rts_smoother(mu, cov, Fs=Fs, Qs=None)
  
      """
  
      n = np.size(zs, 0)
      dim_x = x.shape[0]
  
      # mean estimates from Kalman Filter
      if x.ndim == 1:
          means = zeros((n, dim_x))
          means_p = zeros((n, dim_x))
      else:
          means = zeros((n, dim_x, 1))
          means_p = zeros((n, dim_x, 1))
  
      # state covariances from Kalman Filter
      covariances = zeros((n, dim_x, dim_x))
      covariances_p = zeros((n, dim_x, dim_x))
  
      if us is None:
          us = [0.0] * n
          Bs = [0.0] * n
  
      if update_first:
          for i, (z, F, Q, H, R, B, u) in enumerate(
              zip(zs, Fs, Qs, Hs, Rs, Bs, us)
          ):
              x, P = update(x, P, z, R=R, H=H)
              means[i, :] = x
              covariances[i, :, :] = P
  
              x, P = predict(x, P, u=u, B=B, F=F, Q=Q)
              means_p[i, :] = x
              covariances_p[i, :, :] = P
              if saver is not None:
                  saver.save()
      else:
          for i, (z, F, Q, H, R, B, u) in enumerate(
              zip(zs, Fs, Qs, Hs, Rs, Bs, us)
          ):
              x, P = predict(x, P, u=u, B=B, F=F, Q=Q)
              means_p[i, :] = x
              covariances_p[i, :, :] = P
  
              x, P = update(x, P, z, R=R, H=H)
              means[i, :] = x
              covariances[i, :, :] = P
              if saver is not None:
                  saver.save()
  
      return (means, covariances, means_p, covariances_p)
  
imports: from __future__ import absolute_import, division
  from copy import deepcopy
  from math import log, exp, sqrt
  import sys
  import numpy
  from numpy import dot, zeros, eye, isscalar, shape
  import numpy.linalg
  from filterpy.stats import logpdf
  from filterpy.common import pretty_str, reshape_z
label_desc: Use image node_id 5 for calling a global function with example usage: batch_filter(x, P, zs, Fs, Qs, Hs, Rs, Bs, us, update_first, saver) and returns: means,  covariances,  means_p,  covariances_p