class_docstr: Metaclass used to ensure that the function signatures for model `Config` initializers contain all
  relevant parameters, including those specified in the superclass. Also update docstrings accordingly.
  
  For example, the only parameter of the base class `Config` is ``transform``. `ForecasterConfig` adds the
  parameters ``max_forecast_steps`` and ``target_seq_index``. Because `Config` inherits from this metaclass,
  we can declare
  
  .. code::
  
      class ForecasterConfig(Config):
  
      def __init__(self, max_forecast_steps: int = None, target_seq_index: int = None, **kwargs):
          ...
  
  and have the function signature for `ForecasterConfig`'s initializer include the parameter ``transform``,
  even though we never declared it explicitly. Additionally, the docstring for ``transform`` is inherited
  from the base class.
code: def __new__(mcs, classname, bases, cls_dict):
      sig = None
      cls = super().__new__(mcs, classname, bases, cls_dict)
      prefix, suffix, params = None, None, OrderedDict()
      for cls_ in cls.__mro__:
          if isinstance(cls_, ModelConfigMeta):
              # Combine the __init__ signatures
              sig = combine_signatures(
                  sig, inspect.signature(cls_.__init__)
              )
  
              # Parse the __init__ docstring. Use the earliest prefix/param docstring in the MRO.
              prefix_, suffix_, params_ = parse_basic_docstring(
                  cls_.__init__.__doc__
              )
              if prefix is None and any(
                  [line != "" for line in prefix_]
              ):
                  prefix = "\n".join(prefix_)
              if suffix is None and any(
                  [line != "" for line in suffix_]
              ):
                  suffix = "\n".join(suffix_)
              for param, docstring_lines in params_.items():
                  if param not in params:
                      params[param] = "\n".join(docstring_lines).rstrip(
                          "\n"
                      )
  
      # Update the signature and docstring of __init__
      cls.__init__.__signature__ = sig
      params = OrderedDict(
          (p, params[p]) for p in sig.parameters if p in params
      )
      cls.__init__.__doc__ = (
          (prefix or "")
          + "\n"
          + "\n".join(params.values())
          + "\n\n"
          + (suffix or "")
      )
      return cls
  
imports: from abc import ABCMeta
  from collections import OrderedDict
  from copy import deepcopy
  from functools import wraps
  import importlib
  import inspect
  import re
  from typing import Callable, Union
label_desc: Use image node_id 1 for calling the ModelConfigMeta obj's underlying member method code with example usage: obj.__new__(mcs, classname, bases, cls_dict) and returns: cls