code: def get_from_cache(url, cache_dir=None):
      """
      Given a URL, look for the corresponding dataset in the local cache.
      If it's not there, download it. Then return the path to the cached file.
      """
      if cache_dir is None:
          cache_dir = PYTORCH_FAIRSEQ_CACHE
      if isinstance(cache_dir, Path):
          cache_dir = str(cache_dir)
  
      if not os.path.exists(cache_dir):
          os.makedirs(cache_dir)
  
      # Get eTag to add to filename, if it exists.
      if url.startswith("s3://"):
          etag = s3_etag(url)
      else:
          try:
              import requests
  
              response = request_wrap_timeout(
                  partial(requests.head, url, allow_redirects=True), url
              )
              if response.status_code != 200:
                  etag = None
              else:
                  etag = response.headers.get("ETag")
          except RuntimeError:
              etag = None
  
      filename = url_to_filename(url, etag)
  
      # get cache path to put the file
      cache_path = os.path.join(cache_dir, filename)
  
      # If we don't have a connection (etag is None) and can't identify the file
      # try to get the last downloaded one
      if not os.path.exists(cache_path) and etag is None:
          matching_files = fnmatch.filter(
              os.listdir(cache_dir), filename + ".*"
          )
          matching_files = list(
              filter(lambda s: not s.endswith(".json"), matching_files)
          )
          if matching_files:
              cache_path = os.path.join(cache_dir, matching_files[-1])
  
      if not os.path.exists(cache_path):
          # Download to temporary file, then copy to cache dir once finished.
          # Otherwise you get corrupt cache entries if the download gets interrupted.
          with tempfile.NamedTemporaryFile() as temp_file:
              logger.info(
                  "%s not found in cache, downloading to %s",
                  url,
                  temp_file.name,
              )
  
              # GET file object
              if url.startswith("s3://"):
                  s3_get(url, temp_file)
              else:
                  http_get(url, temp_file)
  
              # we are copying the file before closing it, so flush to avoid truncation
              temp_file.flush()
              # shutil.copyfileobj() starts at the current position, so go to the start
              temp_file.seek(0)
  
              logger.info(
                  "copying %s to cache at %s",
                  temp_file.name,
                  cache_path,
              )
              with open(cache_path, "wb") as cache_file:
                  shutil.copyfileobj(temp_file, cache_file)
  
              logger.info("creating metadata file for %s", cache_path)
              meta = {"url": url, "etag": etag}
              meta_path = cache_path + ".json"
              with open(meta_path, "w") as meta_file:
                  output_string = json.dumps(meta)
                  meta_file.write(output_string)
  
              logger.info("removing temp file %s", temp_file.name)
  
      return cache_path
  
imports: import fnmatch
  import json
  import logging
  import os
  import shutil
  import tarfile
  import tempfile
  from functools import partial, wraps
  from hashlib import sha256
  from io import open
label_desc: Use image node_id 12 for calling a global function with example usage: get_from_cache(url, cache_dir) and returns: cache_path