






"""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 _lowerCAmelCase	(  __lowerCamelCase:Union[Dict, str, None] = None   ):

						'''simple docstring'''






						__magic_name__            =     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 _lowerCAmelCase	(  __lowerCamelCase:str ,						__lowerCamelCase:Optional[str] = None ,						__lowerCamelCase:Optional[str] = None   ):

						'''simple docstring'''






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






def _lowerCAmelCase	(  __lowerCamelCase:int ,						__lowerCamelCase:Optional[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

						__magic_name__            =     args.hub_token if hasattr(_SCREAMING_SNAKE_CASE ,						"hub_token"   ) else None
						__magic_name__            =     get_full_repo_name(_SCREAMING_SNAKE_CASE ,						token=_SCREAMING_SNAKE_CASE   )

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

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






def _lowerCAmelCase	(  __lowerCamelCase:Optional[str] ,						__lowerCamelCase:Optional[str] = None   ):

						'''simple docstring'''






						if resolved_file is None or commit_hash is not None:
												return commit_hash
						__magic_name__            =     str(Path(_SCREAMING_SNAKE_CASE   ).as_posix()   )
						__magic_name__            =     re.search(r"snapshots/([^/]+)/" ,						_SCREAMING_SNAKE_CASE   )
						if search is None:
												return None
						__magic_name__            =     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 _lowerCAmelCase	(  __lowerCamelCase:Optional[str] = None ,						__lowerCamelCase:Optional[str] = None   ):

						'''simple docstring'''






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

						__magic_name__            =     Path(_SCREAMING_SNAKE_CASE   ).expanduser()
						__magic_name__            =     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():
																		__magic_name__            =     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 _lowerCAmelCase	(  __lowerCamelCase:str ,						__lowerCamelCase:Optional[str] = None   ):

						'''simple docstring'''






						if variant is not None:
												__magic_name__            =     weights_name.split("."   )
												__magic_name__            =     splits[:-1] + [variant] + splits[-1:]
												__magic_name__            =     ".".join(_SCREAMING_SNAKE_CASE   )

						return weights_name






def _lowerCAmelCase	(  __lowerCamelCase:str ,						*,
    __lowerCamelCase:Tuple ,						__lowerCamelCase:Optional[Any] ,						__lowerCamelCase:int ,						__lowerCamelCase:str ,						__lowerCamelCase:Union[str, Any] ,						__lowerCamelCase:Any ,						__lowerCamelCase:str ,						__lowerCamelCase:int ,						__lowerCamelCase:Tuple ,						__lowerCamelCase:str ,						__lowerCamelCase:List[Any]=None ,						):

						'''simple docstring'''






						__magic_name__            =     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
																		__magic_name__            =     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   )   ):
																		__magic_name__            =     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:
																								__magic_name__            =     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
																		__magic_name__            =     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"""

import unittest

import numpy as np
import torch
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyVaaPriorPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()

class 						A_							(      snake_case_					,							unittest.TestCase  ):
				UpperCAmelCase__        =				KandinskyVaaPriorPipeline
				UpperCAmelCase__        =				['''prompt''']
				UpperCAmelCase__        =				['''prompt''', '''negative_prompt''']
				UpperCAmelCase__        =				[
				    '''num_images_per_prompt''',
				    '''generator''',
				    '''num_inference_steps''',
				    '''latents''',
				    '''negative_prompt''',
				    '''guidance_scale''',
				    '''output_type''',
				    '''return_dict''',
				]
				UpperCAmelCase__        =				False







				@property
				def     _snake_case					(							self							:						Dict	)				->					Dict:
										return 3_2







				@property
				def     _snake_case					(							self							:						Tuple	)				->					Tuple:
										return 3_2







				@property
				def     _snake_case					(							self							:						Dict	)				->					Optional[int]:
										return self.time_input_dim







				@property
				def     _snake_case					(							self							:						List[Any]	)				->					str:
										return self.time_input_dim * 4







				@property
				def     _snake_case					(							self							:						List[str]	)				->					List[Any]:
										return 1_0_0







				@property
				def     _snake_case					(							self							:						List[str]	)				->					Tuple:
										__magic_name__            =     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)
										return tokenizer







				@property
				def     _snake_case					(							self							:						Optional[int]	)				->					Optional[int]:
										torch.manual_seed(0	)
										__magic_name__            =     CLIPTextConfig(
										    bos_token_id=0						,    eos_token_id=2						,    hidden_size=self.text_embedder_hidden_size						,    projection_dim=self.text_embedder_hidden_size						,    intermediate_size=3_7						,    layer_norm_eps=1e-05						,    num_attention_heads=4						,    num_hidden_layers=5						,    pad_token_id=1						,    vocab_size=1_0_0_0						,    )
										return CLIPTextModelWithProjection(__lowerCamelCase	)







				@property
				def     _snake_case					(							self							:						List[str]	)				->					Union[str, Any]:
										torch.manual_seed(0	)

										__magic_name__            =     {
										    "num_attention_heads": 2,
										    "attention_head_dim": 1_2,
										    "embedding_dim": self.text_embedder_hidden_size,
										    "num_layers": 1,
										}

										__magic_name__            =     PriorTransformer(**__lowerCamelCase	)
										# clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
										__magic_name__            =     nn.Parameter(torch.ones(model.clip_std.shape	)	)
										return model







				@property
				def     _snake_case					(							self							:						Union[str, Any]	)				->					Union[str, Any]:
										torch.manual_seed(0	)
										__magic_name__            =     CLIPVisionConfig(
										    hidden_size=self.text_embedder_hidden_size						,    image_size=2_2_4						,    projection_dim=self.text_embedder_hidden_size						,    intermediate_size=3_7						,    num_attention_heads=4						,    num_channels=3						,    num_hidden_layers=5						,    patch_size=1_4						,    )

										__magic_name__            =     CLIPVisionModelWithProjection(__lowerCamelCase	)
										return model







				@property
				def     _snake_case					(							self							:						Union[str, Any]	)				->					int:
										__magic_name__            =     CLIPImageProcessor(
										    crop_size=2_2_4						,    do_center_crop=__lowerCamelCase						,    do_normalize=__lowerCamelCase						,    do_resize=__lowerCamelCase						,    image_mean=[0.4814_5466, 0.457_8275, 0.4082_1073]						,    image_std=[0.2686_2954, 0.2613_0258, 0.2757_7711]						,    resample=3						,    size=2_2_4						,    )

										return image_processor







				def     _snake_case					(							self							:						List[Any]	)				->					Optional[Any]:
										__magic_name__            =     self.dummy_prior
										__magic_name__            =     self.dummy_image_encoder
										__magic_name__            =     self.dummy_text_encoder
										__magic_name__            =     self.dummy_tokenizer
										__magic_name__            =     self.dummy_image_processor

										__magic_name__            =     UnCLIPScheduler(
										    variance_type="fixed_small_log"						,    prediction_type="sample"						,    num_train_timesteps=1_0_0_0						,    clip_sample=__lowerCamelCase						,    clip_sample_range=10.0						,    )

										__magic_name__            =     {
										    "prior": prior,
										    "image_encoder": image_encoder,
										    "text_encoder": text_encoder,
										    "tokenizer": tokenizer,
										    "scheduler": scheduler,
										    "image_processor": image_processor,
										}

										return components







				def     _snake_case					(							self							:						int						,    __lowerCamelCase							:						List[Any]						,    __lowerCamelCase							:						str=0	)				->					Optional[int]:
										if str(__lowerCamelCase	).startswith("mps"	):
																__magic_name__            =     torch.manual_seed(__lowerCamelCase	)
										else:
																__magic_name__            =     torch.Generator(device=__lowerCamelCase	).manual_seed(__lowerCamelCase	)
										__magic_name__            =     {
										    "prompt": "horse",
										    "generator": generator,
										    "guidance_scale": 4.0,
										    "num_inference_steps": 2,
										    "output_type": "np",
										}
										return inputs







				def     _snake_case					(							self							:						Optional[Any]	)				->					Optional[Any]:
										__magic_name__            =     "cpu"

										__magic_name__            =     self.get_dummy_components()

										__magic_name__            =     self.pipeline_class(**__lowerCamelCase	)
										__magic_name__            =     pipe.to(__lowerCamelCase	)

										pipe.set_progress_bar_config(disable=__lowerCamelCase	)

										__magic_name__            =     pipe(**self.get_dummy_inputs(__lowerCamelCase	)	)
										__magic_name__            =     output.image_embeds

										__magic_name__            =     pipe(
										    **self.get_dummy_inputs(__lowerCamelCase	)						,    return_dict=__lowerCamelCase						,    )[0]

										__magic_name__            =     image[0, -1_0:]
										__magic_name__            =     image_from_tuple[0, -1_0:]

										assert image.shape == (1, 3_2)

										__magic_name__            =     np.array(
										    [-0.0532, 1.7120, 0.3656, -1.0852, -0.8946, -1.1756, 0.4348, 0.2482, 0.5146, -0.1156]	)

										assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
										assert np.abs(image_from_tuple_slice.flatten() - expected_slice	).max() < 1e-2







				@skip_mps
				def     _snake_case					(							self							:						Dict	)				->					List[str]:
										__magic_name__            =     torch_device == "cpu"
										__magic_name__            =     True
										__magic_name__            =     False

										self._test_inference_batch_single_identical(
										    test_max_difference=__lowerCamelCase						,    relax_max_difference=__lowerCamelCase						,    test_mean_pixel_difference=__lowerCamelCase						,    )







				@skip_mps
				def     _snake_case					(							self							:						Tuple	)				->					Tuple:
										__magic_name__            =     torch_device == "cpu"
										__magic_name__            =     False

										self._test_attention_slicing_forward_pass(
										    test_max_difference=__lowerCamelCase						,    test_mean_pixel_difference=__lowerCamelCase						,    )



