code: def modelzoo_path(datapath, path):
      """
      Map pretrain models filenames to their path on disk.
  
      If path starts with 'models:', then we remap it to the model zoo path within the
      data directory (default is ParlAI/data/models). We download models from the model
      zoo if they are not here yet.
      """
      if path is None:
          return None
      if (
          not path.startswith("models:")
          and not path.startswith("zoo:")
          and not path.startswith("izoo:")
      ):
          return path
      elif path.startswith("models:") or path.startswith("zoo:"):
          zoo = path.split(":")[0]
          zoo_len = len(zoo) + 1
          model_path = path[zoo_len:]
          # Check if we need to download the model
          if "/" in path:
              animal = path[zoo_len : path.rfind("/")].replace("/", ".")
          else:
              animal = path[zoo_len:]
          if "." not in animal:
              animal += ".build"
          module_name = "parlai.zoo.{}".format(animal)
          try:
              my_module = importlib.import_module(module_name)
              my_module.download(datapath)
          except (ImportError, AttributeError):
              try:
                  # maybe we didn't find a specific model, let's try generic .build
                  animal_ = ".".join(animal.split(".")[:-1]) + ".build"
                  module_name_ = "parlai.zoo.{}".format(animal_)
                  my_module = importlib.import_module(module_name_)
                  my_module.download(datapath)
              except (ImportError, AttributeError) as exc:
                  # truly give up
                  raise ImportError(
                      f"Could not find pretrained model in {module_name} or {module_name_}."
                      " Please check your spelling and make sure you've pulled from master."
                  ) from exc
  
          return os.path.join(datapath, "models", model_path)
      else:
          # Internal path (starts with "izoo:") -- useful for non-public
          # projects.  Save the path to your internal model zoo in
          # parlai_internal/.internal_zoo_path
          # TODO: test the internal zoo.
          zoo_path = "parlai_internal/zoo/.internal_zoo_path"
          if not PathManager.exists(
              "parlai_internal/zoo/.internal_zoo_path"
          ):
              raise RuntimeError(
                  "Please specify the path to your internal zoo in the "
                  "file parlai_internal/zoo/.internal_zoo_path in your "
                  "internal repository."
              )
          else:
              with PathManager.open(zoo_path, "r") as f:
                  zoo = f.read().split("\n")[0]
              return os.path.join(zoo, path[5:])
  
imports: import importlib
  import json
  import time
  import datetime
  import os
  import requests
  import shutil
  import hashlib
  import tqdm
  import gzip
  import math
  import contextlib
  import parlai.utils.logging
  from parlai.utils.io import PathManager
label_desc: Use image node_id 14 for calling a global function with example usage: modelzoo_path(datapath, path) and returns: None, path, os, os