import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, BatchEncoding, PreTrainedTokenizer
from ...utils import logging


_lowerCAmelCase       =		logging.get_logger(__name__)

_lowerCAmelCase       =		"▁"

_lowerCAmelCase       =		{"vocab_file": "sentencepiece.bpe.model"}

_lowerCAmelCase       =		{
    "vocab_file": {
        "facebook/nllb-200-distilled-600M": (
            "https://huggingface.co/facebook/nllb-200-distilled-600M/blob/main/sentencepiece.bpe.model"
        ),
    }
}

_lowerCAmelCase       =		{
    "facebook/nllb-200-distilled-600M": 1_024,
}

# fmt: off
_lowerCAmelCase       =		["ace_Arab", "ace_Latn", "acm_Arab", "acq_Arab", "aeb_Arab", "afr_Latn", "ajp_Arab", "aka_Latn", "amh_Ethi", "apc_Arab", "arb_Arab", "ars_Arab", "ary_Arab", "arz_Arab", "asm_Beng", "ast_Latn", "awa_Deva", "ayr_Latn", "azb_Arab", "azj_Latn", "bak_Cyrl", "bam_Latn", "ban_Latn", "bel_Cyrl", "bem_Latn", "ben_Beng", "bho_Deva", "bjn_Arab", "bjn_Latn", "bod_Tibt", "bos_Latn", "bug_Latn", "bul_Cyrl", "cat_Latn", "ceb_Latn", "ces_Latn", "cjk_Latn", "ckb_Arab", "crh_Latn", "cym_Latn", "dan_Latn", "deu_Latn", "dik_Latn", "dyu_Latn", "dzo_Tibt", "ell_Grek", "eng_Latn", "epo_Latn", "est_Latn", "eus_Latn", "ewe_Latn", "fao_Latn", "pes_Arab", "fij_Latn", "fin_Latn", "fon_Latn", "fra_Latn", "fur_Latn", "fuv_Latn", "gla_Latn", "gle_Latn", "glg_Latn", "grn_Latn", "guj_Gujr", "hat_Latn", "hau_Latn", "heb_Hebr", "hin_Deva", "hne_Deva", "hrv_Latn", "hun_Latn", "hye_Armn", "ibo_Latn", "ilo_Latn", "ind_Latn", "isl_Latn", "ita_Latn", "jav_Latn", "jpn_Jpan", "kab_Latn", "kac_Latn", "kam_Latn", "kan_Knda", "kas_Arab", "kas_Deva", "kat_Geor", "knc_Arab", "knc_Latn", "kaz_Cyrl", "kbp_Latn", "kea_Latn", "khm_Khmr", "kik_Latn", "kin_Latn", "kir_Cyrl", "kmb_Latn", "kon_Latn", "kor_Hang", "kmr_Latn", "lao_Laoo", "lvs_Latn", "lij_Latn", "lim_Latn", "lin_Latn", "lit_Latn", "lmo_Latn", "ltg_Latn", "ltz_Latn", "lua_Latn", "lug_Latn", "luo_Latn", "lus_Latn", "mag_Deva", "mai_Deva", "mal_Mlym", "mar_Deva", "min_Latn", "mkd_Cyrl", "plt_Latn", "mlt_Latn", "mni_Beng", "khk_Cyrl", "mos_Latn", "mri_Latn", "zsm_Latn", "mya_Mymr", "nld_Latn", "nno_Latn", "nob_Latn", "npi_Deva", "nso_Latn", "nus_Latn", "nya_Latn", "oci_Latn", "gaz_Latn", "ory_Orya", "pag_Latn", "pan_Guru", "pap_Latn", "pol_Latn", "por_Latn", "prs_Arab", "pbt_Arab", "quy_Latn", "ron_Latn", "run_Latn", "rus_Cyrl", "sag_Latn", "san_Deva", "sat_Beng", "scn_Latn", "shn_Mymr", "sin_Sinh", "slk_Latn", "slv_Latn", "smo_Latn", "sna_Latn", "snd_Arab", "som_Latn", "sot_Latn", "spa_Latn", "als_Latn", "srd_Latn", "srp_Cyrl", "ssw_Latn", "sun_Latn", "swe_Latn", "swh_Latn", "szl_Latn", "tam_Taml", "tat_Cyrl", "tel_Telu", "tgk_Cyrl", "tgl_Latn", "tha_Thai", "tir_Ethi", "taq_Latn", "taq_Tfng", "tpi_Latn", "tsn_Latn", "tso_Latn", "tuk_Latn", "tum_Latn", "tur_Latn", "twi_Latn", "tzm_Tfng", "uig_Arab", "ukr_Cyrl", "umb_Latn", "urd_Arab", "uzn_Latn", "vec_Latn", "vie_Latn", "war_Latn", "wol_Latn", "xho_Latn", "ydd_Hebr", "yor_Latn", "yue_Hant", "zho_Hans", "zho_Hant", "zul_Latn"]
class     lowerCAmelCase_     (       __lowercase ):
							UpperCAmelCase				   =     VOCAB_FILES_NAMES
							UpperCAmelCase				   =     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							UpperCAmelCase				   =     PRETRAINED_VOCAB_FILES_MAP
							UpperCAmelCase				   =     ["input_ids", "attention_mask"]

							UpperCAmelCase				   =     []
							UpperCAmelCase				   =     []







							def __init__(   self      :     int ,			_A      :     Union[str, Any] ,			_A      :     Optional[int]="<s>" ,			_A      :     str="</s>" ,			_A      :     Optional[int]="</s>" ,			_A      :     Tuple="<s>" ,			_A      :     Dict="<unk>" ,			_A      :     List[str]="<pad>" ,			_A      :     Dict="<mask>" ,			_A      :     Optional[Any]=None ,			_A      :     Union[str, Any]=None ,			_A      :     Any=None ,			_A      :     Optional[Dict[str, Any]] = None ,			_A      :     List[str]=None ,			_A      :     str=False ,			**_A      :     int ,			):
												# Mask token behave like a normal word, i.e. include the space before it
												_UpperCamelCase			     =     AddedToken(_A ,			lstrip=_A ,			rstrip=_A		) if isinstance(_A ,			_A		) else mask_token

												_UpperCamelCase			     =     {} if sp_model_kwargs is None else sp_model_kwargs
												_UpperCamelCase			     =     legacy_behaviour

												super().__init__(
												    bos_token=_A ,			eos_token=_A ,			unk_token=_A ,			sep_token=_A ,			cls_token=_A ,			pad_token=_A ,			mask_token=_A ,			tokenizer_file=_A ,			src_lang=_A ,			tgt_lang=_A ,			additional_special_tokens=_A ,			sp_model_kwargs=self.sp_model_kwargs ,			legacy_behaviour=_A ,			**_A ,			)

												_UpperCamelCase			     =     spm.SentencePieceProcessor(**self.sp_model_kwargs		)
												self.sp_model.Load(str(_A		)		)
												_UpperCamelCase			     =     vocab_file
												# Original fairseq vocab and spm vocab must be "aligned":
												# Vocab    |    0    |    1    |   2    |    3    |  4   |  5   |  6   |   7  |   8  |  9
												# -------- | ------- | ------- | ------ | ------- | ---- | ---- | ---- | ---- | ---- | ----
												# fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | 'an' | '▁n' | '▁m' | '▁t' | '▁k' | '▁a'
												# spm      | '<unk>' | '<s>'   | '</s>' | 'an'    | '▁n' | '▁m' | '▁t' | '▁k' | '▁a' | '▁s'

												# Mimic fairseq token-to-id alignment for the first 4 token
												_UpperCamelCase			     =     {'''<s>''': 0, '''<pad>''': 1, '''</s>''': 2, '''<unk>''': 3}

												# The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
												_UpperCamelCase			     =     1

												_UpperCamelCase			     =     len(self.sp_model		)
												_UpperCamelCase			     =     {
												    code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(_A		)
												}
												_UpperCamelCase			     =     {v: k for k, v in self.lang_code_to_id.items()}
												_UpperCamelCase			     =     len(self.sp_model		) + len(self.lang_code_to_id		) + self.fairseq_offset

												self.fairseq_tokens_to_ids.update(self.lang_code_to_id		)
												_UpperCamelCase			     =     {v: k for k, v in self.fairseq_tokens_to_ids.items()}
												_UpperCamelCase			     =     list(self.lang_code_to_id.keys()		)

												if additional_special_tokens is not None:
																	# Only add those special tokens if they are not already there.
																	self._additional_special_tokens.extend(
																	    [t for t in additional_special_tokens if t not in self._additional_special_tokens]		)

												_UpperCamelCase			     =     src_lang if src_lang is not None else '''eng_Latn'''
												_UpperCamelCase			     =     self.lang_code_to_id[self._src_lang]
												_UpperCamelCase			     =     tgt_lang
												self.set_src_lang_special_tokens(self._src_lang		)







							def __getstate__(   self      :     Union[str, Any]		):
												_UpperCamelCase			     =     self.__dict__.copy()
												_UpperCamelCase			     =     None
												_UpperCamelCase			     =     self.sp_model.serialized_model_proto()
												return state







							def __setstate__(   self      :     str ,			_A      :     Any		):
												_UpperCamelCase			     =     d

												# for backward compatibility
												if not hasattr(self ,			'''sp_model_kwargs'''		):
																	_UpperCamelCase			     =     {}

												_UpperCamelCase			     =     spm.SentencePieceProcessor(**self.sp_model_kwargs		)
												self.sp_model.LoadFromSerializedProto(self.sp_model_proto		)







							@property
							def  UpperCamelCase_						(   self      :     Optional[int]		):
												return len(self.sp_model		) + len(self.lang_code_to_id		) + self.fairseq_offset + 1  # Plus 1 for the mask token







							@property
							def  UpperCamelCase_						(   self      :     int		):
												return self._src_lang







							@src_lang.setter
							def  UpperCamelCase_						(   self      :     int ,			_A      :     str		):
												_UpperCamelCase			     =     new_src_lang
												self.set_src_lang_special_tokens(self._src_lang		)







							def  UpperCamelCase_						(   self      :     str ,			_A      :     List[int] ,			_A      :     Optional[List[int]] = None ,			_A      :     bool = False		):

												if already_has_special_tokens:
																	return super().get_special_tokens_mask(
																	    token_ids_a=_A ,			token_ids_a=_A ,			already_has_special_tokens=_A		)

												_UpperCamelCase			     =     [1] * len(self.prefix_tokens		)
												_UpperCamelCase			     =     [1] * len(self.suffix_tokens		)
												if token_ids_a is None:
																	return prefix_ones + ([0] * len(_A		)) + suffix_ones
												return prefix_ones + ([0] * len(_A		)) + ([0] * len(_A		)) + suffix_ones







							def  UpperCamelCase_						(   self      :     Optional[int] ,			_A      :     List[int] ,			_A      :     Optional[List[int]] = None		):
												if token_ids_a is None:
																	return self.prefix_tokens + token_ids_a + self.suffix_tokens
												# We don't expect to process pairs, but leave the pair logic for API consistency
												return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens







							def  UpperCamelCase_						(   self      :     Any ,			_A      :     List[int] ,			_A      :     Optional[List[int]] = None		):
												_UpperCamelCase			     =     [self.sep_token_id]
												_UpperCamelCase			     =     [self.cls_token_id]

												if token_ids_a is None:
																	return len(cls + token_ids_a + sep		) * [0]
												return len(cls + token_ids_a + sep + sep + token_ids_a + sep		) * [0]







							def  UpperCamelCase_						(   self      :     Optional[int] ,			_A      :     str ,			_A      :     str ,			_A      :     Optional[str] ,			_A      :     Optional[str] ,			**_A      :     Optional[int]		):
												if src_lang is None or tgt_lang is None:
																	raise ValueError('''Translation requires a `src_lang` and a `tgt_lang` for this model'''		)
												_UpperCamelCase			     =     src_lang
												_UpperCamelCase			     =     self(_A ,			add_special_tokens=_A ,			return_tensors=_A ,			**_A		)
												_UpperCamelCase			     =     self.convert_tokens_to_ids(_A		)
												_UpperCamelCase			     =     tgt_lang_id
												return inputs







							def  UpperCamelCase_						(   self      :     Union[str, Any]		):
												_UpperCamelCase			     =     {self.convert_ids_to_tokens(_A		): i for i in range(self.vocab_size		)}
												vocab.update(self.added_tokens_encoder		)
												return vocab







							def  UpperCamelCase_						(   self      :     int ,			_A      :     str		):
												return self.sp_model.encode(_A ,			out_type=_A		)







							def  UpperCamelCase_						(   self      :     List[str] ,			_A      :     Optional[int]		):
												if token in self.fairseq_tokens_to_ids:
																	return self.fairseq_tokens_to_ids[token]
												_UpperCamelCase			     =     self.sp_model.PieceToId(_A		)

												# Need to return unknown token if the SP model returned 0
												return spm_id + self.fairseq_offset if spm_id else self.unk_token_id







							def  UpperCamelCase_						(   self      :     Union[str, Any] ,			_A      :     str		):
												if index in self.fairseq_ids_to_tokens:
																	return self.fairseq_ids_to_tokens[index]
												return self.sp_model.IdToPiece(index - self.fairseq_offset		)







							def  UpperCamelCase_						(   self      :     List[Any] ,			_A      :     Dict		):
												_UpperCamelCase			     =     ''''''.join(_A		).replace(_A ,			''' '''		).strip()
												return out_string







							def  UpperCamelCase_						(   self      :     Union[str, Any] ,			_A      :     str ,			_A      :     Optional[str] = None		):
												if not os.path.isdir(_A		):
																	logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""		)
																	return
												_UpperCamelCase			     =     os.path.join(
												    _A ,			(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']		)

												if os.path.abspath(self.vocab_file		) != os.path.abspath(_A		) and os.path.isfile(self.vocab_file		):
																	copyfile(self.vocab_file ,			_A		)
												elif not os.path.isfile(self.vocab_file		):
																	with open(_A ,			'''wb'''		) as fi:
																						_UpperCamelCase			     =     self.sp_model.serialized_model_proto()
																						fi.write(_A		)

												return (out_vocab_file,)







							def  UpperCamelCase_						(   self      :     Union[str, Any] ,			_A      :     List[str] ,			_A      :     str = "eng_Latn" ,			_A      :     Optional[List[str]] = None ,			_A      :     str = "fra_Latn" ,			**_A      :     Optional[int] ,			):
												_UpperCamelCase			     =     src_lang
												_UpperCamelCase			     =     tgt_lang
												return super().prepare_seqaseq_batch(_A ,			_A ,			**_A		)







							def  UpperCamelCase_						(   self      :     Union[str, Any]		):
												return self.set_src_lang_special_tokens(self.src_lang		)







							def  UpperCamelCase_						(   self      :     Optional[int]		):
												return self.set_tgt_lang_special_tokens(self.tgt_lang		)







							def  UpperCamelCase_						(   self      :     Optional[int] ,			_A      :     Tuple		):
												_UpperCamelCase			     =     self.lang_code_to_id[src_lang]
												if self.legacy_behaviour:
																	_UpperCamelCase			     =     []
																	_UpperCamelCase			     =     [self.eos_token_id, self.cur_lang_code]
												else:
																	_UpperCamelCase			     =     [self.cur_lang_code]
																	_UpperCamelCase			     =     [self.eos_token_id]







							def  UpperCamelCase_						(   self      :     Optional[Any] ,			_A      :     str		):
												_UpperCamelCase			     =     self.lang_code_to_id[lang]
												if self.legacy_behaviour:
																	_UpperCamelCase			     =     []
																	_UpperCamelCase			     =     [self.eos_token_id, self.cur_lang_code]
												else:
																	_UpperCamelCase			     =     [self.cur_lang_code]
																	_UpperCamelCase			     =     [self.eos_token_id]

import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()
class     lowerCAmelCase_     (       __lowercase,  __lowercase,  __lowercase,  unittest.TestCase ):
							UpperCAmelCase				   =     StableUnCLIPPipeline
							UpperCAmelCase				   =     TEXT_TO_IMAGE_PARAMS
							UpperCAmelCase				   =     TEXT_TO_IMAGE_BATCH_PARAMS
							UpperCAmelCase				   =     TEXT_TO_IMAGE_IMAGE_PARAMS
							UpperCAmelCase				   =     TEXT_TO_IMAGE_IMAGE_PARAMS

							# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
							UpperCAmelCase				   =     False







							def  UpperCamelCase_						(   self      :     Optional[int]		):
												_UpperCamelCase			     =     32
												_UpperCamelCase			     =     embedder_hidden_size

												# prior components

												torch.manual_seed(0		)
												_UpperCamelCase			     =     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     CLIPTextModelWithProjection(
												    CLIPTextConfig(
												        bos_token_id=0 ,			eos_token_id=2 ,			hidden_size=_A ,			projection_dim=_A ,			intermediate_size=37 ,			layer_norm_eps=1e-05 ,			num_attention_heads=4 ,			num_hidden_layers=5 ,			pad_token_id=1 ,			vocab_size=1000 ,			)		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     PriorTransformer(
												    num_attention_heads=2 ,			attention_head_dim=12 ,			embedding_dim=_A ,			num_layers=1 ,			)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     DDPMScheduler(
												    variance_type='''fixed_small_log''' ,			prediction_type='''sample''' ,			num_train_timesteps=1000 ,			clip_sample=_A ,			clip_sample_range=5.0 ,			beta_schedule='''squaredcos_cap_v2''' ,			)

												# regular denoising components

												torch.manual_seed(0		)
												_UpperCamelCase			     =     StableUnCLIPImageNormalizer(embedding_dim=_A		)
												_UpperCamelCase			     =     DDPMScheduler(beta_schedule='''squaredcos_cap_v2'''		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     CLIPTextModel(
												    CLIPTextConfig(
												        bos_token_id=0 ,			eos_token_id=2 ,			hidden_size=_A ,			projection_dim=32 ,			intermediate_size=37 ,			layer_norm_eps=1e-05 ,			num_attention_heads=4 ,			num_hidden_layers=5 ,			pad_token_id=1 ,			vocab_size=1000 ,			)		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     UNetaDConditionModel(
												    sample_size=32 ,			in_channels=4 ,			out_channels=4 ,			down_block_types=('''CrossAttnDownBlock2D''', '''DownBlock2D''') ,			up_block_types=('''UpBlock2D''', '''CrossAttnUpBlock2D''') ,			block_out_channels=(32, 64) ,			attention_head_dim=(2, 4) ,			class_embed_type='''projection''' ,			projection_class_embeddings_input_dim=embedder_projection_dim * 2 ,			cross_attention_dim=_A ,			layers_per_block=1 ,			upcast_attention=_A ,			use_linear_projection=_A ,			)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     DDIMScheduler(
												    beta_schedule='''scaled_linear''' ,			beta_start=0.0_0085 ,			beta_end=0.012 ,			prediction_type='''v_prediction''' ,			set_alpha_to_one=_A ,			steps_offset=1 ,			)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     AutoencoderKL()

												_UpperCamelCase			     =     {
												    # prior components
												    '''prior_tokenizer''': prior_tokenizer,
												    '''prior_text_encoder''': prior_text_encoder,
												    '''prior''': prior,
												    '''prior_scheduler''': prior_scheduler,
												    # image noising components
												    '''image_normalizer''': image_normalizer,
												    '''image_noising_scheduler''': image_noising_scheduler,
												    # regular denoising components
												    '''tokenizer''': tokenizer,
												    '''text_encoder''': text_encoder,
												    '''unet''': unet,
												    '''scheduler''': scheduler,
												    '''vae''': vae,
												}

												return components







							def  UpperCamelCase_						(   self      :     Dict ,			_A      :     Tuple ,			_A      :     Dict=0		):
												if str(_A		).startswith('''mps'''		):
																	_UpperCamelCase			     =     torch.manual_seed(_A		)
												else:
																	_UpperCamelCase			     =     torch.Generator(device=_A		).manual_seed(_A		)
												_UpperCamelCase			     =     {
												    '''prompt''': '''A painting of a squirrel eating a burger''',
												    '''generator''': generator,
												    '''num_inference_steps''': 2,
												    '''prior_num_inference_steps''': 2,
												    '''output_type''': '''numpy''',
												}
												return inputs







							def  UpperCamelCase_						(   self      :     Dict		):
												_UpperCamelCase			     =     torch_device == '''cpu'''

												self._test_attention_slicing_forward_pass(test_max_difference=_A		)







							def  UpperCamelCase_						(   self      :     List[Any]		):
												_UpperCamelCase			     =     torch_device in ['''cpu''', '''mps''']

												self._test_inference_batch_single_identical(test_max_difference=_A		)




@slow
@require_torch_gpu
class     lowerCAmelCase_     (       unittest.TestCase ):







							def  UpperCamelCase_						(   self      :     Optional[Any]		):
												# clean up the VRAM after each test
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()







							def  UpperCamelCase_						(   self      :     List[str]		):
												_UpperCamelCase			     =     load_numpy(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy'''		)

												_UpperCamelCase			     =     StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l''' ,			torch_dtype=torch.floataa		)
												pipe.to(_A		)
												pipe.set_progress_bar_config(disable=_A		)
												# stable unclip will oom when integration tests are run on a V100,
												# so turn on memory savings
												pipe.enable_attention_slicing()
												pipe.enable_sequential_cpu_offload()

												_UpperCamelCase			     =     torch.Generator(device='''cpu'''		).manual_seed(0		)
												_UpperCamelCase			     =     pipe('''anime turle''' ,			generator=_A ,			output_type='''np'''		)

												_UpperCamelCase			     =     output.images[0]

												assert image.shape == (768, 768, 3)

												assert_mean_pixel_difference(_A ,			_A		)







							def  UpperCamelCase_						(   self      :     Optional[Any]		):
												torch.cuda.empty_cache()
												torch.cuda.reset_max_memory_allocated()
												torch.cuda.reset_peak_memory_stats()

												_UpperCamelCase			     =     StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l''' ,			torch_dtype=torch.floataa		)
												_UpperCamelCase			     =     pipe.to(_A		)
												pipe.set_progress_bar_config(disable=_A		)
												pipe.enable_attention_slicing()
												pipe.enable_sequential_cpu_offload()

												_UpperCamelCase			     =     pipe(
												    '''anime turtle''' ,			prior_num_inference_steps=2 ,			num_inference_steps=2 ,			output_type='''np''' ,			)

												_UpperCamelCase			     =     torch.cuda.max_memory_allocated()
												# make sure that less than 7 GB is allocated
												assert mem_bytes < 7 * 10**9
