class_docstr: Base class for all configuration classes. All configuration parameters are stored under `self.config`. Also
  provides the [`~ConfigMixin.from_config`] and [`~ConfigMixin.save_config`] methods for loading, downloading, and
  saving classes that inherit from [`ConfigMixin`].
  
  Class attributes:
      - **config_name** (`str`) -- A filename under which the config should stored when calling
        [`~ConfigMixin.save_config`] (should be overridden by parent class).
      - **ignore_for_config** (`List[str]`) -- A list of attributes that should not be saved in the config (should be
        overridden by subclass).
      - **has_compatibles** (`bool`) -- Whether the class has compatible classes (should be overridden by subclass).
      - **_deprecated_kwargs** (`List[str]`) -- Keyword arguments that are deprecated. Note that the `init` function
        should only have a `kwargs` argument if at least one argument is deprecated (should be overridden by
        subclass).
code: def extract_init_dict(cls, config_dict, **kwargs):
      # Skip keys that were not present in the original config, so default __init__ values were used
      used_defaults = config_dict.get("_use_default_values", [])
      config_dict = {
          k: v
          for k, v in config_dict.items()
          if k not in used_defaults and k != "_use_default_values"
      }
  
      # 0. Copy origin config dict
      original_dict = dict(config_dict.items())
  
      # 1. Retrieve expected config attributes from __init__ signature
      expected_keys = cls._get_init_keys(cls)
      expected_keys.remove("self")
      # remove general kwargs if present in dict
      if "kwargs" in expected_keys:
          expected_keys.remove("kwargs")
      # remove flax internal keys
      if hasattr(cls, "_flax_internal_args"):
          for arg in cls._flax_internal_args:
              expected_keys.remove(arg)
  
      # 2. Remove attributes that cannot be expected from expected config attributes
      # remove keys to be ignored
      if len(cls.ignore_for_config) > 0:
          expected_keys = expected_keys - set(cls.ignore_for_config)
  
      # load diffusers library to import compatible and original scheduler
      diffusers_library = importlib.import_module(
          __name__.split(".")[0]
      )
  
      if cls.has_compatibles:
          compatible_classes = [
              c
              for c in cls._get_compatibles()
              if not isinstance(c, DummyObject)
          ]
      else:
          compatible_classes = []
  
      expected_keys_comp_cls = set()
      for c in compatible_classes:
          expected_keys_c = cls._get_init_keys(c)
          expected_keys_comp_cls = expected_keys_comp_cls.union(
              expected_keys_c
          )
      expected_keys_comp_cls = (
          expected_keys_comp_cls - cls._get_init_keys(cls)
      )
      config_dict = {
          k: v
          for k, v in config_dict.items()
          if k not in expected_keys_comp_cls
      }
  
      # remove attributes from orig class that cannot be expected
      orig_cls_name = config_dict.pop("_class_name", cls.__name__)
      if orig_cls_name != cls.__name__ and hasattr(
          diffusers_library, orig_cls_name
      ):
          orig_cls = getattr(diffusers_library, orig_cls_name)
          unexpected_keys_from_orig = (
              cls._get_init_keys(orig_cls) - expected_keys
          )
          config_dict = {
              k: v
              for k, v in config_dict.items()
              if k not in unexpected_keys_from_orig
          }
  
      # remove private attributes
      config_dict = {
          k: v for k, v in config_dict.items() if not k.startswith("_")
      }
  
      # 3. Create keyword arguments that will be passed to __init__ from expected keyword arguments
      init_dict = {}
      for key in expected_keys:
          # if config param is passed to kwarg and is present in config dict
          # it should overwrite existing config dict key
          if key in kwargs and key in config_dict:
              config_dict[key] = kwargs.pop(key)
  
          if key in kwargs:
              # overwrite key
              init_dict[key] = kwargs.pop(key)
          elif key in config_dict:
              # use value from config dict
              init_dict[key] = config_dict.pop(key)
  
      # 4. Give nice warning if unexpected values have been passed
      if len(config_dict) > 0:
          logger.warning(
              f"The config attributes {config_dict} were passed to {cls.__name__}, "
              "but are not expected and will be ignored. Please verify your "
              f"{cls.config_name} configuration file."
          )
  
      # 5. Give nice info if config attributes are initiliazed to default because they have not been passed
      passed_keys = set(init_dict.keys())
      if len(expected_keys - passed_keys) > 0:
          logger.info(
              f"{expected_keys - passed_keys} was not found in config. Values will be initialized to default values."
          )
  
      # 6. Define unused keyword arguments
      unused_kwargs = {**config_dict, **kwargs}
  
      # 7. Define "hidden" config parameters that were saved for compatible classes
      hidden_config_dict = {
          k: v for k, v in original_dict.items() if k not in init_dict
      }
  
      return init_dict, unused_kwargs, hidden_config_dict
  
imports: import dataclasses
  import functools
  import importlib
  import inspect
  import json
  import os
  import re
  from collections import OrderedDict
  from pathlib import PosixPath
  from typing import Any, Dict, Tuple, Union
  import numpy
  from huggingface_hub import create_repo, hf_hub_download
  from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError, RevisionNotFoundError
  from requests import HTTPError
  from .None import __version__
  from .utils import DIFFUSERS_CACHE, HUGGINGFACE_CO_RESOLVE_ENDPOINT, DummyObject, deprecate, extract_commit_hash, http_user_agent, logging
label_desc: Use image node_id 8 for calling the ConfigMixin obj's underlying member method code with example usage: obj.extract_init_dict(cls, config_dict) and returns: init_dict,  unused_kwargs,  hidden_config_dict