





"""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      __A   (      a_    :Union[Dict, str, None] = None)		->		str:
				__a			:    Union[str, Any]      							=	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(a_ ,							a_):
								ua += "; " + "; ".join(F"""{k}/{v}""" for k, v in user_agent.items())
				elif isinstance(a_ ,							a_):
								ua += "; " + user_agent
				return ua

def      __A   (      a_    :str ,							a_    :Optional[str] = None ,							a_    :Optional[str] = None)		->		Optional[int]:
				if token is None:
								__a			:    Any      							=	HfFolder.get_token()
				if organization is None:
								__a			:    List[Any]      							=	whoami(a_)['''name''']
								return F"""{username}/{model_id}"""
				else:
								return F"""{organization}/{model_id}"""

def      __A   (      a_    :Union[str, Any] ,							a_    :List[str])		->		Optional[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(a_ ,							'''local_rank''') and args.local_rank not in [-1, 0]:
								return

				__a			:    int      							=	args.hub_token if hasattr(a_ ,							'''hub_token''') else None
				__a			:    Any      							=	get_full_repo_name(a_ ,							token=a_)

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

				__a			:    List[Any]      							=	os.path.join(args.output_dir ,							'''README.md''')
				model_card.save(a_)

def      __A   (      a_    :Optional[str] ,							a_    :Optional[str] = None)		->		Union[str, Any]:
				if resolved_file is None or commit_hash is not None:
								return commit_hash
				__a			:    Any      							=	str(Path(a_).as_posix())
				__a			:    Optional[int]      							=	re.search(R'''snapshots/([^/]+)/''' ,							a_)
				if search is None:
								return None
				__a			:    Dict      							=	search.groups()[0]
				return commit_hash if REGEX_COMMIT_HASH.match(a_) 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      __A   (      a_    :Optional[str] = None ,							a_    :Optional[str] = None)		->		None:
				if new_cache_dir is None:
								__a			:    Dict      							=	DIFFUSERS_CACHE
				if old_cache_dir is None:
								__a			:    List[Any]      							=	old_diffusers_cache

				__a			:    Union[str, Any]      							=	Path(a_).expanduser()
				__a			:    Dict      							=	Path(a_).expanduser()
				for old_blob_path in old_cache_dir.glob('''**/blobs/*'''):
								if old_blob_path.is_file() and not old_blob_path.is_symlink():
												__a			:    List[Any]      							=	new_cache_dir / old_blob_path.relative_to(a_)
												new_blob_path.parent.mkdir(parents=a_ ,							exist_ok=a_)
												os.replace(a_ ,							a_)
												try:
																os.symlink(a_ ,							a_)
												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      __A   (      a_    :str ,							a_    :Optional[str] = None)		->		str:
				if variant is not None:
								__a			:    Dict      							=	weights_name.split('''.''')
								__a			:    List[Any]      							=	splits[:-1] + [variant] + splits[-1:]
								__a			:    Tuple      							=	'''.'''.join(a_)

				return weights_name






def      __A   (      a_    :List[Any] ,							*,
    a_    :Union[str, Any] ,							a_    :Dict ,							a_    :Union[str, Any] ,							a_    :Optional[int] ,							a_    :str ,							a_    :Any ,							a_    :str ,							a_    :Optional[int] ,							a_    :str ,							a_    :Tuple ,							a_    :List[str]=None ,							)		->		Dict:
				__a			:    int      							=	str(a_)
				if os.path.isfile(a_):
								return pretrained_model_name_or_path
				elif os.path.isdir(a_):
								if os.path.isfile(os.path.join(a_ ,							a_)):
												# Load from a PyTorch checkpoint
												__a			:    Union[str, Any]      							=	os.path.join(a_ ,							a_)
												return model_file
								elif subfolder is not None and os.path.isfile(
								    os.path.join(a_ ,							a_ ,							a_)):
												__a			:    Optional[Any]      							=	os.path.join(a_ ,							a_ ,							a_)
												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(a_).base_version) >= version.parse('''0.20.0''')
								):
												try:
																__a			:    Any      							=	hf_hub_download(
																    a_ ,							filename=_add_variant(a_ ,							a_) ,							cache_dir=a_ ,							force_download=a_ ,							proxies=a_ ,							resume_download=a_ ,							local_files_only=a_ ,							use_auth_token=a_ ,							user_agent=a_ ,							subfolder=a_ ,							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.""" ,							a_ ,							)
																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(a_ ,							a_)} 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(a_ ,							a_)}' so that the correct variant file can be added.""" ,							a_ ,							)
								try:
												# 2. Load model file as usual
												__a			:    Optional[Any]      							=	hf_hub_download(
												    a_ ,							filename=a_ ,							cache_dir=a_ ,							force_download=a_ ,							proxies=a_ ,							resume_download=a_ ,							local_files_only=a_ ,							use_auth_token=a_ ,							user_agent=a_ ,							subfolder=a_ ,							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 math import pi, sqrt, tan






def       lowercase					(_A       ):







       """simple docstring"""







       if side_length < 0:
              raise ValueError('surface_area_cube() only accepts non-negative values'       )
       return 6 * side_length**2






def       lowercase					(_A ,    _A ,    _A       ):







       """simple docstring"""







       if length < 0 or breadth < 0 or height < 0:
              raise ValueError('surface_area_cuboid() only accepts non-negative values'       )
       return 2 * ((length * breadth) + (breadth * height) + (length * height))






def       lowercase					(_A       ):







       """simple docstring"""







       if radius < 0:
              raise ValueError('surface_area_sphere() only accepts non-negative values'       )
       return 4 * pi * radius**2






def       lowercase					(_A       ):







       """simple docstring"""







       if radius < 0:
              raise ValueError('surface_area_hemisphere() only accepts non-negative values'       )
       return 3 * pi * radius**2






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if radius < 0 or height < 0:
              raise ValueError('surface_area_cone() only accepts non-negative values'       )
       return pi * radius * (radius + (height**2 + radius**2) ** 0.5)






def       lowercase					(_A ,    _A ,    _A       ):







       """simple docstring"""







       if radius_a < 0 or radius_a < 0 or height < 0:
              raise ValueError(
                  'surface_area_conical_frustum() only accepts non-negative values'       )
       _lowerCAmelCase     :				int       =							(height**2 + (radius_a - radius_a) ** 2) ** 0.5
       return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if radius < 0 or height < 0:
              raise ValueError('surface_area_cylinder() only accepts non-negative values'       )
       return 2 * pi * radius * (height + radius)






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if torus_radius < 0 or tube_radius < 0:
              raise ValueError('surface_area_torus() only accepts non-negative values'       )
       if torus_radius < tube_radius:
              raise ValueError(
                  'surface_area_torus() does not support spindle or self intersecting tori'       )
       return 4 * pow(_A ,    2       ) * torus_radius * tube_radius






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if length < 0 or width < 0:
              raise ValueError('area_rectangle() only accepts non-negative values'       )
       return length * width






def       lowercase					(_A       ):







       """simple docstring"""







       if side_length < 0:
              raise ValueError('area_square() only accepts non-negative values'       )
       return side_length**2






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if base < 0 or height < 0:
              raise ValueError('area_triangle() only accepts non-negative values'       )
       return (base * height) / 2






def       lowercase					(_A ,    _A ,    _A       ):







       """simple docstring"""







       if sidea < 0 or sidea < 0 or sidea < 0:
              raise ValueError('area_triangle_three_sides() only accepts non-negative values'       )
       elif sidea + sidea < sidea or sidea + sidea < sidea or sidea + sidea < sidea:
              raise ValueError('Given three sides do not form a triangle'       )
       _lowerCAmelCase     :				Tuple       =							(sidea + sidea + sidea) / 2
       _lowerCAmelCase     :				Dict       =							sqrt(
           semi_perimeter
           * (semi_perimeter - sidea)
           * (semi_perimeter - sidea)
           * (semi_perimeter - sidea)       )
       return area






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if base < 0 or height < 0:
              raise ValueError('area_parallelogram() only accepts non-negative values'       )
       return base * height






def       lowercase					(_A ,    _A ,    _A       ):







       """simple docstring"""







       if basea < 0 or basea < 0 or height < 0:
              raise ValueError('area_trapezium() only accepts non-negative values'       )
       return 1 / 2 * (basea + basea) * height






def       lowercase					(_A       ):







       """simple docstring"""







       if radius < 0:
              raise ValueError('area_circle() only accepts non-negative values'       )
       return pi * radius**2






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if radius_x < 0 or radius_y < 0:
              raise ValueError('area_ellipse() only accepts non-negative values'       )
       return pi * radius_x * radius_y






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if diagonal_a < 0 or diagonal_a < 0:
              raise ValueError('area_rhombus() only accepts non-negative values'       )
       return 1 / 2 * diagonal_a * diagonal_a






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if not isinstance(_A ,    _A       ) or sides < 3:
              raise ValueError(
                  'area_reg_polygon() only accepts integers greater than or \
equal to three as number of sides'       )
       elif length < 0:
              raise ValueError(
                  'area_reg_polygon() only accepts non-negative values as \
length of a side'       )
       return (sides * length**2) / (4 * tan(pi / sides       ))
       return (sides * length**2) / (4 * tan(pi / sides       ))


if __name__ == "__main__":
       import doctest

       doctest.testmod(verbose=True)  # verbose so we can see methods missing tests

       print("""[DEMO] Areas of various geometric shapes: \n""")
       print(F'''Rectangle: {area_rectangle(10, 20) = }''')
       print(F'''Square: {area_square(10) = }''')
       print(F'''Triangle: {area_triangle(10, 10) = }''')
       print(F'''Triangle: {area_triangle_three_sides(5, 12, 13) = }''')
       print(F'''Parallelogram: {area_parallelogram(10, 20) = }''')
       print(F'''Rhombus: {area_rhombus(10, 20) = }''')
       print(F'''Trapezium: {area_trapezium(10, 20, 30) = }''')
       print(F'''Circle: {area_circle(20) = }''')
       print(F'''Ellipse: {area_ellipse(10, 20) = }''')
       print("""\nSurface Areas of various geometric shapes: \n""")
       print(F'''Cube: {surface_area_cube(20) = }''')
       print(F'''Cuboid: {surface_area_cuboid(10, 20, 30) = }''')
       print(F'''Sphere: {surface_area_sphere(20) = }''')
       print(F'''Hemisphere: {surface_area_hemisphere(20) = }''')
       print(F'''Cone: {surface_area_cone(10, 20) = }''')
       print(F'''Conical Frustum: {surface_area_conical_frustum(10, 20, 30) = }''')
       print(F'''Cylinder: {surface_area_cylinder(10, 20) = }''')
       print(F'''Torus: {surface_area_torus(20, 10) = }''')
       print(F'''Equilateral Triangle: {area_reg_polygon(3, 10) = }''')
       print(F'''Square: {area_reg_polygon(4, 10) = }''')
       print(F'''Reqular Pentagon: {area_reg_polygon(5, 10) = }''')

