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


__A     = get_logger(__name__)


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


def       lowercase_      (      _lowerCamelCase:		Any = None					)       ->					str:



							'''simple docstring'''

							__lowerCamelCase    :						List[str]						      =   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       lowercase_      (      _lowerCamelCase:		str  ,      _lowerCamelCase:		Any = None  ,      _lowerCamelCase:		Dict = None					)       ->					int:



							'''simple docstring'''

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


def       lowercase_      (      _lowerCamelCase:		Optional[int]  ,      _lowerCamelCase:		Optional[Any]					)       ->					Union[str, Any]:



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

							__lowerCamelCase    :						Optional[Any]						      =   args.hub_token if hasattr(_SCREAMING_SNAKE_CASE  ,      "hub_token"					) else None
							__lowerCamelCase    :						Tuple						      =   get_full_repo_name(_SCREAMING_SNAKE_CASE  ,      token=_SCREAMING_SNAKE_CASE					)

							__lowerCamelCase    :						Tuple						      =   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  ,      )

							__lowerCamelCase    :						Tuple						      =   os.path.join(args.output_dir  ,      "README.md"					)
							model_card.save(_SCREAMING_SNAKE_CASE					)


def       lowercase_      (      _lowerCamelCase:		Dict  ,      _lowerCamelCase:		Dict = None					)       ->					int:



							'''simple docstring'''

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


def       lowercase_      (      _lowerCamelCase:		Tuple = None  ,      _lowerCamelCase:		Tuple = None					)       ->					None:



							'''simple docstring'''

							if new_cache_dir is None:
														__lowerCamelCase    :						Optional[Any]						      =   DIFFUSERS_CACHE
							if old_cache_dir is None:
														__lowerCamelCase    :						Tuple						      =   old_diffusers_cache

							__lowerCamelCase    :						Optional[int]						      =   Path(_SCREAMING_SNAKE_CASE					).expanduser()
							__lowerCamelCase    :						int						      =   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():
																					__lowerCamelCase    :						Any						      =   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).


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

if cache_version < 1:
				__A     = 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     = '''\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       lowercase_      (      _lowerCamelCase:		List[Any]  ,      _lowerCamelCase:		Optional[Any] = None					)       ->					str:



							'''simple docstring'''

							if variant is not None:
														__lowerCamelCase    :						int						      =   weights_name.split("."					)
														__lowerCamelCase    :						Optional[Any]						      =   splits[:-1] + [variant] + splits[-1:]
														__lowerCamelCase    :						Tuple						      =   '.'.join(_SCREAMING_SNAKE_CASE					)

							return weights_name







def       lowercase_      (      _lowerCamelCase:		List[str]  ,      *,
    _lowerCamelCase:		List[Any]  ,      _lowerCamelCase:		Dict  ,      _lowerCamelCase:		Optional[int]  ,      _lowerCamelCase:		Optional[int]  ,      _lowerCamelCase:		List[str]  ,      _lowerCamelCase:		List[Any]  ,      _lowerCamelCase:		List[str]  ,      _lowerCamelCase:		int  ,      _lowerCamelCase:		Union[str, Any]  ,      _lowerCamelCase:		List[Any]  ,      _lowerCamelCase:		str=None  ,      )       ->					Dict:



							'''simple docstring'''

							__lowerCamelCase    :						Optional[Any]						      =   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
																					__lowerCamelCase    :						int						      =   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					)					):
																					__lowerCamelCase    :						Dict						      =   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:
																												__lowerCamelCase    :						Optional[int]						      =   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
																					__lowerCamelCase    :						int						      =   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}"""					)






"""simple docstring"""





def  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			)					->float:





  """simple docstring"""


  if discount_rate < 0:
    raise ValueError('Discount rate cannot be negative'			)
  if not cash_flows:
    raise ValueError('Cash flows list cannot be empty'			)
  lowerCAmelCase__			:Union[str, Any]											=							sum(
      cash_flow / ((1 + discount_rate) ** i) for i, cash_flow in enumerate(_SCREAMING_SNAKE_CASE			)			)
  return round(_SCREAMING_SNAKE_CASE     ,   ndigits=2			)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
