





'''simple docstring'''





import itertools
import json
import os
import unittest

from transformers import AddedToken, LongformerTokenizer, LongformerTokenizerFast
from transformers.models.longformer.tokenization_longformer import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class    _UpperCAmelCase							(		_lowerCamelCase			,       unittest.TestCase     ):
      a						       =							LongformerTokenizer
      a						       =							True
      a						       =							LongformerTokenizerFast
      a						       =							True
      def 		_lowerCamelCase      (		self       ):
         super().setUp()

         # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
         A_     :				str			      =	[
             """l""",
             """o""",
             """w""",
             """e""",
             """r""",
             """s""",
             """t""",
             """i""",
             """d""",
             """n""",
             """\u0120""",
             """\u0120l""",
             """\u0120n""",
             """\u0120lo""",
             """\u0120low""",
             """er""",
             """\u0120lowest""",
             """\u0120newer""",
             """\u0120wider""",
             """<unk>""",
         ]
         A_     :				List[str]			      =	dict(zip(a__      ,       range(len(a__       )       )       )       )
         A_     :				Union[str, Any]			      =	["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
         A_     :				Union[str, Any]			      =	{"""unk_token""": """<unk>"""}

         A_     :				int			      =	os.path.join(self.tmpdirname      ,       VOCAB_FILES_NAMES["""vocab_file"""]       )
         A_     :				int			      =	os.path.join(self.tmpdirname      ,       VOCAB_FILES_NAMES["""merges_file"""]       )
         with open(self.vocab_file      ,       """w"""      ,       encoding="""utf-8"""       ) as fp:
            fp.write(json.dumps(a__       ) + """\n"""       )
         with open(self.merges_file      ,       """w"""      ,       encoding="""utf-8"""       ) as fp:
            fp.write("""\n""".join(a__       )       )
      def 		_lowerCamelCase      (		self      ,       **a__       ):
         kwargs.update(self.special_tokens_map       )
         return self.tokenizer_class.from_pretrained(self.tmpdirname      ,       **a__       )
      def 		_lowerCamelCase      (		self      ,       **a__       ):
         kwargs.update(self.special_tokens_map       )
         return self.rust_tokenizer_class.from_pretrained(self.tmpdirname      ,       **a__       )
      def 		_lowerCamelCase      (		self      ,       a__       ):
         A_     :				Dict			      =	"""lower newer"""
         A_     :				Optional[Any]			      =	"""lower newer"""
         return input_text, output_text
      def 		_lowerCamelCase      (		self       ):
         A_     :				str			      =	self.tokenizer_class(self.vocab_file      ,       self.merges_file      ,       **self.special_tokens_map       )
         A_     :				Tuple			      =	"""lower newer"""
         A_     :				str			      =	["""l""", """o""", """w""", """er""", """\u0120""", """n""", """e""", """w""", """er"""]
         A_     :				Union[str, Any]			      =	tokenizer.tokenize(a__       )  # , add_prefix_space=True)
         self.assertListEqual(a__      ,       a__       )

         A_     :				Union[str, Any]			      =	tokens + [tokenizer.unk_token]
         A_     :				str			      =	[0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
         self.assertListEqual(tokenizer.convert_tokens_to_ids(a__       )      ,       a__       )
      def 		_lowerCamelCase      (		self       ):
         A_     :				Optional[int]			      =	self.get_tokenizer()

         self.assertListEqual(tokenizer.encode("""Hello world!"""      ,       add_special_tokens=a__       )      ,       [0, 31414, 232, 328, 2]       )
         self.assertListEqual(
             tokenizer.encode("""Hello world! cécé herlolip 418"""      ,       add_special_tokens=a__       )      ,       [0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]      ,       )
      @slow
      def 		_lowerCamelCase      (		self       ):
         A_     :				Optional[Any]			      =	self.tokenizer_class.from_pretrained("""allenai/longformer-base-4096"""       )

         A_     :				Optional[Any]			      =	tokenizer.encode("""sequence builders"""      ,       add_special_tokens=a__       )
         A_     :				Optional[Any]			      =	tokenizer.encode("""multi-sequence build"""      ,       add_special_tokens=a__       )

         A_     :				Tuple			      =	tokenizer.encode(
             """sequence builders"""      ,       add_special_tokens=a__      ,       add_prefix_space=a__       )
         A_     :				List[str]			      =	tokenizer.encode(
             """sequence builders"""      ,       """multi-sequence build"""      ,       add_special_tokens=a__      ,       add_prefix_space=a__       )

         A_     :				str			      =	tokenizer.build_inputs_with_special_tokens(a__       )
         A_     :				Union[str, Any]			      =	tokenizer.build_inputs_with_special_tokens(a__      ,       a__       )

         assert encoded_sentence == encoded_text_from_decode
         assert encoded_pair == encoded_pair_from_decode
      def 		_lowerCamelCase      (		self       ):
         A_     :				Dict			      =	self.get_tokenizer()

         A_     :				int			      =	"""Encode this sequence."""
         A_     :				Tuple			      =	tokenizer.byte_encoder[""" """.encode("""utf-8"""       )[0]]

         # Testing encoder arguments
         A_     :				List[Any]			      =	tokenizer.encode(a__      ,       add_special_tokens=a__      ,       add_prefix_space=a__       )
         A_     :				str			      =	tokenizer.convert_ids_to_tokens(encoded[0]       )[0]
         self.assertNotEqual(a__      ,       a__       )

         A_     :				Optional[Any]			      =	tokenizer.encode(a__      ,       add_special_tokens=a__      ,       add_prefix_space=a__       )
         A_     :				Tuple			      =	tokenizer.convert_ids_to_tokens(encoded[0]       )[0]
         self.assertEqual(a__      ,       a__       )

         tokenizer.add_special_tokens({"""bos_token""": """<s>"""}       )
         A_     :				Tuple			      =	tokenizer.encode(a__      ,       add_special_tokens=a__       )
         A_     :				Any			      =	tokenizer.convert_ids_to_tokens(encoded[1]       )[0]
         self.assertNotEqual(a__      ,       a__       )

         # Testing spaces after special tokens
         A_     :				Union[str, Any]			      =	"""<mask>"""
         tokenizer.add_special_tokens(
             {"""mask_token""": AddedToken(a__      ,       lstrip=a__      ,       rstrip=a__       )}       )  # mask token has a left space
         A_     :				List[Any]			      =	tokenizer.convert_tokens_to_ids(a__       )

         A_     :				str			      =	"""Encode <mask> sequence"""
         A_     :				Any			      =	"""Encode <mask>sequence"""

         A_     :				List[str]			      =	tokenizer.encode(a__       )
         A_     :				str			      =	encoded.index(a__       )
         A_     :				str			      =	tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]       )[0]
         self.assertEqual(a__      ,       a__       )

         A_     :				List[str]			      =	tokenizer.encode(a__       )
         A_     :				Dict			      =	encoded.index(a__       )
         A_     :				Union[str, Any]			      =	tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]       )[0]
         self.assertNotEqual(a__      ,       a__       )
      def 		_lowerCamelCase      (		self       ):
         pass
      def 		_lowerCamelCase      (		self       ):
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""       ):
               A_     :				Union[str, Any]			      =	self.rust_tokenizer_class.from_pretrained(a__      ,       **a__       )
               A_     :				Union[str, Any]			      =	self.tokenizer_class.from_pretrained(a__      ,       **a__       )
               A_     :				Optional[int]			      =	"""A, <mask> AllenNLP sentence."""
               A_     :				Optional[int]			      =	tokenizer_r.encode_plus(a__      ,       add_special_tokens=a__      ,       return_token_type_ids=a__       )
               A_     :				List[str]			      =	tokenizer_p.encode_plus(a__      ,       add_special_tokens=a__      ,       return_token_type_ids=a__       )

               # token_type_ids should put 0 everywhere
               self.assertEqual(sum(tokens_r["""token_type_ids"""]       )      ,       sum(tokens_p["""token_type_ids"""]       )       )

               # attention_mask should put 1 everywhere, so sum over length should be 1
               self.assertEqual(
                   sum(tokens_r["""attention_mask"""]       ) / len(tokens_r["""attention_mask"""]       )      ,       sum(tokens_p["""attention_mask"""]       ) / len(tokens_p["""attention_mask"""]       )      ,       )

               A_     :				int			      =	tokenizer_r.convert_ids_to_tokens(tokens_r["""input_ids"""]       )
               A_     :				Optional[Any]			      =	tokenizer_p.convert_ids_to_tokens(tokens_p["""input_ids"""]       )

               # Rust correctly handles the space before the mask while python doesnt
               self.assertSequenceEqual(tokens_p["""input_ids"""]      ,       [0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2]       )
               self.assertSequenceEqual(tokens_r["""input_ids"""]      ,       [0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2]       )

               self.assertSequenceEqual(
                   a__      ,       ["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]       )
               self.assertSequenceEqual(
                   a__      ,       ["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]       )
      def 		_lowerCamelCase      (		self       ):
         for trim_offsets, add_prefix_space in itertools.product([True, False]      ,       repeat=2       ):
            A_     :				Dict			      =	self.rust_tokenizer_class.from_pretrained(
                self.tmpdirname      ,       use_fast=a__      ,       add_prefix_space=a__      ,       trim_offsets=a__       )

            A_     :				Dict			      =	json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()       )
            A_     :				Optional[int]			      =	json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()       )

            self.assertEqual(pre_tokenizer_state["""add_prefix_space"""]      ,       a__       )

            self.assertEqual(post_processor_state["""add_prefix_space"""]      ,       a__       )
            self.assertEqual(post_processor_state["""trim_offsets"""]      ,       a__       )






      def 		_lowerCamelCase      (		self       ):
         # Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space` and
         # `trim_offsets`
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""       ):
               A_     :				Tuple			      =	"""hello"""  # `hello` is a token in the vocabulary of `pretrained_name`
               A_     :				Optional[Any]			      =	F"""{text_of_1_token} {text_of_1_token}"""

               A_     :				List[str]			      =	self.rust_tokenizer_class.from_pretrained(
                   a__      ,       use_fast=a__      ,       add_prefix_space=a__      ,       trim_offsets=a__       )
               A_     :				Optional[Any]			      =	tokenizer_r(a__      ,       return_offsets_mapping=a__      ,       add_special_tokens=a__       )
               self.assertEqual(encoding.offset_mapping[0]      ,       (0, len(a__       ))       )
               self.assertEqual(
                   encoding.offset_mapping[1]      ,       (len(a__       ) + 1, len(a__       ) + 1 + len(a__       ))      ,       )

               A_     :				Optional[Any]			      =	self.rust_tokenizer_class.from_pretrained(
                   a__      ,       use_fast=a__      ,       add_prefix_space=a__      ,       trim_offsets=a__       )
               A_     :				str			      =	tokenizer_r(a__      ,       return_offsets_mapping=a__      ,       add_special_tokens=a__       )
               self.assertEqual(encoding.offset_mapping[0]      ,       (0, len(a__       ))       )
               self.assertEqual(
                   encoding.offset_mapping[1]      ,       (len(a__       ) + 1, len(a__       ) + 1 + len(a__       ))      ,       )

               A_     :				Union[str, Any]			      =	self.rust_tokenizer_class.from_pretrained(
                   a__      ,       use_fast=a__      ,       add_prefix_space=a__      ,       trim_offsets=a__       )
               A_     :				str			      =	tokenizer_r(a__      ,       return_offsets_mapping=a__      ,       add_special_tokens=a__       )
               self.assertEqual(encoding.offset_mapping[0]      ,       (0, len(a__       ))       )
               self.assertEqual(
                   encoding.offset_mapping[1]      ,       (len(a__       ), len(a__       ) + 1 + len(a__       ))      ,       )

               A_     :				str			      =	self.rust_tokenizer_class.from_pretrained(
                   a__      ,       use_fast=a__      ,       add_prefix_space=a__      ,       trim_offsets=a__       )
               A_     :				Optional[Any]			      =	tokenizer_r(a__      ,       return_offsets_mapping=a__      ,       add_special_tokens=a__       )
               self.assertEqual(encoding.offset_mapping[0]      ,       (0, len(a__       ))       )
               self.assertEqual(
                   encoding.offset_mapping[1]      ,       (len(a__       ), len(a__       ) + 1 + len(a__       ))      ,       )

               A_     :				Dict			      =	F""" {text}"""

               # tokenizer_r = self.rust_tokenizer_class.from_pretrained(
               #     pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True
               # )
               # encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False)
               # self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token)))
               # self.assertEqual(
               #     encoding.offset_mapping[1],
               #     (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)),
               # )

               A_     :				List[Any]			      =	self.rust_tokenizer_class.from_pretrained(
                   a__      ,       use_fast=a__      ,       add_prefix_space=a__      ,       trim_offsets=a__       )
               A_     :				List[str]			      =	tokenizer_r(a__      ,       return_offsets_mapping=a__      ,       add_special_tokens=a__       )
               self.assertEqual(encoding.offset_mapping[0]      ,       (1, 1 + len(a__       ))       )
               self.assertEqual(
                   encoding.offset_mapping[1]      ,       (1 + len(a__       ) + 1, 1 + len(a__       ) + 1 + len(a__       ))      ,       )

               A_     :				Optional[Any]			      =	self.rust_tokenizer_class.from_pretrained(
                   a__      ,       use_fast=a__      ,       add_prefix_space=a__      ,       trim_offsets=a__       )
               A_     :				Optional[int]			      =	tokenizer_r(a__      ,       return_offsets_mapping=a__      ,       add_special_tokens=a__       )
               self.assertEqual(encoding.offset_mapping[0]      ,       (0, 1 + len(a__       ))       )
               self.assertEqual(
                   encoding.offset_mapping[1]      ,       (1 + len(a__       ), 1 + len(a__       ) + 1 + len(a__       ))      ,       )

               A_     :				int			      =	self.rust_tokenizer_class.from_pretrained(
                   a__      ,       use_fast=a__      ,       add_prefix_space=a__      ,       trim_offsets=a__       )
               A_     :				Any			      =	tokenizer_r(a__      ,       return_offsets_mapping=a__      ,       add_special_tokens=a__       )
               self.assertEqual(encoding.offset_mapping[0]      ,       (0, 1 + len(a__       ))       )
               self.assertEqual(
                   encoding.offset_mapping[1]      ,       (1 + len(a__       ), 1 + len(a__       ) + 1 + len(a__       ))      ,       )













import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, XLMRobertaTokenizer

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

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


enable_full_determinism()

class    _UpperCAmelCase							(		_lowerCamelCase			,       _lowerCamelCase			,       _lowerCamelCase			,       unittest.TestCase     ):
      a						       =							AltDiffusionPipeline
      a						       =							TEXT_TO_IMAGE_PARAMS
      a						       =							TEXT_TO_IMAGE_BATCH_PARAMS
      a						       =							TEXT_TO_IMAGE_IMAGE_PARAMS
      a						       =							TEXT_TO_IMAGE_IMAGE_PARAMS
      def 		_lowerCamelCase      (		self       ):
         torch.manual_seed(0       )
         A_     :				Optional[int]			      =	UNetaDConditionModel(
             block_out_channels=(32, 64)      ,       layers_per_block=2      ,       sample_size=32      ,       in_channels=4      ,       out_channels=4      ,       down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")      ,       up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")      ,       cross_attention_dim=32      ,       )
         A_     :				List[Any]			      =	DDIMScheduler(
             beta_start=0.0_0085      ,       beta_end=0.012      ,       beta_schedule="""scaled_linear"""      ,       clip_sample=a__      ,       set_alpha_to_one=a__      ,       )
         torch.manual_seed(0       )
         A_     :				int			      =	AutoencoderKL(
             block_out_channels=[32, 64]      ,       in_channels=3      ,       out_channels=3      ,       down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]      ,       up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]      ,       latent_channels=4      ,       )

         # TODO: address the non-deterministic text encoder (fails for save-load tests)
         # torch.manual_seed(0)
         # text_encoder_config = RobertaSeriesConfig(
         #     hidden_size=32,
         #     project_dim=32,
         #     intermediate_size=37,
         #     layer_norm_eps=1e-05,
         #     num_attention_heads=4,
         #     num_hidden_layers=5,
         #     vocab_size=5002,
         # )
         # text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

         torch.manual_seed(0       )
         A_     :				Optional[int]			      =	CLIPTextConfig(
             bos_token_id=0      ,       eos_token_id=2      ,       hidden_size=32      ,       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=5002      ,       )
         A_     :				Optional[Any]			      =	CLIPTextModel(a__       )

         A_     :				Union[str, Any]			      =	XLMRobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-xlm-roberta"""       )
         A_     :				str			      =	77

         A_     :				Optional[Any]			      =	{
             """unet""": unet,
             """scheduler""": scheduler,
             """vae""": vae,
             """text_encoder""": text_encoder,
             """tokenizer""": tokenizer,
             """safety_checker""": None,
             """feature_extractor""": None,
         }
         return components
      def 		_lowerCamelCase      (		self      ,       a__      ,       a__=0       ):
         if str(a__       ).startswith("""mps"""       ):
            A_     :				Union[str, Any]			      =	torch.manual_seed(a__       )
         else:
            A_     :				Dict			      =	torch.Generator(device=a__       ).manual_seed(a__       )
         A_     :				Dict			      =	{
             """prompt""": """A painting of a squirrel eating a burger""",
             """generator""": generator,
             """num_inference_steps""": 2,
             """guidance_scale""": 6.0,
             """output_type""": """numpy""",
         }
         return inputs
      def 		_lowerCamelCase      (		self       ):
         super().test_attention_slicing_forward_pass(expected_max_diff=3E-3       )
      def 		_lowerCamelCase      (		self       ):
         super().test_inference_batch_single_identical(expected_max_diff=3E-3       )
      def 		_lowerCamelCase      (		self       ):
         A_     :				Optional[Any]			      =	"""cpu"""  # ensure determinism for the device-dependent torch.Generator

         A_     :				Union[str, Any]			      =	self.get_dummy_components()
         torch.manual_seed(0       )
         A_     :				List[str]			      =	RobertaSeriesConfig(
             hidden_size=32      ,       project_dim=32      ,       intermediate_size=37      ,       layer_norm_eps=1E-05      ,       num_attention_heads=4      ,       num_hidden_layers=5      ,       vocab_size=5002      ,       )
         # TODO: remove after fixing the non-deterministic text encoder
         A_     :				Dict			      =	RobertaSeriesModelWithTransformation(a__       )
         A_     :				Any			      =	text_encoder

         A_     :				Tuple			      =	AltDiffusionPipeline(**a__       )
         A_     :				int			      =	alt_pipe.to(a__       )
         alt_pipe.set_progress_bar_config(disable=a__       )

         A_     :				Union[str, Any]			      =	self.get_dummy_inputs(a__       )
         A_     :				Tuple			      =	"""A photo of an astronaut"""
         A_     :				Dict			      =	alt_pipe(**a__       )
         A_     :				List[str]			      =	output.images
         A_     :				List[Any]			      =	image[0, -3:, -3:, -1]

         assert image.shape == (1, 64, 64, 3)
         A_     :				Tuple			      =	np.array(
             [0.574_8162, 0.6044_7145, 0.4882_1217, 0.5010_0636, 0.543_1185, 0.4576_3683, 0.4965_7696, 0.4813_2733, 0.4757_3093]       )

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






      def 		_lowerCamelCase      (		self       ):
         A_     :				Tuple			      =	"""cpu"""  # ensure determinism for the device-dependent torch.Generator

         A_     :				Union[str, Any]			      =	self.get_dummy_components()
         A_     :				str			      =	PNDMScheduler(skip_prk_steps=a__       )
         torch.manual_seed(0       )
         A_     :				Any			      =	RobertaSeriesConfig(
             hidden_size=32      ,       project_dim=32      ,       intermediate_size=37      ,       layer_norm_eps=1E-05      ,       num_attention_heads=4      ,       num_hidden_layers=5      ,       vocab_size=5002      ,       )
         # TODO: remove after fixing the non-deterministic text encoder
         A_     :				int			      =	RobertaSeriesModelWithTransformation(a__       )
         A_     :				Any			      =	text_encoder
         A_     :				Any			      =	AltDiffusionPipeline(**a__       )
         A_     :				int			      =	alt_pipe.to(a__       )
         alt_pipe.set_progress_bar_config(disable=a__       )

         A_     :				Union[str, Any]			      =	self.get_dummy_inputs(a__       )
         A_     :				Union[str, Any]			      =	alt_pipe(**a__       )
         A_     :				List[str]			      =	output.images
         A_     :				List[Any]			      =	image[0, -3:, -3:, -1]

         assert image.shape == (1, 64, 64, 3)
         A_     :				List[Any]			      =	np.array(
             [0.5160_5093, 0.570_7241, 0.4736_5507, 0.5057_8886, 0.563_3877, 0.464_2503, 0.518_2081, 0.4876_3484, 0.4908_4237]       )

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






@slow
@require_torch_gpu
class    _UpperCAmelCase							(		unittest.TestCase     ):
      def 		_lowerCamelCase      (		self       ):
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()
      def 		_lowerCamelCase      (		self       ):
         # make sure here that pndm scheduler skips prk
         A_     :				Any			      =	AltDiffusionPipeline.from_pretrained("""BAAI/AltDiffusion"""      ,       safety_checker=a__       )
         A_     :				Optional[int]			      =	alt_pipe.to(a__       )
         alt_pipe.set_progress_bar_config(disable=a__       )

         A_     :				Tuple			      =	"""A painting of a squirrel eating a burger"""
         A_     :				Tuple			      =	torch.manual_seed(0       )
         A_     :				int			      =	alt_pipe([prompt]      ,       generator=a__      ,       guidance_scale=6.0      ,       num_inference_steps=20      ,       output_type="""np"""       )

         A_     :				Optional[Any]			      =	output.images

         A_     :				int			      =	image[0, -3:, -3:, -1]

         assert image.shape == (1, 512, 512, 3)
         A_     :				str			      =	np.array([0.1010, 0.0800, 0.0794, 0.0885, 0.0843, 0.0762, 0.0769, 0.0729, 0.0586]       )

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






      def 		_lowerCamelCase      (		self       ):
         A_     :				Dict			      =	DDIMScheduler.from_pretrained("""BAAI/AltDiffusion"""      ,       subfolder="""scheduler"""       )

         A_     :				int			      =	AltDiffusionPipeline.from_pretrained("""BAAI/AltDiffusion"""      ,       scheduler=a__      ,       safety_checker=a__       )
         A_     :				Dict			      =	alt_pipe.to(a__       )
         alt_pipe.set_progress_bar_config(disable=a__       )

         A_     :				Optional[int]			      =	"""A painting of a squirrel eating a burger"""
         A_     :				Any			      =	torch.manual_seed(0       )

         A_     :				List[str]			      =	alt_pipe([prompt]      ,       generator=a__      ,       num_inference_steps=2      ,       output_type="""numpy"""       )
         A_     :				List[Any]			      =	output.images

         A_     :				Tuple			      =	image[0, -3:, -3:, -1]

         assert image.shape == (1, 512, 512, 3)
         A_     :				Any			      =	np.array([0.4019, 0.4052, 0.3810, 0.4119, 0.3916, 0.3982, 0.4651, 0.4195, 0.5323]       )

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






