



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


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


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





def     _UpperCamelCase     ():






							"""simple docstring"""





							UpperCamelCase__				     =			"https://pypi.org/pypi/diffusers/json"
							UpperCamelCase__				     =			json.loads(request.urlopen(_lowerCamelCase       ).read()       )["releases"].keys()
							return sorted(_lowerCamelCase   ,			key=lambda a__       : version.Version(_lowerCamelCase       )       )





def     _UpperCamelCase     ():






							"""simple docstring"""





							if HF_MODULES_CACHE in sys.path:
														return

							sys.path.append(_lowerCamelCase       )
							os.makedirs(_lowerCamelCase   ,			exist_ok=_lowerCamelCase       )
							UpperCamelCase__				     =			Path(_lowerCamelCase       ) / "__init__.py"
							if not init_path.exists():
														init_path.touch()





def     _UpperCamelCase     (a__   :Dict       ):






							"""simple docstring"""





							init_hf_modules()
							UpperCamelCase__				     =			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       )
							UpperCamelCase__				     =			dynamic_module_path / "__init__.py"
							if not init_path.exists():
														init_path.touch()





def     _UpperCamelCase     (a__   :int       ):






							"""simple docstring"""





							with open(_lowerCamelCase   ,			"""r"""   ,			encoding="""utf-8"""       ) as f:
														UpperCamelCase__				     =			f.read()

							# Imports of the form `import .xxx`
							UpperCamelCase__				     =			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     (a__   :str       ):






							"""simple docstring"""





							UpperCamelCase__				     =			False
							UpperCamelCase__				     =			[module_file]
							UpperCamelCase__				     =			[]

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

														UpperCamelCase__				     =			Path(_lowerCamelCase       ).parent
														UpperCamelCase__				     =			[str(module_path / m       ) for m in new_imports]
														UpperCamelCase__				     =			[f for f in new_import_files if f not in all_relative_imports]
														UpperCamelCase__				     =			[f"""{f}.py""" for f in new_import_files]

														UpperCamelCase__				     =			len(_lowerCamelCase       ) == 0
														all_relative_imports.extend(_lowerCamelCase       )

							return all_relative_imports





def     _UpperCamelCase     (a__   :Optional[int]       ):






							"""simple docstring"""





							with open(_lowerCamelCase   ,			"""r"""   ,			encoding="""utf-8"""       ) as f:
														UpperCamelCase__				     =			f.read()

							# Imports of the form `import xxx`
							UpperCamelCase__				     =			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
							UpperCamelCase__				     =			[imp.split("""."""       )[0] for imp in imports if not imp.startswith("""."""       )]

							# Unique-ify and test we got them all
							UpperCamelCase__				     =			list(set(_lowerCamelCase       )       )
							UpperCamelCase__				     =			[]
							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     (a__   :List[str]   ,			a__   :Tuple       ):






							"""simple docstring"""





							UpperCamelCase__				     =			module_path.replace(os.path.sep   ,			"""."""       )
							UpperCamelCase__				     =			importlib.import_module(_lowerCamelCase       )

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





def     _UpperCamelCase     (a__   :Optional[int]       ):






							"""simple docstring"""





							from ..pipelines import DiffusionPipeline

							UpperCamelCase__				     =			dict(inspect.getmembers(_lowerCamelCase   ,			inspect.isclass       )       )

							UpperCamelCase__				     =			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}."""       )
																					UpperCamelCase__				     =			cls

							return pipeline_class





def     _UpperCamelCase     (a__   :int   ,			a__   :str   ,			a__   :Any = None   ,			a__   :List[Any] = False   ,			a__   :Optional[Any] = False   ,			a__   :List[Any] = None   ,			a__   :List[str] = None   ,			a__   :List[str] = None   ,			a__   :Optional[int] = False   ,			):






							"""simple docstring"""





							UpperCamelCase__				     =			str(_lowerCamelCase       )

							UpperCamelCase__				     =			os.path.join(_lowerCamelCase   ,			_lowerCamelCase       )

							if os.path.isfile(_lowerCamelCase       ):
														UpperCamelCase__				     =			module_file_or_url
														UpperCamelCase__				     =			"local"
							elif pretrained_model_name_or_path.count("""/"""       ) == 0:
														UpperCamelCase__				     =			get_diffusers_versions()
														# cut ".dev0"
														UpperCamelCase__				     =			"v" + ".".join(__version__.split("""."""       )[:3]       )

														# retrieve github version that matches
														if revision is None:
																					UpperCamelCase__				     =			latest_version if latest_version[1:] in available_versions else "main"
																					logger.info(f"""Defaulting to latest_version: {revision}."""       )
														elif revision in available_versions:
																					UpperCamelCase__				     =			f"""v{revision}"""
														elif revision == "main":
																					UpperCamelCase__				     =			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
														UpperCamelCase__				     =			COMMUNITY_PIPELINES_URL.format(revision=_lowerCamelCase   ,			pipeline=_lowerCamelCase       )
														try:
																					UpperCamelCase__				     =			cached_download(
																					    _lowerCamelCase   ,			cache_dir=_lowerCamelCase   ,			force_download=_lowerCamelCase   ,			proxies=_lowerCamelCase   ,			resume_download=_lowerCamelCase   ,			local_files_only=_lowerCamelCase   ,			use_auth_token=_lowerCamelCase   ,			)
																					UpperCamelCase__				     =			"git"
																					UpperCamelCase__				     =			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
																					UpperCamelCase__				     =			hf_hub_download(
																					    _lowerCamelCase   ,			_lowerCamelCase   ,			cache_dir=_lowerCamelCase   ,			force_download=_lowerCamelCase   ,			proxies=_lowerCamelCase   ,			resume_download=_lowerCamelCase   ,			local_files_only=_lowerCamelCase   ,			use_auth_token=_lowerCamelCase   ,			)
																					UpperCamelCase__				     =			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
							UpperCamelCase__				     =			check_imports(_lowerCamelCase       )

							# Now we move the module inside our cached dynamic modules.
							UpperCamelCase__				     =			DIFFUSERS_DYNAMIC_MODULE_NAME + os.path.sep + submodule
							create_dynamic_module(_lowerCamelCase       )
							UpperCamelCase__				     =			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:
																					UpperCamelCase__				     =			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       ):
																					UpperCamelCase__				     =			use_auth_token
														elif use_auth_token is True:
																					UpperCamelCase__				     =			HfFolder.get_token()
														else:
																					UpperCamelCase__				     =			None

														UpperCamelCase__				     =			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.
														UpperCamelCase__				     =			submodule_path / commit_hash
														UpperCamelCase__				     =			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     (a__   :Tuple   ,			a__   :Union[str, Any]   ,			a__   :int = None   ,			a__   :List[Any] = None   ,			a__   :Union[str, Any] = False   ,			a__   :List[Any] = False   ,			a__   :Any = None   ,			a__   :List[str] = None   ,			a__   :str = None   ,			a__   :Dict = False   ,			**a__   :Optional[Any]   ,			):






							"""simple docstring"""





							UpperCamelCase__				     =			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"""   ,			""""""       )       )











UpperCamelCase__											= "ABCDEFGHIJKLMNOPQRSTUVWXYZ"





def     _UpperCamelCase     ():






							"""simple docstring"""





							UpperCamelCase__				     =			input("""Enter message: """       )
							UpperCamelCase__				     =			input("""Enter key [alphanumeric]: """       )
							UpperCamelCase__				     =			input("""Encrypt/Decrypt [e/d]: """       )

							if mode.lower().startswith("""e"""       ):
														UpperCamelCase__				     =			"""encrypt"""
														UpperCamelCase__				     =			encrypt_message(a__   ,			a__       )
							elif mode.lower().startswith("""d"""       ):
														UpperCamelCase__				     =			"""decrypt"""
														UpperCamelCase__				     =			decrypt_message(a__   ,			a__       )

							print(f"""\n{mode.title()}ed message:"""       )
							print(a__       )





def     _UpperCamelCase     (a__   :str   ,			a__   :str       ):






							"""simple docstring"""





							return translate_message(a__   ,			a__   ,			"""encrypt"""       )





def     _UpperCamelCase     (a__   :str   ,			a__   :str       ):






							"""simple docstring"""





							return translate_message(a__   ,			a__   ,			"""decrypt"""       )





def     _UpperCamelCase     (a__   :str   ,			a__   :str   ,			a__   :str       ):






							"""simple docstring"""





							UpperCamelCase__				     =			[]
							UpperCamelCase__				     =			0
							UpperCamelCase__				     =			key.upper()

							for symbol in message:
														UpperCamelCase__				     =			LETTERS.find(symbol.upper()       )
														if num != -1:
																					if mode == "encrypt":
																												num += LETTERS.find(key[key_index]       )
																					elif mode == "decrypt":
																												num -= LETTERS.find(key[key_index]       )

																					num %= len(a__       )

																					if symbol.isupper():
																												translated.append(LETTERS[num]       )
																					elif symbol.islower():
																												translated.append(LETTERS[num].lower()       )

																					key_index += 1
																					if key_index == len(a__       ):
																												UpperCamelCase__				     =			0
														else:
																					translated.append(a__       )
							return "".join(a__       )


if __name__ == "__main__":
					main()




