



"""simple docstring"""
import json
import os
import shutil
import tempfile
import unittest

from transformers import BatchEncoding, CanineTokenizer
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.tokenization_utils import AddedToken
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__      ,			unittest.TestCase ):
   __lowerCAmelCase  :   List[Any]						=						CanineTokenizer
   __lowerCAmelCase  :   Dict						=						False

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    super().setUp()
    UpperCAmelCase	:					List[str]	=	CanineTokenizer()
    tokenizer.save_pretrained(self.tmpdirname						)

   @cached_property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[int]:





    '''simple docstring'''




    return CanineTokenizer.from_pretrained("""google/canine-s"""						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     **_SCREAMING_SNAKE_CASE						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	self.tokenizer_class.from_pretrained(self.tmpdirname      ,     **_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Tuple	=	1024
    return tokenizer

   @require_torch
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	self.canine_tokenizer
    UpperCAmelCase	:					List[str]	=	["""Life is like a box of chocolates.""", """You never know what you\'re gonna get."""]
    # fmt: off
    UpperCAmelCase	:					Union[str, Any]	=	[57344, 76, 105, 102, 101, 32, 105, 115, 32, 108, 105, 107, 101, 32, 97, 32, 98, 111, 120, 32, 111, 102, 32, 99, 104, 111, 99, 111, 108, 97, 116, 101, 115, 46, 57345, 0, 0, 0, 0]
    # fmt: on
    UpperCAmelCase	:					Optional[Any]	=	tokenizer(_SCREAMING_SNAKE_CASE      ,     padding=_SCREAMING_SNAKE_CASE      ,     return_tensors="""pt"""						)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

    UpperCAmelCase	:					str	=	list(batch.input_ids.numpy()[0]						)

    self.assertListEqual(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

    self.assertEqual((2, 39)      ,     batch.input_ids.shape						)
    self.assertEqual((2, 39)      ,     batch.attention_mask.shape						)

   @require_torch
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[int]:





    '''simple docstring'''




    UpperCAmelCase	:					Any	=	self.canine_tokenizer
    UpperCAmelCase	:					str	=	["""Once there was a man.""", """He wrote a test in HuggingFace Tranformers."""]
    UpperCAmelCase	:					Dict	=	tokenizer(_SCREAMING_SNAKE_CASE      ,     padding=_SCREAMING_SNAKE_CASE      ,     return_tensors="""pt"""						)
    # check if input_ids, attention_mask and token_type_ids are returned
    self.assertIn("""input_ids"""      ,     _SCREAMING_SNAKE_CASE						)
    self.assertIn("""attention_mask"""      ,     _SCREAMING_SNAKE_CASE						)
    self.assertIn("""token_type_ids"""      ,     _SCREAMING_SNAKE_CASE						)

   @require_torch
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	self.canine_tokenizer
    UpperCAmelCase	:					Union[str, Any]	=	[
        """What\'s the weater?""",
        """It\'s about 25 degrees.""",
    ]
    UpperCAmelCase	:					Dict	=	tokenizer(
        text_target=_SCREAMING_SNAKE_CASE      ,     max_length=32      ,     padding="""max_length"""      ,     truncation=_SCREAMING_SNAKE_CASE      ,     return_tensors="""pt"""						)
    self.assertEqual(32      ,     targets["""input_ids"""].shape[1]						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[int]:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[Any]	=	self.get_tokenizers()
    for tokenizer in tokenizers:
     with self.subTest(F"{tokenizer.__class__.__name__}"						):
      self.assertNotEqual(tokenizer.model_max_length      ,     42						)

        # Now let's start the test
    UpperCAmelCase	:					Tuple	=	self.get_tokenizers()
    for tokenizer in tokenizers:
     with self.subTest(F"{tokenizer.__class__.__name__}"						):
      # Isolate this from the other tests because we save additional tokens/etc
      UpperCAmelCase	:					Union[str, Any]	=	tempfile.mkdtemp()

      UpperCAmelCase	:					Dict	=	""" He is very happy, UNwant\u00E9d,running"""
      UpperCAmelCase	:					List[str]	=	tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)
      tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE						)

      UpperCAmelCase	:					int	=	tokenizer.__class__.from_pretrained(_SCREAMING_SNAKE_CASE						)
      UpperCAmelCase	:					List[Any]	=	after_tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)
      self.assertListEqual(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

      shutil.rmtree(_SCREAMING_SNAKE_CASE						)

    UpperCAmelCase	:					List[str]	=	self.get_tokenizers(model_max_length=42						)
    for tokenizer in tokenizers:
     with self.subTest(F"{tokenizer.__class__.__name__}"						):
      # Isolate this from the other tests because we save additional tokens/etc
      UpperCAmelCase	:					List[str]	=	tempfile.mkdtemp()

      UpperCAmelCase	:					Tuple	=	""" He is very happy, UNwant\u00E9d,running"""

      UpperCAmelCase	:					Optional[Any]	=	tokenizer.additional_special_tokens

      # We can add a new special token for Canine as follows:
      UpperCAmelCase	:					Optional[int]	=	chr(0xE_0_0_7						)
      additional_special_tokens.append(_SCREAMING_SNAKE_CASE						)
      tokenizer.add_special_tokens({"""additional_special_tokens""": additional_special_tokens}						)
      UpperCAmelCase	:					Union[str, Any]	=	tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)
      tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE						)

      UpperCAmelCase	:					Optional[Any]	=	tokenizer.__class__.from_pretrained(_SCREAMING_SNAKE_CASE						)
      UpperCAmelCase	:					Dict	=	after_tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)
      self.assertListEqual(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
      self.assertIn(_SCREAMING_SNAKE_CASE      ,     after_tokenizer.additional_special_tokens						)
      self.assertEqual(after_tokenizer.model_max_length      ,     42						)

      UpperCAmelCase	:					List[Any]	=	tokenizer.__class__.from_pretrained(_SCREAMING_SNAKE_CASE      ,     model_max_length=43						)
      self.assertEqual(tokenizer.model_max_length      ,     43						)

      shutil.rmtree(_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Any	=	self.get_tokenizers(do_lower_case=_SCREAMING_SNAKE_CASE						)
    for tokenizer in tokenizers:
     with self.subTest(F"{tokenizer.__class__.__name__}"						):
      UpperCAmelCase	,		UpperCAmelCase	:					Dict	=	self.get_clean_sequence(_SCREAMING_SNAKE_CASE						)

      # a special token for Canine can be defined as follows:
      UpperCAmelCase	:					List[Any]	=	0xE_0_0_5
      UpperCAmelCase	:					List[Any]	=	chr(_SCREAMING_SNAKE_CASE						)

      tokenizer.add_special_tokens({"""cls_token""": special_token}						)
      UpperCAmelCase	:					Union[str, Any]	=	tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)
      self.assertEqual(len(_SCREAMING_SNAKE_CASE						)      ,     1						)

      UpperCAmelCase	:					str	=	tokenizer.decode(ids + encoded_special_token      ,     clean_up_tokenization_spaces=_SCREAMING_SNAKE_CASE						)
      UpperCAmelCase	:					int	=	tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)

      UpperCAmelCase	:					List[str]	=	tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)
      UpperCAmelCase	:					Optional[Any]	=	tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)
      self.assertEqual(_SCREAMING_SNAKE_CASE      ,     input_encoded + special_token_id						)

      UpperCAmelCase	:					List[Any]	=	tokenizer.decode(_SCREAMING_SNAKE_CASE      ,     skip_special_tokens=_SCREAMING_SNAKE_CASE						)
      self.assertTrue(special_token not in decoded						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      str:





    '''simple docstring'''




    UpperCAmelCase	:					Dict	=	self.get_tokenizers(do_lower_case=_SCREAMING_SNAKE_CASE						)
    for tokenizer in tokenizers:
     with self.subTest(F"{tokenizer.__class__.__name__}"						):
      UpperCAmelCase	:					Union[str, Any]	=	chr(0xE_0_0_5						)
      UpperCAmelCase	:					List[Any]	=	chr(0xE_0_0_6						)

      # `add_tokens` method stores special tokens only in `tokenizer.unique_no_split_tokens`. (in tokenization_utils.py)
      tokenizer.add_tokens([SPECIAL_TOKEN_1]      ,     special_tokens=_SCREAMING_SNAKE_CASE						)
      # `add_special_tokens` method stores special tokens in `tokenizer.additional_special_tokens`,
      # which also occur in `tokenizer.all_special_tokens`. (in tokenization_utils_base.py)
      tokenizer.add_special_tokens({"""additional_special_tokens""": [SPECIAL_TOKEN_2]}						)

      UpperCAmelCase	:					List[str]	=	tokenizer.tokenize(_SCREAMING_SNAKE_CASE						)
      UpperCAmelCase	:					Dict	=	tokenizer.tokenize(_SCREAMING_SNAKE_CASE						)

      self.assertEqual(len(_SCREAMING_SNAKE_CASE						)      ,     1						)
      self.assertEqual(len(_SCREAMING_SNAKE_CASE						)      ,     1						)
      self.assertEqual(token_a[0]      ,     _SCREAMING_SNAKE_CASE						)
      self.assertEqual(token_a[0]      ,     _SCREAMING_SNAKE_CASE						)

   @require_tokenizers
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	self.get_tokenizers(do_lower_case=_SCREAMING_SNAKE_CASE						)
    for tokenizer in tokenizers:
     with self.subTest(F"{tokenizer.__class__.__name__}"						):
      # a special token for Canine can be defined as follows:
      UpperCAmelCase	:					Any	=	0xE_0_0_6
      UpperCAmelCase	:					Optional[int]	=	chr(_SCREAMING_SNAKE_CASE						)

      UpperCAmelCase	:					Optional[Any]	=	AddedToken(_SCREAMING_SNAKE_CASE      ,     lstrip=_SCREAMING_SNAKE_CASE						)
      tokenizer.add_special_tokens({"""additional_special_tokens""": [new_token]}						)

      with tempfile.TemporaryDirectory() as tmp_dir_name:
       tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE						)
       tokenizer.from_pretrained(_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Any	=	[]
    if self.test_slow_tokenizer:
     tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())						)

    if self.test_rust_tokenizer:
     tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())						)

    for tokenizer_class, tokenizer_utils in tokenizer_list:
     with tempfile.TemporaryDirectory() as tmp_dir:
      tokenizer_utils.save_pretrained(_SCREAMING_SNAKE_CASE						)

      with open(os.path.join(_SCREAMING_SNAKE_CASE      ,     """special_tokens_map.json"""						)      ,     encoding="""utf-8"""						) as json_file:
       UpperCAmelCase	:					Dict	=	json.load(_SCREAMING_SNAKE_CASE						)

      with open(os.path.join(_SCREAMING_SNAKE_CASE      ,     """tokenizer_config.json"""						)      ,     encoding="""utf-8"""						) as json_file:
       UpperCAmelCase	:					Optional[Any]	=	json.load(_SCREAMING_SNAKE_CASE						)

      # a special token for Canine can be defined as follows:
      UpperCAmelCase	:					Union[str, Any]	=	0xE_0_0_6
      UpperCAmelCase	:					Tuple	=	chr(_SCREAMING_SNAKE_CASE						)

      UpperCAmelCase	:					List[str]	=	[new_token_a]
      UpperCAmelCase	:					Any	=	[new_token_a]

      with open(os.path.join(_SCREAMING_SNAKE_CASE      ,     """special_tokens_map.json"""						)      ,     """w"""      ,     encoding="""utf-8"""						) as outfile:
       json.dump(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
      with open(os.path.join(_SCREAMING_SNAKE_CASE      ,     """tokenizer_config.json"""						)      ,     """w"""      ,     encoding="""utf-8"""						) as outfile:
       json.dump(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

      # the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
      # into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
      # "special_tokens_map.json" files
      UpperCAmelCase	:					Tuple	=	tokenizer_class.from_pretrained(_SCREAMING_SNAKE_CASE      ,     extra_ids=0						)
      self.assertIn(_SCREAMING_SNAKE_CASE      ,     tokenizer_without_change_in_init.additional_special_tokens						)
      # self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab
      self.assertEqual(
          [new_token_a]      ,     tokenizer_without_change_in_init.convert_ids_to_tokens(
              tokenizer_without_change_in_init.convert_tokens_to_ids([new_token_a]						)						)      ,     )

      UpperCAmelCase	:					Optional[int]	=	0xE_0_0_7
      UpperCAmelCase	:					List[Any]	=	chr(_SCREAMING_SNAKE_CASE						)
      # Now we test that we can change the value of additional_special_tokens in the from_pretrained
      UpperCAmelCase	:					Dict	=	[AddedToken(_SCREAMING_SNAKE_CASE      ,     lstrip=_SCREAMING_SNAKE_CASE						)]
      UpperCAmelCase	:					Tuple	=	tokenizer_class.from_pretrained(
          _SCREAMING_SNAKE_CASE      ,     additional_special_tokens=_SCREAMING_SNAKE_CASE      ,     extra_ids=0						)

      self.assertIn(_SCREAMING_SNAKE_CASE      ,     tokenizer.additional_special_tokens						)
      # self.assertIn(new_token_2,tokenizer.get_vocab()) # ByT5Tokenization no vocab
      self.assertEqual(
          [new_token_a]      ,     tokenizer.convert_ids_to_tokens(tokenizer.convert_tokens_to_ids([new_token_a]						)						)						)

   @require_tokenizers
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[str]:





    '''simple docstring'''




    UpperCAmelCase	:					Any	=	self.get_tokenizers(do_lower_case=_SCREAMING_SNAKE_CASE						)
    for tokenizer in tokenizers:
     with self.subTest(F"{tokenizer.__class__.__name__}"						):
      UpperCAmelCase	:					Tuple	=	"""hello world"""
      if self.space_between_special_tokens:
       UpperCAmelCase	:					int	=	"""[CLS] hello world [SEP]"""
      else:
       UpperCAmelCase	:					Optional[int]	=	input
      UpperCAmelCase	:					Any	=	tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)
      UpperCAmelCase	:					List[str]	=	tokenizer.decode(_SCREAMING_SNAKE_CASE      ,     spaces_between_special_tokens=self.space_between_special_tokens						)
      self.assertIn(_SCREAMING_SNAKE_CASE      ,     [output, output.lower()]						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[str]:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	self.get_tokenizers()
    for tokenizer in tokenizers:
     with self.subTest(F"{tokenizer.__class__.__name__}"						):
      UpperCAmelCase	:					Tuple	=	[
          """bos_token""",
          """eos_token""",
          """unk_token""",
          """sep_token""",
          """pad_token""",
          """cls_token""",
          """mask_token""",
      ]

    UpperCAmelCase	:					Union[str, Any]	=	"""a"""
    UpperCAmelCase	:					str	=	ord(_SCREAMING_SNAKE_CASE						)

    for attr in attributes_list:
     setattr(_SCREAMING_SNAKE_CASE      ,     attr + """_id"""      ,     _SCREAMING_SNAKE_CASE						)
     self.assertEqual(getattr(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)      ,     _SCREAMING_SNAKE_CASE						)
     self.assertEqual(getattr(_SCREAMING_SNAKE_CASE      ,     attr + """_id"""						)      ,     _SCREAMING_SNAKE_CASE						)

     setattr(_SCREAMING_SNAKE_CASE      ,     attr + """_id"""      ,     _SCREAMING_SNAKE_CASE						)
     self.assertEqual(getattr(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)      ,     _SCREAMING_SNAKE_CASE						)
     self.assertEqual(getattr(_SCREAMING_SNAKE_CASE      ,     attr + """_id"""						)      ,     _SCREAMING_SNAKE_CASE						)

    setattr(_SCREAMING_SNAKE_CASE      ,     """additional_special_tokens_ids"""      ,     []						)
    self.assertListEqual(getattr(_SCREAMING_SNAKE_CASE      ,     """additional_special_tokens"""						)      ,     []						)
    self.assertListEqual(getattr(_SCREAMING_SNAKE_CASE      ,     """additional_special_tokens_ids"""						)      ,     []						)

    UpperCAmelCase	:					Dict	=	0xE_0_0_6
    UpperCAmelCase	:					List[str]	=	chr(_SCREAMING_SNAKE_CASE						)
    setattr(_SCREAMING_SNAKE_CASE      ,     """additional_special_tokens_ids"""      ,     [additional_special_token_id]						)
    self.assertListEqual(getattr(_SCREAMING_SNAKE_CASE      ,     """additional_special_tokens"""						)      ,     [additional_special_token]						)
    self.assertListEqual(getattr(_SCREAMING_SNAKE_CASE      ,     """additional_special_tokens_ids"""						)      ,     [additional_special_token_id]						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Tuple:





    '''simple docstring'''




    pass

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    pass

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[Any]:





    '''simple docstring'''




    pass

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      int:





    '''simple docstring'''




    pass

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      str:





    '''simple docstring'''




    pass

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Tuple:





    '''simple docstring'''




    pass

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    pass




   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    pass


import random

import torch
from huggingface_hub import HfApi

from diffusers import UNetaDModel


_lowerCamelCase       :				List[Any]       =			HfApi()

_lowerCamelCase       :				Dict       =			{}
# fmt: off
_lowerCamelCase       :				List[Any]       =			torch.tensor([
    -0.7_5_1_5, -1.6_8_8_3, 0.2_4_2_0, 0.0_3_0_0, 0.6_3_4_7, 1.3_4_3_3, -1.1_7_4_3, -3.7_4_6_7,
    1.2_3_4_2, -2.2_4_8_5, 0.4_6_3_6, 0.8_0_7_6, -0.7_9_9_1, 0.3_9_6_9, 0.8_4_9_8, 0.9_1_8_9,
    -1.8_8_8_7, -3.3_5_2_2, 0.7_6_3_9, 0.2_0_4_0, 0.6_2_7_1, -2.7_1_4_8, -1.6_3_1_6, 3.0_8_3_9,
    0.3_1_8_6, 0.2_7_2_1, -0.9_7_5_9, -1.2_4_6_1, 2.6_2_5_7, 1.3_5_5_7
])
_lowerCamelCase       :				int       =			torch.tensor([
    -2.3_6_3_9, -2.5_3_4_4, 0.0_0_5_4, -0.6_6_7_4, 1.5_9_9_0, 1.0_1_5_8, 0.3_1_2_4, -2.1_4_3_6,
    1.8_7_9_5, -2.5_4_2_9, -0.1_5_6_6, -0.3_9_7_3, 1.2_4_9_0, 2.6_4_4_7, 1.2_2_8_3, -0.5_2_0_8,
    -2.8_1_5_4, -3.5_1_1_9, 2.3_8_3_8, 1.2_0_3_3, 1.7_2_0_1, -2.1_2_5_6, -1.4_5_7_6, 2.7_9_4_8,
    2.4_2_0_4, -0.9_7_5_2, -1.2_5_4_6, 0.8_0_2_7, 3.2_7_5_8, 3.1_3_6_5
])
_lowerCamelCase       :				Optional[int]       =			torch.tensor([
    -0.6_5_3_1, -0.6_8_9_1, -0.3_1_7_2, -0.5_3_7_5, -0.9_1_4_0, -0.5_3_6_7, -0.1_1_7_5, -0.7_8_6_9,
    -0.3_8_0_8, -0.4_5_1_3, -0.2_0_9_8, -0.0_0_8_3, 0.3_1_8_3, 0.5_1_4_0, 0.2_2_4_7, -0.1_3_0_4,
    -0.1_3_0_2, -0.2_8_0_2, -0.2_0_8_4, -0.2_0_2_5, -0.4_9_6_7, -0.4_8_7_3, -0.0_8_6_1, 0.6_9_2_5,
    0.0_2_5_0, 0.1_2_9_0, -0.1_5_4_3, 0.6_3_1_6, 1.0_4_6_0, 1.4_9_4_3
])
_lowerCamelCase       :				Dict       =			torch.tensor([
    0.0_9_1_1, 0.1_1_0_7, 0.0_1_8_2, 0.0_4_3_5, -0.0_8_0_5, -0.0_6_0_8, 0.0_3_8_1, 0.2_1_7_2,
    -0.0_2_8_0, 0.1_3_2_7, -0.0_2_9_9, -0.0_2_5_5, -0.0_0_5_0, -0.1_1_7_0, -0.1_0_4_6, 0.0_3_0_9,
    0.1_3_6_7, 0.1_7_2_8, -0.0_5_3_3, -0.0_7_4_8, -0.0_5_3_4, 0.1_6_2_4, 0.0_3_8_4, -0.1_8_0_5,
    -0.0_7_0_7, 0.0_6_4_2, 0.0_2_2_0, -0.0_1_3_4, -0.1_3_3_3, -0.1_5_0_5
])
_lowerCamelCase       :				Dict       =			torch.tensor([
    0.1_3_2_1, 0.1_3_3_7, 0.0_4_4_0, 0.0_6_2_2, -0.0_5_9_1, -0.0_3_7_0, 0.0_5_0_3, 0.2_1_3_3,
    -0.0_1_7_7, 0.1_4_1_5, -0.0_1_1_6, -0.0_1_1_2, 0.0_0_4_4, -0.0_9_8_0, -0.0_7_8_9, 0.0_3_9_5,
    0.1_5_0_2, 0.1_7_8_5, -0.0_4_8_8, -0.0_5_1_4, -0.0_4_0_4, 0.1_5_3_9, 0.0_4_5_4, -0.1_5_5_9,
    -0.0_6_6_5, 0.0_6_5_9, 0.0_3_8_3, -0.0_0_0_5, -0.1_2_6_6, -0.1_3_8_6
])
_lowerCamelCase       :				List[Any]       =			torch.tensor([
    0.1_1_5_4, 0.1_2_1_8, 0.0_3_0_7, 0.0_5_2_6, -0.0_7_1_1, -0.0_5_4_1, 0.0_3_6_6, 0.2_0_7_8,
    -0.0_2_6_7, 0.1_3_1_7, -0.0_2_2_6, -0.0_1_9_3, -0.0_0_1_4, -0.1_0_5_5, -0.0_9_0_2, 0.0_3_3_0,
    0.1_3_9_1, 0.1_7_0_9, -0.0_5_6_2, -0.0_6_9_3, -0.0_5_6_0, 0.1_4_8_2, 0.0_3_8_1, -0.1_6_8_3,
    -0.0_6_8_1, 0.0_6_6_1, 0.0_3_3_1, -0.0_0_4_6, -0.1_2_6_8, -0.1_4_3_1
])
_lowerCamelCase       :				Dict       =			torch.tensor([
    0.1_1_9_2, 0.1_2_4_0, 0.0_4_1_4, 0.0_6_0_6, -0.0_5_5_7, -0.0_4_1_2, 0.0_4_3_0, 0.2_0_4_2,
    -0.0_2_0_0, 0.1_3_8_5, -0.0_1_1_5, -0.0_1_3_2, 0.0_0_1_7, -0.0_9_6_5, -0.0_8_0_2, 0.0_3_9_8,
    0.1_4_3_3, 0.1_7_4_7, -0.0_4_5_8, -0.0_5_3_3, -0.0_4_0_7, 0.1_5_4_5, 0.0_4_1_9, -0.1_5_7_4,
    -0.0_6_4_5, 0.0_6_2_6, 0.0_3_4_1, -0.0_0_1_0, -0.1_1_9_9, -0.1_3_9_0
])
_lowerCamelCase       :				int       =			torch.tensor([
    0.1_0_7_5, 0.1_0_7_4, 0.0_2_0_5, 0.0_4_3_1, -0.0_7_7_4, -0.0_6_0_7, 0.0_2_9_8, 0.2_0_4_2,
    -0.0_3_2_0, 0.1_2_6_7, -0.0_2_8_1, -0.0_2_5_0, -0.0_0_6_4, -0.1_0_9_1, -0.0_9_4_6, 0.0_2_9_0,
    0.1_3_2_8, 0.1_6_5_0, -0.0_5_8_0, -0.0_7_3_8, -0.0_5_8_6, 0.1_4_4_0, 0.0_3_3_7, -0.1_7_4_6,
    -0.0_7_1_2, 0.0_6_0_5, 0.0_2_5_0, -0.0_0_9_9, -0.1_3_1_6, -0.1_4_7_3
])
_lowerCamelCase       :				int       =			torch.tensor([
    -1.4_5_7_2, -2.0_4_8_1, -0.0_4_1_4, -0.6_0_0_5, 1.4_1_3_6, 0.5_8_4_8, 0.4_0_2_8, -2.7_3_3_0,
    1.2_2_1_2, -2.1_2_2_8, 0.2_1_5_5, 0.4_0_3_9, 0.7_6_6_2, 2.0_5_3_5, 0.7_4_7_7, -0.3_2_4_3,
    -2.1_7_5_8, -2.7_6_4_8, 1.6_9_4_7, 0.7_0_2_6, 1.2_3_3_8, -1.6_0_7_8, -0.8_6_8_2, 2.2_8_1_0,
    1.8_5_7_4, -0.5_7_1_8, -0.5_5_8_6, -0.0_1_8_6, 2.3_4_1_5, 2.1_2_5_1])
_lowerCamelCase       :				Tuple       =			torch.tensor([
    -1.3_6_9_0, -1.9_7_2_0, -0.4_0_9_0, -0.6_9_6_6, 1.4_6_6_0, 0.9_9_3_8, -0.1_3_8_5, -2.7_3_2_4,
    0.7_7_3_6, -1.8_9_1_7, 0.2_9_2_3, 0.4_2_9_3, 0.1_6_9_3, 1.4_1_1_2, 1.1_8_8_7, -0.3_1_8_1,
    -2.2_1_6_0, -2.6_3_8_1, 1.3_1_7_0, 0.8_1_6_3, 0.9_2_4_0, -1.6_5_4_4, -0.6_0_9_9, 2.5_2_5_9,
    1.6_4_3_0, -0.9_0_9_0, -0.9_3_9_2, -0.0_1_2_6, 2.4_2_6_8, 2.3_2_6_6
])
_lowerCamelCase       :				List[str]       =			torch.tensor([
    -1.3_5_2_5, -1.9_6_2_8, -0.3_9_5_6, -0.6_8_6_0, 1.4_6_6_4, 1.0_0_1_4, -0.1_2_5_9, -2.7_2_1_2,
    0.7_7_7_2, -1.8_8_1_1, 0.2_9_9_6, 0.4_3_8_8, 0.1_7_0_4, 1.4_0_2_9, 1.1_7_0_1, -0.3_0_2_7,
    -2.2_0_5_3, -2.6_2_8_7, 1.3_3_5_0, 0.8_1_3_1, 0.9_2_7_4, -1.6_2_9_2, -0.6_0_9_8, 2.5_1_3_1,
    1.6_5_0_5, -0.8_9_5_8, -0.9_2_9_8, -0.0_1_5_1, 2.4_2_5_7, 2.3_3_5_5
])
_lowerCamelCase       :				int       =			torch.tensor([
    -2.0_5_8_5, -2.7_8_9_7, -0.2_8_5_0, -0.8_9_4_0, 1.9_0_5_2, 0.5_7_0_2, 0.6_3_4_5, -3.8_9_5_9,
    1.5_9_3_2, -3.2_3_1_9, 0.1_9_7_4, 0.0_2_8_7, 1.7_5_6_6, 2.6_5_4_3, 0.8_3_8_7, -0.5_3_5_1,
    -3.2_7_3_6, -4.3_3_7_5, 2.9_0_2_9, 1.6_3_9_0, 1.4_6_4_0, -2.1_7_0_1, -1.9_0_1_3, 2.9_3_4_1,
    3.4_9_8_1, -0.6_2_5_5, -1.1_6_4_4, -0.1_5_9_1, 3.7_0_9_7, 3.2_0_6_6
])
_lowerCamelCase       :				Tuple       =			torch.tensor([
    -2.3_1_3_9, -2.5_5_9_4, -0.0_1_9_7, -0.6_7_8_5, 1.7_0_0_1, 1.1_6_0_6, 0.3_0_7_5, -2.1_7_4_0,
    1.8_0_7_1, -2.5_6_3_0, -0.0_9_2_6, -0.3_8_1_1, 1.2_1_1_6, 2.6_2_4_6, 1.2_7_3_1, -0.5_3_9_8,
    -2.8_1_5_3, -3.6_1_4_0, 2.3_8_9_3, 1.3_2_6_2, 1.6_2_5_8, -2.1_8_5_6, -1.3_2_6_7, 2.8_3_9_5,
    2.3_7_7_9, -1.0_6_2_3, -1.2_4_6_8, 0.8_9_5_9, 3.3_3_6_7, 3.2_2_4_3
])
_lowerCamelCase       :				int       =			torch.tensor([
    -2.0_6_2_8, -2.7_6_6_7, -0.2_0_8_9, -0.8_2_6_3, 2.0_5_3_9, 0.5_9_9_2, 0.6_4_9_5, -3.8_3_3_6,
    1.6_0_2_5, -3.2_8_1_7, 0.1_7_2_1, -0.0_6_3_3, 1.7_5_1_6, 2.7_0_3_9, 0.8_1_0_0, -0.5_9_0_8,
    -3.2_1_1_3, -4.4_3_4_3, 2.9_2_5_7, 1.3_6_3_2, 1.5_5_6_2, -2.1_4_8_9, -1.9_8_9_4, 3.0_5_6_0,
    3.3_3_9_6, -0.7_3_2_8, -1.0_4_1_7, 0.0_3_8_3, 3.7_0_9_3, 3.2_3_4_3
])
_lowerCamelCase       :				List[Any]       =			torch.tensor([
    -1.4_5_7_4, -2.0_5_6_9, -0.0_4_7_3, -0.6_1_1_7, 1.4_0_1_8, 0.5_7_6_9, 0.4_1_2_9, -2.7_3_4_4,
    1.2_2_4_1, -2.1_3_9_7, 0.2_0_0_0, 0.3_9_3_7, 0.7_6_1_6, 2.0_4_5_3, 0.7_3_2_4, -0.3_3_9_1,
    -2.1_7_4_6, -2.7_7_4_4, 1.6_9_6_3, 0.6_9_2_1, 1.2_1_8_7, -1.6_1_7_2, -0.8_8_7_7, 2.2_4_3_9,
    1.8_4_7_1, -0.5_8_3_9, -0.5_6_0_5, -0.0_4_6_4, 2.3_2_5_0, 2.1_2_1_9
])
# fmt: on

_lowerCamelCase       :				List[str]       =			api.list_models(filter='''diffusers''')
for mod in models:
			if "google" in mod.author or mod.modelId == "CompVis/ldm-celebahq-256":
						_lowerCamelCase       :				Any       =			'''/home/patrick/google_checkpoints/''' + mod.modelId.split('''/''')[-1]

						print(F'Started running {mod.modelId}!!!')

						if mod.modelId.startswith('''CompVis'''):
									_lowerCamelCase       :				Optional[Any]       =			UNetaDModel.from_pretrained(local_checkpoint, subfolder='''unet''')
						else:
									_lowerCamelCase       :				int       =			UNetaDModel.from_pretrained(local_checkpoint)

						torch.manual_seed(0)
						random.seed(0)

						_lowerCamelCase       :				Union[str, Any]       =			torch.randn(1, model.config.in_channels, model.config.sample_size, model.config.sample_size)
						_lowerCamelCase       :				int       =			torch.tensor([10] * noise.shape[0])
						with torch.no_grad():
									_lowerCamelCase       :				int       =			model(noise, time_step).sample

						assert torch.allclose(
						    logits[0, 0, 0, :30], results['''_'''.join('''_'''.join(mod.modelId.split('''/''')).split('''-'''))], atol=1E-3
						)
						print(F'{mod.modelId} has passed successfully!!!')