





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


__A				:    List[str]       =   get_logger(__name__)


__A				:    int       =   Path(__file__).parent / "model_card_template.md"
__A				:    str       =   uuida().hex
__A				:    Dict       =   os.getenv("HF_HUB_OFFLINE", "").upper() in ENV_VARS_TRUE_VALUES
__A				:    List[str]       =   os.getenv("DISABLE_TELEMETRY", "").upper() in ENV_VARS_TRUE_VALUES
__A				:    Optional[Any]       =   HUGGINGFACE_CO_RESOLVE_ENDPOINT + "/api/telemetry/"





def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__ = None )  ->				str:







			'''simple docstring'''

			UpperCAmelCase   		=				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:







			'''simple docstring'''

			if token is None:
						UpperCAmelCase   		=				HfFolder.get_token()
			if organization is None:
						UpperCAmelCase   		=				whoami(UpperCamelCase__ )['''name''']
						return F"""{username}/{model_id}"""
			else:
						return F"""{organization}/{model_id}"""





def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__			,			UpperCamelCase__ )  ->				str:







			'''simple docstring'''

			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   		=				args.hub_token if hasattr(UpperCamelCase__			,			'''hub_token''' ) else None
			UpperCAmelCase   		=				get_full_repo_name(UpperCamelCase__			,			token=UpperCamelCase__ )

			UpperCAmelCase   		=				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   		=				os.path.join(args.output_dir			,			'''README.md''' )
			model_card.save(UpperCamelCase__ )





def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__			,			UpperCamelCase__ = None )  ->				Optional[Any]:







			'''simple docstring'''

			if resolved_file is None or commit_hash is not None:
						return commit_hash
			UpperCAmelCase   		=				str(Path(UpperCamelCase__ ).as_posix() )
			UpperCAmelCase   		=				re.search(R'''snapshots/([^/]+)/'''			,			UpperCamelCase__ )
			if search is None:
						return None
			UpperCAmelCase   		=				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.
__A				:    Optional[int]       =   os.path.expanduser(
    os.getenv("HF_HOME", os.path.join(os.getenv("XDG_CACHE_HOME", "~/.cache"), "huggingface"))
)
__A				:    Any       =   os.path.join(hf_cache_home, "diffusers")





def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__ = None			,			UpperCamelCase__ = None )  ->				None:







			'''simple docstring'''

			if new_cache_dir is None:
						UpperCAmelCase   		=				DIFFUSERS_CACHE
			if old_cache_dir is None:
						UpperCAmelCase   		=				old_diffusers_cache

			UpperCAmelCase   		=				Path(UpperCamelCase__ ).expanduser()
			UpperCAmelCase   		=				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   		=				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).


__A				:    Tuple       =   os.path.join(DIFFUSERS_CACHE, "version_diffusers_cache.txt")
if not os.path.isfile(cache_version_file):
				__A				:    int       =   0
else:
				with open(cache_version_file) as f:
								try:
												__A				:    List[Any]       =   int(f.read())
								except ValueError:
												__A				:    Dict       =   0

if cache_version < 1:
				__A				:    Dict       =   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:
												__A				:    List[Any]       =   "\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:







			'''simple docstring'''

			if variant is not None:
						UpperCAmelCase   		=				weights_name.split('''.''' )
						UpperCAmelCase   		=				splits[:-1] + [variant] + splits[-1:]
						UpperCAmelCase   		=				'''.'''.join(UpperCamelCase__ )

			return weights_name






def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__			,			*,
    UpperCamelCase__			,			UpperCamelCase__			,			UpperCamelCase__			,			UpperCamelCase__			,			UpperCamelCase__			,			UpperCamelCase__			,			UpperCamelCase__			,			UpperCamelCase__			,			UpperCamelCase__			,			UpperCamelCase__			,			UpperCamelCase__=None			,			)  ->				Optional[Any]:







			'''simple docstring'''

			UpperCAmelCase   		=				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   		=				os.path.join(UpperCamelCase__			,			UpperCamelCase__ )
									return model_file
						elif subfolder is not None and os.path.isfile(
						    os.path.join(UpperCamelCase__			,			UpperCamelCase__			,			UpperCamelCase__ ) ):
									UpperCAmelCase   		=				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   		=				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   		=				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}""" )










from collections import OrderedDict
from typing import TYPE_CHECKING, Any, List, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import TensorType, logging


if TYPE_CHECKING:
				from ...onnx.config import PatchingSpec
				from ...tokenization_utils_base import PreTrainedTokenizerBase


__A				:    Dict       =   logging.get_logger(__name__)

__A				:    str       =   {
    "allenai/longformer-base-4096": "https://huggingface.co/allenai/longformer-base-4096/resolve/main/config.json",
    "allenai/longformer-large-4096": "https://huggingface.co/allenai/longformer-large-4096/resolve/main/config.json",
    "allenai/longformer-large-4096-finetuned-triviaqa": (
        "https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/config.json"
    ),
    "allenai/longformer-base-4096-extra.pos.embd.only": (
        "https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/config.json"
    ),
    "allenai/longformer-large-4096-extra.pos.embd.only": (
        "https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/config.json"
    ),
}

class 	A_       (a_			):
	UpperCAmelCase__					=			'''longformer'''
	def __init__(    self							,					_A = 5_1_2							,					_A = 2							,					_A = 1							,					_A = 0							,					_A = 2							,					_A = 3_0_5_2_2							,					_A = 7_6_8							,					_A = 1_2							,					_A = 1_2							,					_A = 3_0_7_2							,					_A = "gelu"							,					_A = 0.1							,					_A = 0.1							,					_A = 5_1_2							,					_A = 2							,					_A = 0.02							,					_A = 1E-12							,					_A = False							,					**_A							,					):






				'''simple docstring'''







				super().__init__(pad_token_id=_A							,					**_A		)

				UpperCAmelCase   		=				attention_window
				UpperCAmelCase   		=				sep_token_id
				UpperCAmelCase   		=				bos_token_id
				UpperCAmelCase   		=				eos_token_id
				UpperCAmelCase   		=				vocab_size
				UpperCAmelCase   		=				hidden_size
				UpperCAmelCase   		=				num_hidden_layers
				UpperCAmelCase   		=				num_attention_heads
				UpperCAmelCase   		=				hidden_act
				UpperCAmelCase   		=				intermediate_size
				UpperCAmelCase   		=				hidden_dropout_prob
				UpperCAmelCase   		=				attention_probs_dropout_prob
				UpperCAmelCase   		=				max_position_embeddings
				UpperCAmelCase   		=				type_vocab_size
				UpperCAmelCase   		=				initializer_range
				UpperCAmelCase   		=				layer_norm_eps
				UpperCAmelCase   		=				onnx_export

class 	A_       (a_			):
	def __init__(    self							,					_A							,					_A = "default"							,					_A = None		):






				'''simple docstring'''







				super().__init__(_A							,					_A							,					_A		)
				UpperCAmelCase   		=				True
	@property
	def      _lowercase				(    self		):






				'''simple docstring'''







				if self.task == "multiple-choice":
							UpperCAmelCase   		=				{0: '''batch''', 1: '''choice''', 2: '''sequence'''}
				else:
							UpperCAmelCase   		=				{0: '''batch''', 1: '''sequence'''}
				return OrderedDict(
				    [
				        ('''input_ids''', dynamic_axis),
				        ('''attention_mask''', dynamic_axis),
				        ('''global_attention_mask''', dynamic_axis),
				    ]		)
	@property
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				super().outputs
				if self.task == "default":
							UpperCAmelCase   		=				{0: '''batch'''}
				return outputs
	@property
	def      _lowercase				(    self		):






				'''simple docstring'''







				return 1E-4
	@property
	def      _lowercase				(    self		):






				'''simple docstring'''







				return max(super().default_onnx_opset							,					1_4		)







	def      _lowercase				(    self							,					_A							,					_A = -1							,					_A = -1							,					_A = False							,					_A = None							,					):






				'''simple docstring'''







				UpperCAmelCase   		=				super().generate_dummy_inputs(
				    preprocessor=_A							,					batch_size=_A							,					seq_length=_A							,					is_pair=_A							,					framework=_A		)
				import torch

				# for some reason, replacing this code by inputs["global_attention_mask"] = torch.randint(2, inputs["input_ids"].shape, dtype=torch.int64)
				# makes the export fail randomly
				UpperCAmelCase   		=				torch.zeros_like(inputs['''input_ids''']		)
				# make every second token global
				UpperCAmelCase   		=				1

				return inputs



