code: def _partial_fit(
      model_and_meta: Tuple[Model, Meta],
      X: ArrayLike,
      y: ArrayLike,
      fit_params: Dict[str, Any],
  ) -> Tuple[Model, Meta]:
      """
      Call partial_fit on a classifiers with training data X and y
  
      Arguments
      ---------
      model_and_meta : Tuple[Estimator, dict]
      X, y : np.ndarray, np.ndarray
          Training data
      fit_params : dict
          Extra keyword arguments to pass to partial_fit
  
      Returns
      -------
      Results
          A namedtuple with four fields: info, models, history, best
  
          * info : Dict[model_id, List[Dict]]
              Keys are integers identifying each model. Values are a
              List of Dict
          * models : Dict[model_id, Future[Estimator]]
              A dictionary with the same keys as `info`. The values
              are futures to the fitted models.
          * history : List[Dict]
              The history of model fitting for each model. Each element
              of the list is a dictionary with the following elements:
  
              * model_id : int
                  A superset of the keys for `info` and `models`.
              * params : Dict[str, Any]
                  Parameters this model was trained with.
              * partial_fit_calls : int
                  The number of *consecutive* partial fit calls at this stage in
                  this models training history.
              * partial_fit_time : float
                  Time (in seconds) spent on this partial fit
              * score : float
                  Score on the test set for the model at this point in history
              * score_time : float
                  Time (in seconds) spent on this scoring.
          * best : Tuple[model_id, Future[Estimator]]]
              The estimator with the highest validation score in the final
              round.
      """
      with log_errors():
          start = time()
          model, meta = model_and_meta
  
          if len(X):
              model = deepcopy(model)
              model.partial_fit(X, y, **(fit_params or {}))
  
          meta = dict(meta)
          meta["partial_fit_calls"] += 1
          meta["partial_fit_time"] = time() - start
  
          return model, meta
  
imports: from __future__ import division
  import itertools
  import logging
  import operator
  import sys
  from collections import defaultdict, namedtuple
  from copy import deepcopy
  from time import time
  from typing import Any, Callable, Dict, List, Optional, Tuple, Union
  from warnings import warn
  import dask
  import dask.array
  import dask.dataframe
  import numpy
  import scipy.stats
  import toolz
  from dask.distributed import Future, default_client, futures_of, wait
  from distributed.utils import log_errors
  from sklearn.base import BaseEstimator, clone
  from sklearn.linear_model import SGDClassifier
  from sklearn.metrics import check_scoring
  from sklearn.model_selection import ParameterGrid, ParameterSampler
  from sklearn.utils import check_random_state
  from sklearn.utils.metaestimators import available_if
  from sklearn.utils.validation import check_is_fitted
  from .._compat import DISTRIBUTED_2021_02_0, annotate, dummy_context
  from .._typing import ArrayLike, Int
  from .._utils import LoggingContext
  from ..wrappers import ParallelPostFit
  from ._split import train_test_split
  from .utils import estimator_has
label_desc: Use image node_id 1 for calling a global function with example usage: _partial_fit(model_and_meta, X, y, fit_params) and returns: model,  meta