code: def cached_file(
      path_or_repo_id: Union[str, os.PathLike],
      filename: str,
      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,
      subfolder: str = "",
      user_agent: Optional[Union[str, Dict[str, str]]] = None,
      _raise_exceptions_for_missing_entries: bool = True,
      _raise_exceptions_for_connection_errors: bool = True,
      _commit_hash: Optional[str] = None,
  ):
      """
      Tries to locate a file in a local folder and repo, downloads and cache it if necessary.
  
      Args:
          path_or_repo_id (`str` or `os.PathLike`):
              This can be either:
  
              - a string, the *model id* of a model repo on huggingface.co.
              - a path to a *directory* potentially containing the file.
          filename (`str`):
              The name of the file to locate in `path_or_repo`.
          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 `huggingface-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.
          subfolder (`str`, *optional*, defaults to `""`):
              In case the relevant files are located inside a subfolder of the model repo on huggingface.co, you can
              specify the folder name here.
  
      <Tip>
  
      Passing `use_auth_token=True` is required when you want to use a private model.
  
      </Tip>
  
      Returns:
          `Optional[str]`: Returns the resolved file (to the cache folder if downloaded from a repo).
  
      Examples:
  
      ```python
      # Download a model weight from the Hub and cache it.
      model_weights_file = cached_file("bert-base-uncased", "pytorch_model.bin")
      ```"""
      # Private arguments
      #     _raise_exceptions_for_missing_entries: if False, do not raise an exception for missing entries but return
      #         None.
      #     _raise_exceptions_for_connection_errors: if False, do not raise an exception for connection errors but return
      #         None.
      #     _commit_hash: passed when we are chaining several calls to various files (e.g. when loading a tokenizer or
      #         a pipeline). If files are cached for this commit hash, avoid calls to head and get from the cache.
      if is_offline_mode() and not local_files_only:
          logger.info("Offline mode: forcing local_files_only=True")
          local_files_only = True
      if subfolder is None:
          subfolder = ""
  
      path_or_repo_id = str(path_or_repo_id)
      full_filename = os.path.join(subfolder, filename)
      if os.path.isdir(path_or_repo_id):
          resolved_file = os.path.join(
              os.path.join(path_or_repo_id, subfolder), filename
          )
          if not os.path.isfile(resolved_file):
              if _raise_exceptions_for_missing_entries:
                  raise EnvironmentError(
                      f"{path_or_repo_id} does not appear to have a file named {full_filename}. Checkout "
                      f"'https://huggingface.co/{path_or_repo_id}/{revision}' for available files."
                  )
              else:
                  return None
          return resolved_file
  
      if cache_dir is None:
          cache_dir = TRANSFORMERS_CACHE
      if isinstance(cache_dir, Path):
          cache_dir = str(cache_dir)
  
      if _commit_hash is not None:
          # If the file is cached under that commit hash, we return it directly.
          resolved_file = try_to_load_from_cache(
              path_or_repo_id,
              full_filename,
              cache_dir=cache_dir,
              revision=_commit_hash,
          )
          if resolved_file is not None:
              if resolved_file is not _CACHED_NO_EXIST:
                  return resolved_file
              elif not _raise_exceptions_for_missing_entries:
                  return None
              else:
                  raise EnvironmentError(
                      f"Could not locate {full_filename} inside {path_or_repo_id}."
                  )
  
      user_agent = http_user_agent(user_agent)
      try:
          # Load from URL or cache if already cached
          resolved_file = hf_hub_download(
              path_or_repo_id,
              filename,
              subfolder=None if len(subfolder) == 0 else subfolder,
              revision=revision,
              cache_dir=cache_dir,
              user_agent=user_agent,
              force_download=force_download,
              proxies=proxies,
              resume_download=resume_download,
              use_auth_token=use_auth_token,
              local_files_only=local_files_only,
          )
  
      except RepositoryNotFoundError:
          raise EnvironmentError(
              f"{path_or_repo_id} is not a local folder and is not a valid model identifier "
              "listed on 'https://huggingface.co/models'\nIf this is a private repository, make sure to "
              "pass a token having permission to this repo with `use_auth_token` or log in with "
              "`huggingface-cli login` and pass `use_auth_token=True`."
          )
      except RevisionNotFoundError:
          raise EnvironmentError(
              f"{revision} is not a valid git identifier (branch name, tag name or commit id) that exists "
              "for this model name. Check the model page at "
              f"'https://huggingface.co/{path_or_repo_id}' for available revisions."
          )
      except LocalEntryNotFoundError:
          # We try to see if we have a cached version (not up to date):
          resolved_file = try_to_load_from_cache(
              path_or_repo_id,
              full_filename,
              cache_dir=cache_dir,
              revision=revision,
          )
          if (
              resolved_file is not None
              and resolved_file != _CACHED_NO_EXIST
          ):
              return resolved_file
          if (
              not _raise_exceptions_for_missing_entries
              or not _raise_exceptions_for_connection_errors
          ):
              return None
          raise EnvironmentError(
              f"We couldn't connect to '{HUGGINGFACE_CO_RESOLVE_ENDPOINT}' to load this file, couldn't find it in the"
              f" cached files and it looks like {path_or_repo_id} is not the path to a directory containing a file named"
              f" {full_filename}.\nCheckout your internet connection or see how to run the library in offline mode at"
              " 'https://huggingface.co/docs/transformers/installation#offline-mode'."
          )
      except EntryNotFoundError:
          if not _raise_exceptions_for_missing_entries:
              return None
          if revision is None:
              revision = "main"
          raise EnvironmentError(
              f"{path_or_repo_id} does not appear to have a file named {full_filename}. Checkout "
              f"'https://huggingface.co/{path_or_repo_id}/{revision}' for available files."
          )
      except HTTPError as err:
          # First we try to see if we have a cached version (not up to date):
          resolved_file = try_to_load_from_cache(
              path_or_repo_id,
              full_filename,
              cache_dir=cache_dir,
              revision=revision,
          )
          if (
              resolved_file is not None
              and resolved_file != _CACHED_NO_EXIST
          ):
              return resolved_file
          if not _raise_exceptions_for_connection_errors:
              return None
  
          raise EnvironmentError(
              f"There was a specific connection error when trying to load {path_or_repo_id}:\n{err}"
          )
  
      return resolved_file
  
imports: import json
  import os
  import re
  import shutil
  import sys
  import tempfile
  import traceback
  import warnings
  from pathlib import Path
  from typing import Dict, List, Optional, Tuple, Union
  from urllib.parse import urlparse
  from uuid import uuid4
  import huggingface_hub
  import requests
  from huggingface_hub import CommitOperationAdd, HfFolder, create_commit, create_repo, get_hf_file_metadata, hf_hub_download, hf_hub_url, whoami
  from huggingface_hub.file_download import REGEX_COMMIT_HASH, http_get
  from huggingface_hub.utils import EntryNotFoundError, LocalEntryNotFoundError, RepositoryNotFoundError, RevisionNotFoundError, hf_raise_for_status
  from requests.exceptions import HTTPError
  from transformers.utils.logging import tqdm
  from .None import __version__, logging
  from .generic import working_or_temp_dir
  from .import_utils import ENV_VARS_TRUE_VALUES, _tf_version, _torch_version, is_tf_available, is_torch_available, is_training_run_on_sagemaker
label_desc: Use image node_id 8 for calling a global function with example usage: cached_file(path_or_repo_id, filename, cache_dir, force_download, resume_download, proxies, use_auth_token, revision, local_files_only, subfolder, user_agent, _raise_exceptions_for_missing_entries, _raise_exceptions_for_connection_errors, _commit_hash) and returns: resolved_file, resolved_file, None, resolved_file, resolved_file, None, None, resolved_file, None, None