





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


lowercase_          =		get_logger(__name__)


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




def       __UpperCamelCase  (_SCREAMING_SNAKE_CASE = None		)    ->       str:
  lowercase__           =  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(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		):
    ua += "; " + "; ".join(F"""{k}/{v}""" for k, v in user_agent.items()		)
  elif isinstance(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		):
    ua += "; " + user_agent
  return ua




def       __UpperCamelCase  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE = None		,						_SCREAMING_SNAKE_CASE = None		)    ->       Any:
  if token is None:
    lowercase__           =  HfFolder.get_token()
  if organization is None:
    lowercase__           =  whoami(_SCREAMING_SNAKE_CASE		)['name']
    return F"""{username}/{model_id}"""
  else:
    return F"""{organization}/{model_id}"""




def       __UpperCamelCase  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       List[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(_SCREAMING_SNAKE_CASE		,						'local_rank'		) and args.local_rank not in [-1, 0]:
    return

  lowercase__           =  args.hub_token if hasattr(_SCREAMING_SNAKE_CASE		,						'hub_token'		) else None
  lowercase__           =  get_full_repo_name(_SCREAMING_SNAKE_CASE		,						token=_SCREAMING_SNAKE_CASE		)

  lowercase__           =  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=_SCREAMING_SNAKE_CASE		,						model_name=_SCREAMING_SNAKE_CASE		,						repo_name=_SCREAMING_SNAKE_CASE		,						dataset_name=args.dataset_name if hasattr(_SCREAMING_SNAKE_CASE		,						'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(_SCREAMING_SNAKE_CASE		,						'gradient_accumulation_steps'		) else None
      )		,						adam_betaa=args.adam_betaa if hasattr(_SCREAMING_SNAKE_CASE		,						'adam_beta1'		) else None		,						adam_betaa=args.adam_betaa if hasattr(_SCREAMING_SNAKE_CASE		,						'adam_beta2'		) else None		,						adam_weight_decay=args.adam_weight_decay if hasattr(_SCREAMING_SNAKE_CASE		,						'adam_weight_decay'		) else None		,						adam_epsilon=args.adam_epsilon if hasattr(_SCREAMING_SNAKE_CASE		,						'adam_epsilon'		) else None		,						lr_scheduler=args.lr_scheduler if hasattr(_SCREAMING_SNAKE_CASE		,						'lr_scheduler'		) else None		,						lr_warmup_steps=args.lr_warmup_steps if hasattr(_SCREAMING_SNAKE_CASE		,						'lr_warmup_steps'		) else None		,						ema_inv_gamma=args.ema_inv_gamma if hasattr(_SCREAMING_SNAKE_CASE		,						'ema_inv_gamma'		) else None		,						ema_power=args.ema_power if hasattr(_SCREAMING_SNAKE_CASE		,						'ema_power'		) else None		,						ema_max_decay=args.ema_max_decay if hasattr(_SCREAMING_SNAKE_CASE		,						'ema_max_decay'		) else None		,						mixed_precision=args.mixed_precision		,						)

  lowercase__           =  os.path.join(args.output_dir		,						'README.md'		)
  model_card.save(_SCREAMING_SNAKE_CASE		)




def       __UpperCamelCase  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE = None		)    ->       Optional[int]:
  if resolved_file is None or commit_hash is not None:
    return commit_hash
  lowercase__           =  str(Path(_SCREAMING_SNAKE_CASE		).as_posix()		)
  lowercase__           =  re.search(R'snapshots/([^/]+)/'		,						_SCREAMING_SNAKE_CASE		)
  if search is None:
    return None
  lowercase__           =  search.groups()[0]
  return commit_hash if REGEX_COMMIT_HASH.match(_SCREAMING_SNAKE_CASE		) 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.
lowercase_          =		os.path.expanduser(
    os.getenv("""HF_HOME""", os.path.join(os.getenv("""XDG_CACHE_HOME""", """~/.cache"""), """huggingface"""))
)
lowercase_          =		os.path.join(hf_cache_home, """diffusers""")




def       __UpperCamelCase  (_SCREAMING_SNAKE_CASE = None		,						_SCREAMING_SNAKE_CASE = None		)    ->       None:
  if new_cache_dir is None:
    lowercase__           =  DIFFUSERS_CACHE
  if old_cache_dir is None:
    lowercase__           =  old_diffusers_cache

  lowercase__           =  Path(_SCREAMING_SNAKE_CASE		).expanduser()
  lowercase__           =  Path(_SCREAMING_SNAKE_CASE		).expanduser()
  for old_blob_path in old_cache_dir.glob('**/blobs/*'		):
    if old_blob_path.is_file() and not old_blob_path.is_symlink():
      lowercase__           =  new_cache_dir / old_blob_path.relative_to(_SCREAMING_SNAKE_CASE		)
      new_blob_path.parent.mkdir(parents=_SCREAMING_SNAKE_CASE		,						exist_ok=_SCREAMING_SNAKE_CASE		)
      os.replace(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)
      try:
        os.symlink(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)
      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).


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

if cache_version < 1:
      lowercase_          =		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:
                  lowercase_          =		"""\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  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE = None		)    ->       str:
  if variant is not None:
    lowercase__           =  weights_name.split('.'		)
    lowercase__           =  splits[:-1] + [variant] + splits[-1:]
    lowercase__           =  '.'.join(_SCREAMING_SNAKE_CASE		)

  return weights_name




def       __UpperCamelCase  (_SCREAMING_SNAKE_CASE		,						*,
    _SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE=None		,						)    ->       str:
  lowercase__           =  str(_SCREAMING_SNAKE_CASE		)
  if os.path.isfile(_SCREAMING_SNAKE_CASE		):
    return pretrained_model_name_or_path
  elif os.path.isdir(_SCREAMING_SNAKE_CASE		):
    if os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)		):
      # Load from a PyTorch checkpoint
      lowercase__           =  os.path.join(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)
      return model_file
    elif subfolder is not None and os.path.isfile(
        os.path.join(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)		):
      lowercase__           =  os.path.join(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)
      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(_SCREAMING_SNAKE_CASE		).base_version		) >= version.parse('0.20.0'		)
    ):
      try:
        lowercase__           =  hf_hub_download(
            _SCREAMING_SNAKE_CASE		,						filename=_add_variant(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)		,						cache_dir=_SCREAMING_SNAKE_CASE		,						force_download=_SCREAMING_SNAKE_CASE		,						proxies=_SCREAMING_SNAKE_CASE		,						resume_download=_SCREAMING_SNAKE_CASE		,						local_files_only=_SCREAMING_SNAKE_CASE		,						use_auth_token=_SCREAMING_SNAKE_CASE		,						user_agent=_SCREAMING_SNAKE_CASE		,						subfolder=_SCREAMING_SNAKE_CASE		,						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."""		,						_SCREAMING_SNAKE_CASE		,						)
        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(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)} 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(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)}' so that the correct variant file can be added."""		,						_SCREAMING_SNAKE_CASE		,						)
    try:
      # 2. Load model file as usual
      lowercase__           =  hf_hub_download(
          _SCREAMING_SNAKE_CASE		,						filename=_SCREAMING_SNAKE_CASE		,						cache_dir=_SCREAMING_SNAKE_CASE		,						force_download=_SCREAMING_SNAKE_CASE		,						proxies=_SCREAMING_SNAKE_CASE		,						resume_download=_SCREAMING_SNAKE_CASE		,						local_files_only=_SCREAMING_SNAKE_CASE		,						use_auth_token=_SCREAMING_SNAKE_CASE		,						user_agent=_SCREAMING_SNAKE_CASE		,						subfolder=_SCREAMING_SNAKE_CASE		,						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}"""		)









import warnings

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


lowercase_          =		logging.get_logger(__name__)

lowercase_          =		{
    """xlnet-base-cased""": """https://huggingface.co/xlnet-base-cased/resolve/main/config.json""",
    """xlnet-large-cased""": """https://huggingface.co/xlnet-large-cased/resolve/main/config.json""",
}
class     SCREAMING_SNAKE_CASE       (UpperCAmelCase				):
   _UpperCamelCase   :		str			 =	'xlnet'
   _UpperCamelCase   :		Optional[Any]			 =	['mems']
   _UpperCamelCase   :		Union[str, Any]			 =	{
       'n_token': 'vocab_size',  # Backward compatibility
       'hidden_size': 'd_model',
       'num_attention_heads': 'n_head',
       'num_hidden_layers': 'n_layer',
   }


   def __init__(   self      :    str      ,					a      :    int=32_000      ,					a      :    Any=1_024      ,					a      :    Optional[Any]=24      ,					a      :    str=16      ,					a      :    int=4_096      ,					a      :    List[str]="gelu"      ,					a      :    Any=True      ,					a      :    Dict="bi"      ,					a      :    str=0.02      ,					a      :    List[str]=1E-1_2      ,					a      :    Tuple=0.1      ,					a      :    Optional[Any]=512      ,					a      :    Tuple=None      ,					a      :    Union[str, Any]=True      ,					a      :    int=False      ,					a      :    int=False      ,					a      :    Tuple=-1      ,					a      :    Any=False      ,					a      :    Tuple="last"      ,					a      :    List[str]=True      ,					a      :    Optional[Any]="tanh"      ,					a      :    List[Any]=0.1      ,					a      :    int=5      ,					a      :    List[Any]=5      ,					a      :    Optional[int]=5      ,					a      :    Dict=1      ,					a      :    Optional[Any]=2      ,					**a      :    List[Any]      ,					)->       List[str]:





     """simple docstring"""







     lowercase__           =  vocab_size
     lowercase__           =  d_model
     lowercase__           =  n_layer
     lowercase__           =  n_head
     if d_model % n_head != 0:
       raise ValueError(f"""'d_model % n_head' ({d_model % n_head}) should be equal to 0"""	)
     if "d_head" in kwargs:
       if kwargs["d_head"] != d_model // n_head:
         raise ValueError(
             f"""`d_head` ({kwargs["d_head"]}) should be equal to `d_model // n_head` ({d_model // n_head})"""	)
     lowercase__           =  d_model // n_head
     lowercase__           =  ff_activation
     lowercase__           =  d_inner
     lowercase__           =  untie_r
     lowercase__           =  attn_type

     lowercase__           =  initializer_range
     lowercase__           =  layer_norm_eps

     lowercase__           =  dropout
     lowercase__           =  mem_len
     lowercase__           =  reuse_len
     lowercase__           =  bi_data
     lowercase__           =  clamp_len
     lowercase__           =  same_length

     lowercase__           =  summary_type
     lowercase__           =  summary_use_proj
     lowercase__           =  summary_activation
     lowercase__           =  summary_last_dropout
     lowercase__           =  start_n_top
     lowercase__           =  end_n_top

     lowercase__           =  bos_token_id
     lowercase__           =  pad_token_id
     lowercase__           =  eos_token_id

     if "use_cache" in kwargs:
       warnings.warn(
           'The `use_cache` argument is deprecated and will be removed in a future version, use `use_mems_eval`'
           ' instead.'      ,					a      ,					)
       lowercase__           =  kwargs['use_cache']

     lowercase__           =  use_mems_eval
     lowercase__           =  use_mems_train
     super().__init__(pad_token_id=a      ,					bos_token_id=a      ,					eos_token_id=a      ,					**a	)


   @property
   def 	SCREAMING_SNAKE_CASE_							(   self      :    Optional[Any]	)->       List[str]:





     """simple docstring"""







     logger.info(f"""The model {self.model_type} is one of the few models that has no sequence length limit."""	)
     return -1


   @max_position_embeddings.setter
   def 	SCREAMING_SNAKE_CASE_							(   self      :    Tuple      ,					a      :    Union[str, Any]	)->       List[Any]:





     """simple docstring"""







     raise NotImplementedError(
         f"""The model {self.model_type} is one of the few models that has no sequence length limit."""	)


