






import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / "utils"))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
  from test_module.custom_tokenization_fast import CustomTokenizerFast


class    __lowercase   (						unittest.TestCase	):







     '''simple docstring'''




     def 		lowerCAmelCase_  (					self							:      Dict					):


         """simple docstring"""



         __A       =						0




     @slow
     def 		lowerCAmelCase_  (					self							:      Optional[int]					):


         """simple docstring"""



         for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
             __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_					)
             self.assertIsNotNone(UpperCamelCase_					)
             self.assertIsInstance(UpperCamelCase_			,						(BertTokenizer, BertTokenizerFast)					)
             self.assertGreater(len(UpperCamelCase_					)			,						0					)

         for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
             __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_					)
             self.assertIsNotNone(UpperCamelCase_					)
             self.assertIsInstance(UpperCamelCase_			,						(GPTaTokenizer, GPTaTokenizerFast)					)
             self.assertGreater(len(UpperCamelCase_					)			,						0					)




     def 		lowerCAmelCase_  (					self							:      int					):


         """simple docstring"""



         __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_					)
         self.assertIsInstance(UpperCamelCase_			,						(BertTokenizer, BertTokenizerFast)					)
         self.assertEqual(tokenizer.vocab_size			,						12					)




     def 		lowerCAmelCase_  (					self							:      Tuple					):


         """simple docstring"""



         __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_					)
         self.assertIsInstance(UpperCamelCase_			,						(RobertaTokenizer, RobertaTokenizerFast)					)
         self.assertEqual(tokenizer.vocab_size			,						20					)




     def 		lowerCAmelCase_  (					self							:      Tuple					):


         """simple docstring"""



         __A       =						AutoConfig.from_pretrained(UpperCamelCase_					)
         self.assertIsInstance(UpperCamelCase_			,						UpperCamelCase_					)
         # Check that tokenizer_type ≠ model_type
         __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_			,						config=UpperCamelCase_					)
         self.assertIsInstance(UpperCamelCase_			,						(BertTokenizer, BertTokenizerFast)					)
         self.assertEqual(tokenizer.vocab_size			,						12					)




     def 		lowerCAmelCase_  (					self							:      Union[str, Any]					):


         """simple docstring"""



         with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy("""./tests/fixtures/vocab.txt"""			,						os.path.join(UpperCamelCase_			,						"""vocab.txt"""					)					)

             __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_			,						tokenizer_type="""bert"""			,						use_fast=UpperCamelCase_					)
             self.assertIsInstance(UpperCamelCase_			,						UpperCamelCase_					)

         with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy("""./tests/fixtures/vocab.json"""			,						os.path.join(UpperCamelCase_			,						"""vocab.json"""					)					)
             shutil.copy("""./tests/fixtures/merges.txt"""			,						os.path.join(UpperCamelCase_			,						"""merges.txt"""					)					)

             __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_			,						tokenizer_type="""gpt2"""			,						use_fast=UpperCamelCase_					)
             self.assertIsInstance(UpperCamelCase_			,						UpperCamelCase_					)




     @require_tokenizers
     def 		lowerCAmelCase_  (					self							:      Union[str, Any]					):


         """simple docstring"""



         with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy("""./tests/fixtures/vocab.txt"""			,						os.path.join(UpperCamelCase_			,						"""vocab.txt"""					)					)

             __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_			,						tokenizer_type="""bert"""					)
             self.assertIsInstance(UpperCamelCase_			,						UpperCamelCase_					)

         with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy("""./tests/fixtures/vocab.json"""			,						os.path.join(UpperCamelCase_			,						"""vocab.json"""					)					)
             shutil.copy("""./tests/fixtures/merges.txt"""			,						os.path.join(UpperCamelCase_			,						"""merges.txt"""					)					)

             __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_			,						tokenizer_type="""gpt2"""					)
             self.assertIsInstance(UpperCamelCase_			,						UpperCamelCase_					)




     def 		lowerCAmelCase_  (					self							:      Dict					):


         """simple docstring"""



         with pytest.raises(UpperCamelCase_					):
             AutoTokenizer.from_pretrained("""./"""			,						tokenizer_type="""xxx"""					)




     @require_tokenizers
     def 		lowerCAmelCase_  (					self							:      Dict					):


         """simple docstring"""



         for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
             __A       =						tokenizer_class.from_pretrained("""wietsedv/bert-base-dutch-cased"""					)
             self.assertIsInstance(UpperCamelCase_			,						(BertTokenizer, BertTokenizerFast)					)

             if isinstance(UpperCamelCase_			,						UpperCamelCase_					):
                 self.assertEqual(tokenizer.basic_tokenizer.do_lower_case			,						UpperCamelCase_					)
             else:
                 self.assertEqual(tokenizer.do_lower_case			,						UpperCamelCase_					)

             self.assertEqual(tokenizer.model_max_length			,						512					)




     @require_tokenizers
     def 		lowerCAmelCase_  (					self							:      Optional[Any]					):


         """simple docstring"""



         for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
             with self.assertRaisesRegex(
                 UpperCamelCase_			,						"""julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier"""			,						):
                 __A       =						tokenizer_class.from_pretrained("""julien-c/herlolip-not-exists"""					)




     def 		lowerCAmelCase_  (					self							:      int					):


         """simple docstring"""



         __A       =						TOKENIZER_MAPPING.values()
         __A       =						[]

         for slow_tok, fast_tok in tokenizers:
             if slow_tok is not None:
                 tokenizer_names.append(slow_tok.__name__					)

             if fast_tok is not None:
                 tokenizer_names.append(fast_tok.__name__					)

         for tokenizer_name in tokenizer_names:
             # must find the right class
             tokenizer_class_from_name(UpperCamelCase_					)




     @require_tokenizers
     def 		lowerCAmelCase_  (					self							:      Union[str, Any]					):


         """simple docstring"""



         self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""			,						use_fast=UpperCamelCase_					)			,						UpperCamelCase_					)
         self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""					)			,						UpperCamelCase_					)




     @require_tokenizers
     def 		lowerCAmelCase_  (					self							:      Tuple					):


         """simple docstring"""



         __A       =						AutoTokenizer.from_pretrained("""distilbert-base-uncased"""			,						do_lower_case=UpperCamelCase_					)
         __A       =						"""Hello, world. How are you?"""
         __A       =						tokenizer.tokenize(UpperCamelCase_					)
         self.assertEqual("""[UNK]"""			,						tokens[0]					)

         __A       =						AutoTokenizer.from_pretrained("""microsoft/mpnet-base"""			,						do_lower_case=UpperCamelCase_					)
         __A       =						tokenizer.tokenize(UpperCamelCase_					)
         self.assertEqual("""[UNK]"""			,						tokens[0]					)




     @require_tokenizers
     def 		lowerCAmelCase_  (					self							:      Tuple					):


         """simple docstring"""



         __A       =						AutoTokenizer.from_pretrained("""robot-test/dummy-tokenizer-fast-with-model-config"""					)
         self.assertEqual(type(UpperCamelCase_					)			,						UpperCamelCase_					)
         self.assertEqual(tokenizer.model_max_length			,						512					)
         self.assertEqual(tokenizer.vocab_size			,						30_000					)
         self.assertEqual(tokenizer.unk_token			,						"""[UNK]"""					)
         self.assertEqual(tokenizer.padding_side			,						"""right"""					)
         self.assertEqual(tokenizer.truncation_side			,						"""right"""					)




     def 		lowerCAmelCase_  (					self							:      Tuple					):


         """simple docstring"""



         __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_					)
         self.assertIsInstance(UpperCamelCase_			,						(BertTokenizer, BertTokenizerFast)					)
         with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(UpperCamelCase_					)
             __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_					)

         self.assertIsInstance(UpperCamelCase_			,						tokenizer.__class__					)
         self.assertEqual(tokenizera.vocab_size			,						12					)




     def 		lowerCAmelCase_  (					self							:      Union[str, Any]					):


         """simple docstring"""



         __A       =						AutoTokenizer.from_pretrained("""ctrl"""					)
         # There is no fast CTRL so this always gives us a slow tokenizer.
         self.assertIsInstance(UpperCamelCase_			,						UpperCamelCase_					)




     def 		lowerCAmelCase_  (					self							:      str					):


         """simple docstring"""



         __A       =						get_tokenizer_config("""bert-base-cased"""					)
         __A       =						config.pop("""_commit_hash"""			,						UpperCamelCase_					)
         # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
         self.assertEqual(UpperCamelCase_			,						{"""do_lower_case""": False}					)

         # This model does not have a tokenizer_config so we get back an empty dict.
         __A       =						get_tokenizer_config(UpperCamelCase_					)
         self.assertDictEqual(UpperCamelCase_			,						{}					)

         # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
         __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_					)
         with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(UpperCamelCase_					)
             __A       =						get_tokenizer_config(UpperCamelCase_					)

         # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
         self.assertEqual(config["""tokenizer_class"""]			,						"""BertTokenizer"""					)




     def 		lowerCAmelCase_  (					self							:      Any					):


         """simple docstring"""



         try:
             AutoConfig.register("""custom"""			,						UpperCamelCase_					)

             AutoTokenizer.register(UpperCamelCase_			,						slow_tokenizer_class=UpperCamelCase_					)
             # Trying to register something existing in the Transformers library will raise an error
             with self.assertRaises(UpperCamelCase_					):
                 AutoTokenizer.register(UpperCamelCase_			,						slow_tokenizer_class=UpperCamelCase_					)

             __A       =						CustomTokenizer.from_pretrained(UpperCamelCase_					)
             with tempfile.TemporaryDirectory() as tmp_dir:
                 tokenizer.save_pretrained(UpperCamelCase_					)

                 __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_					)
                 self.assertIsInstance(UpperCamelCase_			,						UpperCamelCase_					)

         finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                 del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                 del TOKENIZER_MAPPING._extra_content[CustomConfig]




     @require_tokenizers
     def 		lowerCAmelCase_  (					self							:      str					):


         """simple docstring"""



         try:
             AutoConfig.register("""custom"""			,						UpperCamelCase_					)

             # Can register in two steps
             AutoTokenizer.register(UpperCamelCase_			,						slow_tokenizer_class=UpperCamelCase_					)
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]			,						(CustomTokenizer, None)					)
             AutoTokenizer.register(UpperCamelCase_			,						fast_tokenizer_class=UpperCamelCase_					)
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]			,						(CustomTokenizer, CustomTokenizerFast)					)

             del TOKENIZER_MAPPING._extra_content[CustomConfig]
             # Can register in one step
             AutoTokenizer.register(
                 UpperCamelCase_			,						slow_tokenizer_class=UpperCamelCase_			,						fast_tokenizer_class=UpperCamelCase_					)
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]			,						(CustomTokenizer, CustomTokenizerFast)					)

             # Trying to register something existing in the Transformers library will raise an error
             with self.assertRaises(UpperCamelCase_					):
                 AutoTokenizer.register(UpperCamelCase_			,						fast_tokenizer_class=UpperCamelCase_					)

             # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
             # and that model does not have a tokenizer.json
             with tempfile.TemporaryDirectory() as tmp_dir:
                 __A       =						BertTokenizerFast.from_pretrained(UpperCamelCase_					)
                 bert_tokenizer.save_pretrained(UpperCamelCase_					)
                 __A       =						CustomTokenizerFast.from_pretrained(UpperCamelCase_					)

             with tempfile.TemporaryDirectory() as tmp_dir:
                 tokenizer.save_pretrained(UpperCamelCase_					)

                 __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_					)
                 self.assertIsInstance(UpperCamelCase_			,						UpperCamelCase_					)

                 __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_			,						use_fast=UpperCamelCase_					)
                 self.assertIsInstance(UpperCamelCase_			,						UpperCamelCase_					)

         finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                 del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                 del TOKENIZER_MAPPING._extra_content[CustomConfig]




     def 		lowerCAmelCase_  (					self							:      str					):


         """simple docstring"""



         with self.assertRaises(UpperCamelCase_					):
             __A       =						AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""					)
         # If remote code is disabled, we can't load this config.
         with self.assertRaises(UpperCamelCase_					):
             __A       =						AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer"""			,						trust_remote_code=UpperCamelCase_					)

         __A       =						AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""			,						trust_remote_code=UpperCamelCase_					)
         self.assertTrue(tokenizer.special_attribute_present					)
         # Test tokenizer can be reloaded.
         with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(UpperCamelCase_					)
             __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_			,						trust_remote_code=UpperCamelCase_					)
         self.assertTrue(reloaded_tokenizer.special_attribute_present					)

         if is_tokenizers_available():
             self.assertEqual(tokenizer.__class__.__name__			,						"""NewTokenizerFast"""					)
             self.assertEqual(reloaded_tokenizer.__class__.__name__			,						"""NewTokenizerFast"""					)

             # Test we can also load the slow version
             __A       =						AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer"""			,						trust_remote_code=UpperCamelCase_			,						use_fast=UpperCamelCase_					)
             self.assertTrue(tokenizer.special_attribute_present					)
             self.assertEqual(tokenizer.__class__.__name__			,						"""NewTokenizer"""					)
             # Test tokenizer can be reloaded.
             with tempfile.TemporaryDirectory() as tmp_dir:
                 tokenizer.save_pretrained(UpperCamelCase_					)
                 __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_			,						trust_remote_code=UpperCamelCase_			,						use_fast=UpperCamelCase_					)
             self.assertEqual(reloaded_tokenizer.__class__.__name__			,						"""NewTokenizer"""					)
             self.assertTrue(reloaded_tokenizer.special_attribute_present					)
         else:
             self.assertEqual(tokenizer.__class__.__name__			,						"""NewTokenizer"""					)
             self.assertEqual(reloaded_tokenizer.__class__.__name__			,						"""NewTokenizer"""					)




     @require_tokenizers
     def 		lowerCAmelCase_  (					self							:      List[str]					):


         """simple docstring"""



         class    __lowercase   (						lowercase_	):







              '''simple docstring'''
              SCREAMING_SNAKE_CASE     =					False


         class    __lowercase   (						lowercase_	):







              '''simple docstring'''
              SCREAMING_SNAKE_CASE     =					NewTokenizer
              SCREAMING_SNAKE_CASE     =					False

         try:
             AutoConfig.register("""custom"""			,						UpperCamelCase_					)
             AutoTokenizer.register(UpperCamelCase_			,						slow_tokenizer_class=UpperCamelCase_					)
             AutoTokenizer.register(UpperCamelCase_			,						fast_tokenizer_class=UpperCamelCase_					)
             # If remote code is not set, the default is to use local
             __A       =						AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""					)
             self.assertEqual(tokenizer.__class__.__name__			,						"""NewTokenizerFast"""					)
             self.assertFalse(tokenizer.special_attribute_present					)
             __A       =						AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""			,						use_fast=UpperCamelCase_					)
             self.assertEqual(tokenizer.__class__.__name__			,						"""NewTokenizer"""					)
             self.assertFalse(tokenizer.special_attribute_present					)

             # If remote code is disabled, we load the local one.
             __A       =						AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer"""			,						trust_remote_code=UpperCamelCase_					)
             self.assertEqual(tokenizer.__class__.__name__			,						"""NewTokenizerFast"""					)
             self.assertFalse(tokenizer.special_attribute_present					)
             __A       =						AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer"""			,						trust_remote_code=UpperCamelCase_			,						use_fast=UpperCamelCase_					)
             self.assertEqual(tokenizer.__class__.__name__			,						"""NewTokenizer"""					)
             self.assertFalse(tokenizer.special_attribute_present					)

             # If remote is enabled, we load from the Hub
             __A       =						AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer"""			,						trust_remote_code=UpperCamelCase_					)
             self.assertEqual(tokenizer.__class__.__name__			,						"""NewTokenizerFast"""					)
             self.assertTrue(tokenizer.special_attribute_present					)
             __A       =						AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer"""			,						trust_remote_code=UpperCamelCase_			,						use_fast=UpperCamelCase_					)
             self.assertEqual(tokenizer.__class__.__name__			,						"""NewTokenizer"""					)
             self.assertTrue(tokenizer.special_attribute_present					)

         finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                 del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                 del TOKENIZER_MAPPING._extra_content[CustomConfig]




     def 		lowerCAmelCase_  (					self							:      Optional[int]					):


         """simple docstring"""



         __A       =						AutoTokenizer.from_pretrained(
             """hf-internal-testing/test_dynamic_tokenizer_legacy"""			,						trust_remote_code=UpperCamelCase_					)
         self.assertTrue(tokenizer.special_attribute_present					)
         if is_tokenizers_available():
             self.assertEqual(tokenizer.__class__.__name__			,						"""NewTokenizerFast"""					)

             # Test we can also load the slow version
             __A       =						AutoTokenizer.from_pretrained(
                 """hf-internal-testing/test_dynamic_tokenizer_legacy"""			,						trust_remote_code=UpperCamelCase_			,						use_fast=UpperCamelCase_					)
             self.assertTrue(tokenizer.special_attribute_present					)
             self.assertEqual(tokenizer.__class__.__name__			,						"""NewTokenizer"""					)
         else:
             self.assertEqual(tokenizer.__class__.__name__			,						"""NewTokenizer"""					)




     def 		lowerCAmelCase_  (					self							:      Optional[Any]					):


         """simple docstring"""



         with self.assertRaisesRegex(
             UpperCamelCase_			,						"""bert-base is not a local folder and is not a valid model identifier"""					):
             __A       =						AutoTokenizer.from_pretrained("""bert-base"""					)




     def 		lowerCAmelCase_  (					self							:      List[str]					):


         """simple docstring"""



         with self.assertRaisesRegex(
             UpperCamelCase_			,						R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""					):
             __A       =						AutoTokenizer.from_pretrained(UpperCamelCase_			,						revision="""aaaaaa"""					)





     def 		lowerCAmelCase_  (					self							:      Dict					):


         """simple docstring"""



         __A       =						AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""					)
         with RequestCounter() as counter:
             __A       =						AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""					)
             self.assertEqual(counter.get_request_count			,						0					)
             self.assertEqual(counter.head_request_count			,						1					)
             self.assertEqual(counter.other_request_count			,						0					)












from __future__ import annotations

from PIL import Image

# Define glider example
__a   :							Tuple						= [
    [0, 1, 0, 0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0, 0, 0, 0],
    [1, 1, 1, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
]

# Define blinker example
__a   :							Optional[Any]						= [[0, 1, 0], [0, 1, 0], [0, 1, 0]]



def       _SCREAMING_SNAKE_CASE    (			__lowercase :      list[list[int]]     )    ->   list[list[int]]:





    """simple docstring"""

    __A       =						[]
    for i in range(len(__lowercase     )     ):
        __A       =						[]
        for j in range(len(cells[i]     )     ):
            # Get the number of live neighbours
            __A       =						0
            if i > 0 and j > 0:
                neighbour_count += cells[i - 1][j - 1]
            if i > 0:
                neighbour_count += cells[i - 1][j]
            if i > 0 and j < len(cells[i]     ) - 1:
                neighbour_count += cells[i - 1][j + 1]
            if j > 0:
                neighbour_count += cells[i][j - 1]
            if j < len(cells[i]     ) - 1:
                neighbour_count += cells[i][j + 1]
            if i < len(__lowercase     ) - 1 and j > 0:
                neighbour_count += cells[i + 1][j - 1]
            if i < len(__lowercase     ) - 1:
                neighbour_count += cells[i + 1][j]
            if i < len(__lowercase     ) - 1 and j < len(cells[i]     ) - 1:
                neighbour_count += cells[i + 1][j + 1]

            # Rules of the game of life (excerpt from Wikipedia):
            # 1. Any live cell with two or three live neighbours survives.
            # 2. Any dead cell with three live neighbours becomes a live cell.
            # 3. All other live cells die in the next generation.
            #    Similarly, all other dead cells stay dead.
            __A       =						cells[i][j] == 1
            if (
                (alive and 2 <= neighbour_count <= 3)
                or not alive
                and neighbour_count == 3
            ):
                next_generation_row.append(1     )
            else:
                next_generation_row.append(0     )

        next_generation.append(__lowercase     )
    return next_generation



def       _SCREAMING_SNAKE_CASE    (			__lowercase :      list[list[int]]      ,					__lowercase :      int     )    ->   list[Image.Image]:





    """simple docstring"""

    __A       =						[]
    for _ in range(__lowercase     ):
        # Create output image
        __A       =						Image.new("""RGB"""      ,					(len(cells[0]     ), len(__lowercase     ))     )
        __A       =						img.load()

        # Save cells to image
        for x in range(len(__lowercase     )     ):
            for y in range(len(cells[0]     )     ):
                __A       =						2_5_5 - cells[y][x] * 2_5_5
                __A       =						(colour, colour, colour)

        # Save image
        images.append(__lowercase     )
        __A       =						new_generation(__lowercase     )
    return images


if __name__ == "__main__":
  __a   :							Optional[int]						= generate_images(GLIDER, 16)
  images[0].save("out.gif", save_all=True, append_images=images[1:])




