
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 .. import __version__
from . import DIFFUSERS_DYNAMIC_MODULE_NAME, HF_MODULES_CACHE, logging


lowercase__          =(
    'https://raw.githubusercontent.com/huggingface/diffusers/{revision}/examples/community/{pipeline}.py'
)


lowercase__          =logging.get_logger(__name__)  # pylint: disable=invalid-name




def        __UpperCamelCase					(    ):
 __a			:  Dict		    =  '''https://pypi.org/pypi/diffusers/json'''
 __a			:  Union[str, Any]		    =  json.loads(request.urlopen(lowerCAmelCase__  ).read()  )['''releases'''].keys()
 return sorted(lowerCAmelCase__  ,       key=lambda lowerCAmelCase__  : version.Version(lowerCAmelCase__  )  )




def        __UpperCamelCase					(    ):
 # This function has already been executed if HF_MODULES_CACHE already is in the Python path.
 if HF_MODULES_CACHE in sys.path:
  return

 sys.path.append(lowerCAmelCase__  )
 os.makedirs(lowerCAmelCase__  ,       exist_ok=lowerCAmelCase__  )
 __a			:  Optional[Any]		    =  Path(lowerCAmelCase__  ) / '''__init__.py'''
 if not init_path.exists():
  init_path.touch()




def        __UpperCamelCase					(    lowerCAmelCase__							:    Union[str, os.PathLike]  ):
 init_hf_modules()
 __a			:  str		    =  Path(lowerCAmelCase__  ) / name
 # If the parent module does not exist yet, recursively create it.
 if not dynamic_module_path.parent.exists():
  create_dynamic_module(dynamic_module_path.parent  )
 os.makedirs(lowerCAmelCase__  ,       exist_ok=lowerCAmelCase__  )
 __a			:  List[Any]		    =  dynamic_module_path / '''__init__.py'''
 if not init_path.exists():
  init_path.touch()




def        __UpperCamelCase					(    lowerCAmelCase__							:    List[Any]  ):
 with open(lowerCAmelCase__  ,       '''r'''  ,       encoding='''utf-8'''  ) as f:
  __a			:  Any		    =  f.read()

 # Imports of the form `import .xxx`
 __a			:  Any		    =  re.findall('''^\s*import\s+\.(\S+)\s*$'''  ,       lowerCAmelCase__  ,       flags=re.MULTILINE  )
 # Imports of the form `from .xxx import yyy`
 relative_imports += re.findall('''^\s*from\s+\.(\S+)\s+import'''  ,       lowerCAmelCase__  ,       flags=re.MULTILINE  )
 # Unique-ify
 return list(set(lowerCAmelCase__  )  )




def        __UpperCamelCase					(    lowerCAmelCase__							:    Dict  ):
 __a			:  List[str]		    =  False
 __a			:  str		    =  [module_file]
 __a			:  List[str]		    =  []

 # Let's recurse through all relative imports
 while not no_change:
  __a			:  Dict		    =  []
  for f in files_to_check:
   new_imports.extend(get_relative_imports(lowerCAmelCase__  )  )

  __a			:  str		    =  Path(lowerCAmelCase__  ).parent
  __a			:  Dict		    =  [str(module_path / m  ) for m in new_imports]
  __a			:  Optional[Any]		    =  [f for f in new_import_files if f not in all_relative_imports]
  __a			:  Dict		    =  [f"{f}.py" for f in new_import_files]

  __a			:  List[Any]		    =  len(lowerCAmelCase__  ) == 0
  all_relative_imports.extend(lowerCAmelCase__  )

 return all_relative_imports




def        __UpperCamelCase					(    lowerCAmelCase__							:    Dict  ):
 with open(lowerCAmelCase__  ,       '''r'''  ,       encoding='''utf-8'''  ) as f:
  __a			:  Union[str, Any]		    =  f.read()

 # Imports of the form `import xxx`
 __a			:  Optional[Any]		    =  re.findall('''^\s*import\s+(\S+)\s*$'''  ,       lowerCAmelCase__  ,       flags=re.MULTILINE  )
 # Imports of the form `from xxx import yyy`
 imports += re.findall('''^\s*from\s+(\S+)\s+import'''  ,       lowerCAmelCase__  ,       flags=re.MULTILINE  )
 # Only keep the top-level module
 __a			:  Optional[Any]		    =  [imp.split('''.'''  )[0] for imp in imports if not imp.startswith('''.'''  )]

 # Unique-ify and test we got them all
 __a			:  Union[str, Any]		    =  list(set(lowerCAmelCase__  )  )
 __a			:  List[str]		    =  []
 for imp in imports:
  try:
   importlib.import_module(lowerCAmelCase__  )
  except ImportError:
   missing_packages.append(lowerCAmelCase__  )

 if len(lowerCAmelCase__  ) > 0:
  raise ImportError(
      '''This modeling file requires the following packages that were not found in your environment: '''
      f"{', '.join(lowerCAmelCase__  )}. Run `pip install {' '.join(lowerCAmelCase__  )}`"  )

 return get_relative_imports(lowerCAmelCase__  )




def        __UpperCamelCase					(    lowerCAmelCase__							:    int  ,       lowerCAmelCase__							:    Dict  ):
 __a			:  List[str]		    =  module_path.replace(os.path.sep  ,       '''.'''  )
 __a			:  Optional[int]		    =  importlib.import_module(lowerCAmelCase__  )

 if class_name is None:
  return find_pipeline_class(lowerCAmelCase__  )
 return getattr(lowerCAmelCase__  ,       lowerCAmelCase__  )




def        __UpperCamelCase					(    lowerCAmelCase__							:    str  ):
 from ..pipelines import DiffusionPipeline

 __a			:  Tuple		    =  dict(inspect.getmembers(lowerCAmelCase__  ,       inspect.isclass  )  )

 __a			:  Optional[Any]		    =  None
 for cls_name, cls in cls_members.items():
  if (
      cls_name != DiffusionPipeline.__name__
      and issubclass(cls  ,       lowerCAmelCase__  )
      and cls.__module__.split('''.'''  )[0] != "diffusers"
  ):
   if pipeline_class is not None:
    raise ValueError(
        f"Multiple classes that inherit from {DiffusionPipeline.__name__} have been found:"
        f" {pipeline_class.__name__}, and {cls_name}. Please make sure to define only one in"
        f" {loaded_module}."  )
   __a			:  Any		    =  cls

 return pipeline_class




def        __UpperCamelCase					(    lowerCAmelCase__							:    Union[str, os.PathLike]  ,       lowerCAmelCase__							:    str  ,       lowerCAmelCase__							:    Optional[Union[str, os.PathLike]] = None  ,       lowerCAmelCase__							:    bool = False  ,       lowerCAmelCase__							:    bool = False  ,       lowerCAmelCase__							:    Optional[Dict[str, str]] = None  ,       lowerCAmelCase__							:    Optional[Union[bool, str]] = None  ,       lowerCAmelCase__							:    Optional[str] = None  ,       lowerCAmelCase__							:    bool = False  ,       ):
 __a			:  List[Any]		    =  str(lowerCAmelCase__  )

 __a			:  List[Any]		    =  os.path.join(lowerCAmelCase__  ,       lowerCAmelCase__  )

 if os.path.isfile(lowerCAmelCase__  ):
  __a			:  Dict		    =  module_file_or_url
  __a			:  List[Any]		    =  '''local'''
 elif pretrained_model_name_or_path.count('''/'''  ) == 0:
  __a			:  List[str]		    =  get_diffusers_versions()
  # cut ".dev0"
  __a			:  List[Any]		    =  '''v''' + '''.'''.join(__version__.split('''.'''  )[:3]  )

  # retrieve github version that matches
  if revision is None:
   __a			:  str		    =  latest_version if latest_version[1:] in available_versions else '''main'''
   logger.info(f"Defaulting to latest_version: {revision}."  )
  elif revision in available_versions:
   __a			:  Union[str, Any]		    =  f"v{revision}"
  elif revision == "main":
   __a			:  str		    =  revision
  else:
   raise ValueError(
       f"`custom_revision`: {revision} does not exist. Please make sure to choose one of"
       f" {', '.join(available_versions + ['main']  )}."  )

  # community pipeline on GitHub
  __a			:  Tuple		    =  COMMUNITY_PIPELINES_URL.format(revision=lowerCAmelCase__  ,       pipeline=lowerCAmelCase__  )
  try:
   __a			:  Union[str, Any]		    =  cached_download(
       lowerCAmelCase__  ,       cache_dir=lowerCAmelCase__  ,       force_download=lowerCAmelCase__  ,       proxies=lowerCAmelCase__  ,       resume_download=lowerCAmelCase__  ,       local_files_only=lowerCAmelCase__  ,       use_auth_token=lowerCAmelCase__  ,       )
   __a			:  List[str]		    =  '''git'''
   __a			:  Tuple		    =  pretrained_model_name_or_path + '''.py'''
  except EnvironmentError:
   logger.error(f"Could not locate the {module_file} inside {pretrained_model_name_or_path}."  )
   raise
 else:
  try:
   # Load from URL or cache if already cached
   __a			:  Any		    =  hf_hub_download(
       lowerCAmelCase__  ,       lowerCAmelCase__  ,       cache_dir=lowerCAmelCase__  ,       force_download=lowerCAmelCase__  ,       proxies=lowerCAmelCase__  ,       resume_download=lowerCAmelCase__  ,       local_files_only=lowerCAmelCase__  ,       use_auth_token=lowerCAmelCase__  ,       )
   __a			:  Any		    =  os.path.join('''local'''  ,       '''--'''.join(pretrained_model_name_or_path.split('''/'''  )  )  )
  except EnvironmentError:
   logger.error(f"Could not locate the {module_file} inside {pretrained_model_name_or_path}."  )
   raise

    # Check we have all the requirements in our environment
 __a			:  List[Any]		    =  check_imports(lowerCAmelCase__  )

 # Now we move the module inside our cached dynamic modules.
 __a			:  List[Any]		    =  DIFFUSERS_DYNAMIC_MODULE_NAME + os.path.sep + submodule
 create_dynamic_module(lowerCAmelCase__  )
 __a			:  List[Any]		    =  Path(lowerCAmelCase__  ) / full_submodule
 if submodule == "local" or submodule == "git":
  # We always copy local files (we could hash the file to see if there was a change, and give them the name of
  # that hash, to only copy when there is a modification but it seems overkill for now).
  # The only reason we do the copy is to avoid putting too many folders in sys.path.
  shutil.copy(lowerCAmelCase__  ,       submodule_path / module_file  )
  for module_needed in modules_needed:
   __a			:  Tuple		    =  f"{module_needed}.py"
   shutil.copy(os.path.join(lowerCAmelCase__  ,       lowerCAmelCase__  )  ,       submodule_path / module_needed  )
 else:
  # Get the commit hash
  # TODO: we will get this info in the etag soon, so retrieve it from there and not here.
  if isinstance(lowerCAmelCase__  ,       lowerCAmelCase__  ):
   __a			:  List[str]		    =  use_auth_token
  elif use_auth_token is True:
   __a			:  str		    =  HfFolder.get_token()
  else:
   __a			:  Any		    =  None

  __a			:  List[Any]		    =  model_info(lowerCAmelCase__  ,       revision=lowerCAmelCase__  ,       token=lowerCAmelCase__  ).sha

  # The module file will end up being placed in a subfolder with the git hash of the repo. This way we get the
  # benefit of versioning.
  __a			:  List[str]		    =  submodule_path / commit_hash
  __a			:  int		    =  full_submodule + os.path.sep + commit_hash
  create_dynamic_module(lowerCAmelCase__  )

  if not (submodule_path / module_file).exists():
   shutil.copy(lowerCAmelCase__  ,       submodule_path / module_file  )
  # Make sure we also have every file with relative
  for module_needed in modules_needed:
   if not (submodule_path / module_needed).exists():
    get_cached_module_file(
        lowerCAmelCase__  ,       f"{module_needed}.py"  ,       cache_dir=lowerCAmelCase__  ,       force_download=lowerCAmelCase__  ,       resume_download=lowerCAmelCase__  ,       proxies=lowerCAmelCase__  ,       use_auth_token=lowerCAmelCase__  ,       revision=lowerCAmelCase__  ,       local_files_only=lowerCAmelCase__  ,       )
 return os.path.join(lowerCAmelCase__  ,       lowerCAmelCase__  )




def        __UpperCamelCase					(    lowerCAmelCase__							:    Union[str, os.PathLike]  ,       lowerCAmelCase__							:    str  ,       lowerCAmelCase__							:    Optional[str] = None  ,       lowerCAmelCase__							:    Optional[Union[str, os.PathLike]] = None  ,       lowerCAmelCase__							:    bool = False  ,       lowerCAmelCase__							:    bool = False  ,       lowerCAmelCase__							:    Optional[Dict[str, str]] = None  ,       lowerCAmelCase__							:    Optional[Union[bool, str]] = None  ,       lowerCAmelCase__							:    Optional[str] = None  ,       lowerCAmelCase__							:    bool = False  ,       **lowerCAmelCase__							:    Optional[int]  ,       ):
 __a			:  Dict		    =  get_cached_module_file(
     lowerCAmelCase__  ,       lowerCAmelCase__  ,       cache_dir=lowerCAmelCase__  ,       force_download=lowerCAmelCase__  ,       resume_download=lowerCAmelCase__  ,       proxies=lowerCAmelCase__  ,       use_auth_token=lowerCAmelCase__  ,       revision=lowerCAmelCase__  ,       local_files_only=lowerCAmelCase__  ,       )
 return get_class_in_module(lowerCAmelCase__  ,       final_module.replace('''.py'''  ,       ''''''  )  )


from .glue import GlueDataset, GlueDataTrainingArguments
from .language_modeling import (
    LineByLineTextDataset,
    LineByLineWithRefDataset,
    LineByLineWithSOPTextDataset,
    TextDataset,
    TextDatasetForNextSentencePrediction,
)
from .squad import SquadDataset, SquadDataTrainingArguments
