code: def create_kwargs(cls: Type[T], params: Params, **extras) -> Dict[str, Any]:
      
      # Get the signature of the constructor.
      signature = inspect.signature(cls.__init__)
      kwargs: Dict[str, Any] = {}
  
      # Iterate over all the constructor parameters and their annotations.
      for name, param in signature.parameters.items():
          # Skip "self". You're not *required* to call the first parameter "self",
          # so in theory this logic is fragile, but if you don't call the self parameter
          # "self" you kind of deserve what happens.
          if name == "self":
              continue
  
          # If the annotation is a compound type like typing.Dict[str, int],
          # it will have an __origin__ field indicating `typing.Dict`
          # and an __args__ field indicating `(str, int)`. We capture both.
          annotation = remove_optional(param.annotation)
          kwargs[name] = construct_arg(cls, name, annotation, param.default, params, **extras)
  
      params.assert_empty(cls.__name__)
      return kwargs
docs: Given some class, a `Params` object, and potentially other keyword arguments,
      create a dict of keyword args suitable for passing to the class's constructor.
  
      The function does this by finding the class's constructor, matching the constructor
      arguments to entries in the `params` object, and instantiating values for the parameters
      using the type annotation and possibly a from_params method.
  
      Any values that are provided in the `extras` will just be used as is.
      For instance, you might provide an existing `Vocabulary` this way.