






'''simple docstring'''


import os
import re
import sys
import traceback
import warnings
from pathlib import Path
from typing import Dict, Optional, Union
from uuid import uuida

from huggingface_hub import HfFolder, ModelCard, ModelCardData, hf_hub_download, whoami
from huggingface_hub.file_download import REGEX_COMMIT_HASH
from huggingface_hub.utils import (
    EntryNotFoundError,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    is_jinja_available,
)
from packaging import version
from requests import HTTPError

from .. import __version__
from .constants import (
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    SAFETENSORS_WEIGHTS_NAME,
    WEIGHTS_NAME,
)
from .import_utils import (
    ENV_VARS_TRUE_VALUES,
    _flax_version,
    _jax_version,
    _onnxruntime_version,
    _torch_version,
    is_flax_available,
    is_onnx_available,
    is_torch_available,
)
from .logging import get_logger


lowerCAmelCase__										= get_logger(__name__)


lowerCAmelCase__										= Path(__file__).parent / "model_card_template.md"
lowerCAmelCase__										= uuida().hex
lowerCAmelCase__										= os.getenv("HF_HUB_OFFLINE", "").upper() in ENV_VARS_TRUE_VALUES
lowerCAmelCase__										= os.getenv("DISABLE_TELEMETRY", "").upper() in ENV_VARS_TRUE_VALUES
lowerCAmelCase__										= HUGGINGFACE_CO_RESOLVE_ENDPOINT + "/api/telemetry/"







def 						SCREAMING_SNAKE_CASE(  UpperCamelCase = None  )    ->    str:
	UpperCAmelCase_		:      Optional[int]       	=					f"""diffusers/{__version__}; python/{sys.version.split()[0]}; session_id/{SESSION_ID}"""
	if DISABLE_TELEMETRY or HF_HUB_OFFLINE:
		return ua + "; telemetry/off"
	if is_torch_available():
		ua += f"""; torch/{_torch_version}"""
	if is_flax_available():
		ua += f"""; jax/{_jax_version}"""
		ua += f"""; flax/{_flax_version}"""
	if is_onnx_available():
		ua += f"""; onnxruntime/{_onnxruntime_version}"""
	# CI will set this value to True
	if os.environ.get('DIFFUSERS_IS_CI'   ,''  ).upper() in ENV_VARS_TRUE_VALUES:
		ua += "; is_ci/true"
	if isinstance(UpperCamelCase   ,UpperCamelCase  ):
		ua += "; " + "; ".join(f"""{k}/{v}""" for k, v in user_agent.items()  )
	elif isinstance(UpperCamelCase   ,UpperCamelCase  ):
		ua += "; " + user_agent
	return ua







def 						SCREAMING_SNAKE_CASE(  UpperCamelCase   ,UpperCamelCase = None   ,UpperCamelCase = None  )    ->    Dict:
	if token is None:
		UpperCAmelCase_		:      Optional[Any]       	=					HfFolder.get_token()
	if organization is None:
		UpperCAmelCase_		:      str       	=					whoami(UpperCamelCase  )['name']
		return f"""{username}/{model_id}"""
	else:
		return f"""{organization}/{model_id}"""







def 						SCREAMING_SNAKE_CASE(  UpperCamelCase   ,UpperCamelCase  )    ->    Union[str, Any]:
	if not is_jinja_available():
		raise ValueError(
		    'Modelcard rendering is based on Jinja templates.'
		    ' Please make sure to have `jinja` installed before using `create_model_card`.'
		    ' To install it, please run `pip install Jinja2`.'  )

	if hasattr(UpperCamelCase   ,'local_rank'  ) and args.local_rank not in [-1, 0]:
		return

	UpperCAmelCase_		:      List[Any]       	=					args.hub_token if hasattr(UpperCamelCase   ,'hub_token'  ) else None
	UpperCAmelCase_		:      Dict       	=					get_full_repo_name(UpperCamelCase   ,token=UpperCamelCase  )

	UpperCAmelCase_		:      Optional[int]       	=					ModelCard.from_template(
	    card_data=ModelCardData(  # Card metadata object that will be converted to YAML block
	        language='en'   ,license='apache-2.0'   ,library_name='diffusers'   ,tags=[]   ,datasets=args.dataset_name   ,metrics=[]   ,)   ,template_path=UpperCamelCase   ,model_name=UpperCamelCase   ,repo_name=UpperCamelCase   ,dataset_name=args.dataset_name if hasattr(UpperCamelCase   ,'dataset_name'  ) else None   ,learning_rate=args.learning_rate   ,train_batch_size=args.train_batch_size   ,eval_batch_size=args.eval_batch_size   ,gradient_accumulation_steps=(
	        args.gradient_accumulation_steps if hasattr(UpperCamelCase   ,'gradient_accumulation_steps'  ) else None
	    )   ,adam_betaa=args.adam_betaa if hasattr(UpperCamelCase   ,'adam_beta1'  ) else None   ,adam_betaa=args.adam_betaa if hasattr(UpperCamelCase   ,'adam_beta2'  ) else None   ,adam_weight_decay=args.adam_weight_decay if hasattr(UpperCamelCase   ,'adam_weight_decay'  ) else None   ,adam_epsilon=args.adam_epsilon if hasattr(UpperCamelCase   ,'adam_epsilon'  ) else None   ,lr_scheduler=args.lr_scheduler if hasattr(UpperCamelCase   ,'lr_scheduler'  ) else None   ,lr_warmup_steps=args.lr_warmup_steps if hasattr(UpperCamelCase   ,'lr_warmup_steps'  ) else None   ,ema_inv_gamma=args.ema_inv_gamma if hasattr(UpperCamelCase   ,'ema_inv_gamma'  ) else None   ,ema_power=args.ema_power if hasattr(UpperCamelCase   ,'ema_power'  ) else None   ,ema_max_decay=args.ema_max_decay if hasattr(UpperCamelCase   ,'ema_max_decay'  ) else None   ,mixed_precision=args.mixed_precision   ,)

	UpperCAmelCase_		:      int       	=					os.path.join(args.output_dir   ,'README.md'  )
	model_card.save(UpperCamelCase  )







def 						SCREAMING_SNAKE_CASE(  UpperCamelCase   ,UpperCamelCase = None  )    ->    Any:
	if resolved_file is None or commit_hash is not None:
		return commit_hash
	UpperCAmelCase_		:      List[str]       	=					str(Path(UpperCamelCase  ).as_posix()  )
	UpperCAmelCase_		:      List[str]       	=					re.search(r'snapshots/([^/]+)/'   ,UpperCamelCase  )
	if search is None:
		return None
	UpperCAmelCase_		:      Tuple       	=					search.groups()[0]
	return commit_hash if REGEX_COMMIT_HASH.match(UpperCamelCase  ) else None


# Old default cache path, potentially to be migrated.
# This logic was more or less taken from `transformers`, with the following differences:
# - Diffusers doesn't use custom environment variables to specify the cache path.
# - There is no need to migrate the cache format, just move the files to the new location.
lowerCAmelCase__										= os.path.expanduser(
    os.getenv("HF_HOME", os.path.join(os.getenv("XDG_CACHE_HOME", "~/.cache"), "huggingface"))
)
lowerCAmelCase__										= os.path.join(hf_cache_home, "diffusers")







def 						SCREAMING_SNAKE_CASE(  UpperCamelCase = None   ,UpperCamelCase = None  )    ->    None:
	if new_cache_dir is None:
		UpperCAmelCase_		:      List[str]       	=					DIFFUSERS_CACHE
	if old_cache_dir is None:
		UpperCAmelCase_		:      str       	=					old_diffusers_cache

	UpperCAmelCase_		:      Any       	=					Path(UpperCamelCase  ).expanduser()
	UpperCAmelCase_		:      List[Any]       	=					Path(UpperCamelCase  ).expanduser()
	for old_blob_path in old_cache_dir.glob('**/blobs/*'  ):
		if old_blob_path.is_file() and not old_blob_path.is_symlink():
			UpperCAmelCase_		:      str       	=					new_cache_dir / old_blob_path.relative_to(UpperCamelCase  )
			new_blob_path.parent.mkdir(parents=UpperCamelCase   ,exist_ok=UpperCamelCase  )
			os.replace(UpperCamelCase   ,UpperCamelCase  )
			try:
				os.symlink(UpperCamelCase   ,UpperCamelCase  )
			except OSError:
				logger.warning(
				    'Could not create symlink between old cache and new cache. If you use an older version of diffusers again, files will be re-downloaded.'  )
	# At this point, old_cache_dir contains symlinks to the new cache (it can still be used).


lowerCAmelCase__										= os.path.join(DIFFUSERS_CACHE, "version_diffusers_cache.txt")
if not os.path.isfile(cache_version_file):
						lowerCAmelCase__										= 0
else:
						with open(cache_version_file) as f:
												try:
																		lowerCAmelCase__										= int(f.read())
												except ValueError:
																		lowerCAmelCase__										= 0

if cache_version < 1:
						lowerCAmelCase__										= os.path.isdir(old_diffusers_cache) and len(os.listdir(old_diffusers_cache)) > 0
						if old_cache_is_not_empty:
												logger.warning(
												    "The cache for model files in Diffusers v0.14.0 has moved to a new location. Moving your "
												    "existing cached models. This is a one-time operation, you can interrupt it or run it "
												    "later by calling `diffusers.utils.hub_utils.move_cache()`."
												)
												try:
																		move_cache()
												except Exception as e:
																		lowerCAmelCase__										= "\n".join(traceback.format_tb(e.__traceback__))
																		logger.error(
																		    F'There was a problem when trying to move your cache:\n\n{trace}\n{e.__class__.__name__}: {e}\n\nPlease '
																		    "file an issue at https://github.com/huggingface/diffusers/issues/new/choose, copy paste this whole "
																		    "message and we will do our best to help."
																		)

if cache_version < 1:
						try:
												os.makedirs(DIFFUSERS_CACHE, exist_ok=True)
												with open(cache_version_file, "w") as f:
																		f.write("1")
						except Exception:
												logger.warning(
												    F'There was a problem when trying to write in your cache folder ({DIFFUSERS_CACHE}). Please, ensure '
												    "the directory exists and can be written to."
												)







def 						SCREAMING_SNAKE_CASE(  UpperCamelCase   ,UpperCamelCase = None  )    ->    str:
	if variant is not None:
		UpperCAmelCase_		:      Dict       	=					weights_name.split('.'  )
		UpperCAmelCase_		:      Dict       	=					splits[:-1] + [variant] + splits[-1:]
		UpperCAmelCase_		:      Tuple       	=					'.'.join(UpperCamelCase  )

	return weights_name







def 						SCREAMING_SNAKE_CASE(  UpperCamelCase   ,*,
    UpperCamelCase   ,UpperCamelCase   ,UpperCamelCase   ,UpperCamelCase   ,UpperCamelCase   ,UpperCamelCase   ,UpperCamelCase   ,UpperCamelCase   ,UpperCamelCase   ,UpperCamelCase   ,UpperCamelCase=None   ,)    ->    int:
	UpperCAmelCase_		:      List[Any]       	=					str(UpperCamelCase  )
	if os.path.isfile(UpperCamelCase  ):
		return pretrained_model_name_or_path
	elif os.path.isdir(UpperCamelCase  ):
		if os.path.isfile(os.path.join(UpperCamelCase   ,UpperCamelCase  )  ):
			# Load from a PyTorch checkpoint
			UpperCAmelCase_		:      int       	=					os.path.join(UpperCamelCase   ,UpperCamelCase  )
			return model_file
		elif subfolder is not None and os.path.isfile(
		    os.path.join(UpperCamelCase   ,UpperCamelCase   ,UpperCamelCase  )  ):
			UpperCAmelCase_		:      Dict       	=					os.path.join(UpperCamelCase   ,UpperCamelCase   ,UpperCamelCase  )
			return model_file
		else:
			raise EnvironmentError(
			    f"""Error no file named {weights_name} found in directory {pretrained_model_name_or_path}."""  )
	else:
		# 1. First check if deprecated way of loading from branches is used
		if (
		    revision in DEPRECATED_REVISION_ARGS
		    and (weights_name == WEIGHTS_NAME or weights_name == SAFETENSORS_WEIGHTS_NAME)
		    and version.parse(version.parse(UpperCamelCase  ).base_version  ) >= version.parse('0.20.0'  )
		):
			try:
				UpperCAmelCase_		:      int       	=					hf_hub_download(
				    UpperCamelCase   ,filename=_add_variant(UpperCamelCase   ,UpperCamelCase  )   ,cache_dir=UpperCamelCase   ,force_download=UpperCamelCase   ,proxies=UpperCamelCase   ,resume_download=UpperCamelCase   ,local_files_only=UpperCamelCase   ,use_auth_token=UpperCamelCase   ,user_agent=UpperCamelCase   ,subfolder=UpperCamelCase   ,revision=revision or commit_hash   ,)
				warnings.warn(
				    f"""Loading the variant {revision} from {pretrained_model_name_or_path} via `revision='{revision}'` is deprecated. Loading instead from `revision='main'` with `variant={revision}`. Loading model variants via `revision='{revision}'` will be removed in diffusers v1. Please use `variant='{revision}'` instead."""   ,UpperCamelCase   ,)
				return model_file
			except:  # noqa: E722
				warnings.warn(
				    f"""You are loading the variant {revision} from {pretrained_model_name_or_path} via `revision='{revision}'`. This behavior is deprecated and will be removed in diffusers v1. One should use `variant='{revision}'` instead. However, it appears that {pretrained_model_name_or_path} currently does not have a {_add_variant(UpperCamelCase   ,UpperCamelCase  )} file in the 'main' branch of {pretrained_model_name_or_path}. \n The Diffusers team and community would be very grateful if you could open an issue: https://github.com/huggingface/diffusers/issues/new with the title '{pretrained_model_name_or_path} is missing {_add_variant(UpperCamelCase   ,UpperCamelCase  )}' so that the correct variant file can be added."""   ,UpperCamelCase   ,)
		try:
			# 2. Load model file as usual
			UpperCAmelCase_		:      int       	=					hf_hub_download(
			    UpperCamelCase   ,filename=UpperCamelCase   ,cache_dir=UpperCamelCase   ,force_download=UpperCamelCase   ,proxies=UpperCamelCase   ,resume_download=UpperCamelCase   ,local_files_only=UpperCamelCase   ,use_auth_token=UpperCamelCase   ,user_agent=UpperCamelCase   ,subfolder=UpperCamelCase   ,revision=revision or commit_hash   ,)
			return model_file

		except RepositoryNotFoundError:
			raise EnvironmentError(
			    f"""{pretrained_model_name_or_path} 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`.'  )
		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/{pretrained_model_name_or_path}' for available revisions."""  )
		except EntryNotFoundError:
			raise EnvironmentError(
			    f"""{pretrained_model_name_or_path} does not appear to have a file named {weights_name}."""  )
		except HTTPError as err:
			raise EnvironmentError(
			    f"""There was a specific connection error when trying to load {pretrained_model_name_or_path}:\n{err}"""  )
		except ValueError:
			raise EnvironmentError(
			    f"""We couldn't connect to '{HUGGINGFACE_CO_RESOLVE_ENDPOINT}' to load this model, couldn't find it"""
			    f""" in the cached files and it looks like {pretrained_model_name_or_path} is not the path to a"""
			    f""" directory containing a file named {weights_name} or"""
			    ' \nCheckout your internet connection or see how to run the library in'
			    ' offline mode at \'https://huggingface.co/docs/diffusers/installation#offline-mode\'.'  )
		except EnvironmentError:
			raise EnvironmentError(
			    f"""Can't load the model for '{pretrained_model_name_or_path}'. If you were trying to load it from """
			    '\'https://huggingface.co/models\', make sure you don\'t have a local directory with the same name. '
			    f"""Otherwise, make sure '{pretrained_model_name_or_path}' is the correct path to a directory """
			    f"""containing a file named {weights_name}"""  )









'''simple docstring'''


from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase__										= logging.get_logger(__name__)

lowerCAmelCase__										= {
    "tanreinama/GPTSAN-2.8B-spout_is_uniform": (
        "https://huggingface.co/tanreinama/GPTSAN-2.8B-spout_is_uniform/resolve/main/config.json"
    ),
}



class 					lowercase						(  a_ ):
							_lowerCamelCase		:      Any=   "gptsan-japanese"
							_lowerCamelCase		:      List[Any]=   [
							    "past_key_values",
							]
							_lowerCamelCase		:      Tuple=   {
							    "hidden_size": "d_model",
							    "num_attention_heads": "num_heads",
							    "num_hidden_layers": "num_layers",
							}


							def __init__(			self    ,			_snake_case=3_6000    ,			_snake_case=1280    ,			_snake_case=1024    ,			_snake_case=8192    ,			_snake_case=4096    ,			_snake_case=128    ,			_snake_case=10    ,			_snake_case=0    ,			_snake_case=16    ,			_snake_case=16    ,			_snake_case=128    ,			_snake_case=0.0    ,			_snake_case=1e-5    ,			_snake_case=False    ,			_snake_case=0.0    ,			_snake_case="float32"    ,			_snake_case=False    ,			_snake_case=False    ,			_snake_case=False    ,			_snake_case=0.002    ,			_snake_case=False    ,			_snake_case=True    ,			_snake_case=3_5998    ,			_snake_case=3_5995    ,			_snake_case=3_5999    ,			**_snake_case    ,			)							->				Optional[int]:
								UpperCAmelCase_		:      Dict       	=					vocab_size
								UpperCAmelCase_		:      Optional[int]       	=					max_position_embeddings
								UpperCAmelCase_		:      Any       	=					d_model
								UpperCAmelCase_		:      int       	=					d_ff
								UpperCAmelCase_		:      Tuple       	=					d_ext
								UpperCAmelCase_		:      Tuple       	=					d_spout
								UpperCAmelCase_		:      List[Any]       	=					num_switch_layers
								UpperCAmelCase_		:      Tuple       	=					num_ext_layers
								UpperCAmelCase_		:      Optional[int]       	=					num_switch_layers + num_ext_layers
								UpperCAmelCase_		:      Tuple       	=					num_heads
								UpperCAmelCase_		:      List[str]       	=					num_experts
								UpperCAmelCase_		:      List[str]       	=					expert_capacity
								UpperCAmelCase_		:      Optional[int]       	=					dropout_rate
								UpperCAmelCase_		:      List[Any]       	=					layer_norm_epsilon
								UpperCAmelCase_		:      Any       	=					router_bias
								UpperCAmelCase_		:      Optional[Any]       	=					router_jitter_noise
								UpperCAmelCase_		:      str       	=					router_dtype
								UpperCAmelCase_		:      List[str]       	=					router_ignore_padding_tokens
								UpperCAmelCase_		:      Optional[int]       	=					output_hidden_states
								UpperCAmelCase_		:      Union[str, Any]       	=					output_attentions
								UpperCAmelCase_		:      Optional[int]       	=					initializer_factor
								UpperCAmelCase_		:      Optional[int]       	=					output_router_logits
								UpperCAmelCase_		:      List[str]       	=					use_cache

								super().__init__(
								    separator_token_id=_snake_case    ,			pad_token_id=_snake_case    ,			eos_token_id=_snake_case    ,			**_snake_case    ,			)






