code: def get_class_from_dynamic_module(
      pretrained_model_name_or_path: Union[str, os.PathLike],
      module_file: str,
      class_name: Optional[str] = None,
      cache_dir: Optional[Union[str, os.PathLike]] = None,
      force_download: bool = False,
      resume_download: bool = False,
      proxies: Optional[Dict[str, str]] = None,
      use_auth_token: Optional[Union[bool, str]] = None,
      revision: Optional[str] = None,
      local_files_only: bool = False,
      **kwargs,
  ):
      """
      Extracts a class from a module file, present in the local folder or repository of a model.
  
      <Tip warning={true}>
  
      Calling this function will execute the code in the module file found locally or downloaded from the Hub. It should
      therefore only be called on trusted repos.
  
      </Tip>
  
      Args:
          pretrained_model_name_or_path (`str` or `os.PathLike`):
              This can be either:
  
              - a string, the *model id* of a pretrained model configuration hosted inside a model repo on
                huggingface.co. Valid model ids can be located at the root-level, like `bert-base-uncased`, or namespaced
                under a user or organization name, like `dbmdz/bert-base-german-cased`.
              - a path to a *directory* containing a configuration file saved using the
                [`~PreTrainedTokenizer.save_pretrained`] method, e.g., `./my_model_directory/`.
  
          module_file (`str`):
              The name of the module file containing the class to look for.
          class_name (`str`):
              The name of the class to import in the module.
          cache_dir (`str` or `os.PathLike`, *optional*):
              Path to a directory in which a downloaded pretrained model configuration should be cached if the standard
              cache should not be used.
          force_download (`bool`, *optional*, defaults to `False`):
              Whether or not to force to (re-)download the configuration files and override the cached versions if they
              exist.
          resume_download (`bool`, *optional*, defaults to `False`):
              Whether or not to delete incompletely received file. Attempts to resume the download if such a file exists.
          proxies (`Dict[str, str]`, *optional*):
              A dictionary of proxy servers to use by protocol or endpoint, e.g., `{'http': 'foo.bar:3128',
              'http://hostname': 'foo.bar:4012'}.` The proxies are used on each request.
          use_auth_token (`str` or `bool`, *optional*):
              The token to use as HTTP bearer authorization for remote files. If `True`, will use the token generated
              when running `transformers-cli login` (stored in `~/.huggingface`).
          revision (`str`, *optional*, defaults to `"main"`):
              The specific model version to use. It can be a branch name, a tag name, or a commit id, since we use a
              git-based system for storing models and other artifacts on huggingface.co, so `revision` can be any
              identifier allowed by git.
          local_files_only (`bool`, *optional*, defaults to `False`):
              If `True`, will only try to load the tokenizer configuration from local files.
  
      <Tip>
  
      You may pass a token in `use_auth_token` if you are not logged in (`huggingface-cli long`) and want to use private
      or [gated models](https://huggingface.co/docs/hub/models-gated#gated-models).
  
      </Tip>
  
      Returns:
          `type`: The class, dynamically imported from the module.
  
      Examples:
  
      ```python
      # Download module `modeling.py` from huggingface.co and cache then extract the class `MyBertModel` from this
      # module.
      cls = get_class_from_dynamic_module("sgugger/my-bert-model", "modeling.py", "MyBertModel")
      ```"""
      # And lastly we get the class inside our newly created module
      final_module = get_cached_module_file(
          pretrained_model_name_or_path,
          module_file,
          cache_dir=cache_dir,
          force_download=force_download,
          resume_download=resume_download,
          proxies=proxies,
          use_auth_token=use_auth_token,
          revision=revision,
          local_files_only=local_files_only,
      )
      return get_class_in_module(
          class_name, final_module.replace(".py", "")
      )
  
imports: import importlib
  import inspect
  import json
  import os
  import re
  import shutil
  import sys
  from pathlib import Path
  from typing import Dict, Optional, Union
  from urllib import request
  from huggingface_hub import HfFolder, cached_download, hf_hub_download, model_info
  from packaging import version
  from ..None import __version__
  from .None import DIFFUSERS_DYNAMIC_MODULE_NAME, HF_MODULES_CACHE, logging
label_desc: Use image node_id 10 for calling a global function with example usage: get_class_from_dynamic_module(pretrained_model_name_or_path, module_file, class_name, cache_dir, force_download, resume_download, proxies, use_auth_token, revision, local_files_only) and returns: get_class_in_module