

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


_SCREAMING_SNAKE_CASE  :						Union[str, Any]         =    get_logger(__name__)


_SCREAMING_SNAKE_CASE  :						int         =    Path(__file__).parent / '''model_card_template.md'''
_SCREAMING_SNAKE_CASE  :						Optional[int]         =    uuida().hex
_SCREAMING_SNAKE_CASE  :						Any         =    os.getenv('''HF_HUB_OFFLINE''', '''''').upper() in ENV_VARS_TRUE_VALUES
_SCREAMING_SNAKE_CASE  :						Optional[Any]         =    os.getenv('''DISABLE_TELEMETRY''', '''''').upper() in ENV_VARS_TRUE_VALUES
_SCREAMING_SNAKE_CASE  :						Optional[int]         =    HUGGINGFACE_CO_RESOLVE_ENDPOINT + '''/api/telemetry/'''
def        UpperCAmelCase_     (		_A = None       ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__					=					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        UpperCAmelCase_     (		_A   ,	_A = None   ,	_A = None       ):





     '''simple docstring'''




     if token is None:
          SCREAMING_SNAKE_CASE__					=					HfFolder.get_token()
     if organization is None:
          SCREAMING_SNAKE_CASE__					=					whoami(__UpperCamelCase       )['''name''']
          return F'''{username}/{model_id}'''
     else:
          return F'''{organization}/{model_id}'''
def        UpperCAmelCase_     (		_A   ,	_A       ):





     '''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

     SCREAMING_SNAKE_CASE__					=					args.hub_token if hasattr(__UpperCamelCase   ,	'''hub_token'''       ) else None
     SCREAMING_SNAKE_CASE__					=					get_full_repo_name(__UpperCamelCase   ,	token=__UpperCamelCase       )

     SCREAMING_SNAKE_CASE__					=					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   ,	)

     SCREAMING_SNAKE_CASE__					=					os.path.join(args.output_dir   ,	'''README.md'''       )
     model_card.save(__UpperCamelCase       )
def        UpperCAmelCase_     (		_A   ,	_A = None       ):





     '''simple docstring'''




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





     '''simple docstring'''




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

     SCREAMING_SNAKE_CASE__					=					Path(__UpperCamelCase       ).expanduser()
     SCREAMING_SNAKE_CASE__					=					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():
               SCREAMING_SNAKE_CASE__					=					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).


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

if cache_version < 1:
  _SCREAMING_SNAKE_CASE  :						Optional[Any]         =    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:
      _SCREAMING_SNAKE_CASE  :						Union[str, 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        UpperCAmelCase_     (		_A   ,	_A = None       ):





     '''simple docstring'''




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

     return weights_name







def        UpperCAmelCase_     (		_A   ,	*,
    _A   ,	_A   ,	_A   ,	_A   ,	_A   ,	_A   ,	_A   ,	_A   ,	_A   ,	_A   ,	_A=None   ,	):





     '''simple docstring'''




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


_SCREAMING_SNAKE_CASE  :						Any         =    logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE  :						List[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  UpperCAmelCase__	( A__ ):






  """simple docstring"""


  a     =      "longformer"






  def __init__(							self		:	int			,     __lowerCamelCase		:	Union[List[int], int] = 512			,     __lowerCamelCase		:	int = 2			,     __lowerCamelCase		:	int = 1			,     __lowerCamelCase		:	int = 0			,     __lowerCamelCase		:	int = 2			,     __lowerCamelCase		:	int = 3_0522			,     __lowerCamelCase		:	int = 768			,     __lowerCamelCase		:	int = 12			,     __lowerCamelCase		:	int = 12			,     __lowerCamelCase		:	int = 3072			,     __lowerCamelCase		:	str = "gelu"			,     __lowerCamelCase		:	float = 0.1			,     __lowerCamelCase		:	float = 0.1			,     __lowerCamelCase		:	int = 512			,     __lowerCamelCase		:	int = 2			,     __lowerCamelCase		:	float = 0.02			,     __lowerCamelCase		:	float = 1e-12			,     __lowerCamelCase		:	bool = False			,     **__lowerCamelCase		:	Tuple			,     )	->							List[Any]:
       super().__init__(pad_token_id=__lowerCamelCase			,     **__lowerCamelCase      )

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






class  UpperCAmelCase__	( A__ ):






  """simple docstring"""


  def __init__(							self		:	Dict			,     __lowerCamelCase		:	"PretrainedConfig"			,     __lowerCamelCase		:	str = "default"			,     __lowerCamelCase		:	"List[PatchingSpec]" = None      )	->							List[str]:
       super().__init__(__lowerCamelCase			,     __lowerCamelCase			,     __lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					True






  @property
  def    lowercase_	(							self		:	Optional[Any]      )	->							Mapping[str, Mapping[int, str]]:
       if self.task == "multiple-choice":
            SCREAMING_SNAKE_CASE__					=					{0: '''batch''', 1: '''choice''', 2: '''sequence'''}
       else:
            SCREAMING_SNAKE_CASE__					=					{0: '''batch''', 1: '''sequence'''}
       return OrderedDict(
           [
               ('''input_ids''', dynamic_axis),
               ('''attention_mask''', dynamic_axis),
               ('''global_attention_mask''', dynamic_axis),
           ]      )






  @property
  def    lowercase_	(							self		:	Optional[int]      )	->							Mapping[str, Mapping[int, str]]:
       SCREAMING_SNAKE_CASE__					=					super().outputs
       if self.task == "default":
            SCREAMING_SNAKE_CASE__					=					{0: '''batch'''}
       return outputs






  @property
  def    lowercase_	(							self		:	Optional[int]      )	->							float:
       return 1e-4






  @property
  def    lowercase_	(							self		:	Union[str, Any]      )	->							int:
       # needs to be >= 14 to support tril operator
       return max(super().default_onnx_opset			,     14      )







  def    lowercase_	(							self		:	Dict			,     __lowerCamelCase		:	"PreTrainedTokenizerBase"			,     __lowerCamelCase		:	int = -1			,     __lowerCamelCase		:	int = -1			,     __lowerCamelCase		:	bool = False			,     __lowerCamelCase		:	Optional[TensorType] = None			,     )	->							Mapping[str, Any]:
       SCREAMING_SNAKE_CASE__					=					super().generate_dummy_inputs(
           preprocessor=__lowerCamelCase			,     batch_size=__lowerCamelCase			,     seq_length=__lowerCamelCase			,     is_pair=__lowerCamelCase			,     framework=__lowerCamelCase      )
       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
       SCREAMING_SNAKE_CASE__					=					torch.zeros_like(inputs['''input_ids''']      )
       # make every second token global
       SCREAMING_SNAKE_CASE__					=					1

       return inputs


