code: def pop_and_construct_arg(
      class_name: str,
      argument_name: str,
      annotation: Type,
      default: Any,
      params: Params,
      **extras,
  ) -> Any:
      """
      Does the work of actually constructing an individual argument for
      [`create_kwargs`](./#create_kwargs).
  
      Here we're in the inner loop of iterating over the parameters to a particular constructor,
      trying to construct just one of them.  The information we get for that parameter is its name,
      its type annotation, and its default value; we also get the full set of `Params` for
      constructing the object (which we may mutate), and any `extras` that the constructor might
      need.
  
      We take the type annotation and default value here separately, instead of using an
      `inspect.Parameter` object directly, so that we can handle `Union` types using recursion on
      this method, trying the different annotation types in the union in turn.
      """
      from allennlp.models.archival import (
          load_archive,
      )  # import here to avoid circular imports
  
      # We used `argument_name` as the method argument to avoid conflicts with 'name' being a key in
      # `extras`, which isn't _that_ unlikely.  Now that we are inside the method, we can switch back
      # to using `name`.
      name = argument_name
  
      # Some constructors expect extra non-parameter items, e.g. vocab: Vocabulary.
      # We check the provided `extras` for these and just use them if they exist.
      if name in extras:
          if name not in params:
              return extras[name]
          else:
              logger.warning(
                  f"Parameter {name} for class {class_name} was found in both "
                  "**extras and in params. Using the specification found in params, "
                  "but you probably put a key in a config file that you didn't need, "
                  "and if it is different from what we get from **extras, you might "
                  "get unexpected behavior."
              )
      # Next case is when argument should be loaded from pretrained archive.
      elif (
          name in params
          and isinstance(params.get(name), Params)
          and "_pretrained" in params.get(name)
      ):
          load_module_params = params.pop(name).pop("_pretrained")
          archive_file = load_module_params.pop("archive_file")
          module_path = load_module_params.pop("module_path")
          freeze = load_module_params.pop("freeze", True)
          archive = load_archive(archive_file)
          result = archive.extract_module(module_path, freeze)
          if not isinstance(result, annotation):
              raise ConfigurationError(
                  f"The module from model at {archive_file} at path {module_path} "
                  f"was expected of type {annotation} but is of type {type(result)}"
              )
          return result
  
      popped_params = (
          params.pop(name, default)
          if default != _NO_DEFAULT
          else params.pop(name)
      )
      if popped_params is None:
          return None
  
      return construct_arg(
          class_name, name, popped_params, annotation, default, **extras
      )
  
imports: import collections.abc
  from copy import deepcopy
  from pathlib import Path
  from typing import Any, Callable, cast, Dict, Iterable, List, Mapping, Set, Tuple, Type, TypeVar, Union, Optional
  import inspect
  import logging
  from allennlp.common.checks import ConfigurationError
  from allennlp.common.lazy import Lazy
  from allennlp.common.params import Params
label_desc: Use image node_id 10 for calling a global function with example usage: pop_and_construct_arg(class_name, argument_name, annotation, default, params) and returns: construct_arg, None, extras, result