


from __future__ import annotations

from PIL import Image

# Define glider example
_A		       =						[
    [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		       =						[[0, 1, 0], [0, 1, 0], [0, 1, 0]]

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					list[list[int]]				):
     __UpperCamelCase    							=[]
     for i in range(len(SCREAMING_SNAKE_CASE__				)				):
          __UpperCamelCase    							=[]
          for j in range(len(cells[i]				)				):
               # Get the number of live neighbours
               __UpperCamelCase    							=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(SCREAMING_SNAKE_CASE__				) - 1 and j > 0:
                    neighbour_count += cells[i + 1][j - 1]
               if i < len(SCREAMING_SNAKE_CASE__				) - 1:
                    neighbour_count += cells[i + 1][j]
               if i < len(SCREAMING_SNAKE_CASE__				) - 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.
               __UpperCamelCase    							=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(SCREAMING_SNAKE_CASE__				)
     return next_generation

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					list[list[int]]			,     SCREAMING_SNAKE_CASE__			:					int				):
     __UpperCamelCase    							=[]
     for _ in range(SCREAMING_SNAKE_CASE__				):
          # Create output image
          __UpperCamelCase    							=Image.new('RGB'			,     (len(cells[0]				), len(SCREAMING_SNAKE_CASE__				))				)
          __UpperCamelCase    							=img.load()

          # Save cells to image
          for x in range(len(SCREAMING_SNAKE_CASE__				)				):
               for y in range(len(cells[0]				)				):
                    __UpperCamelCase    							=2_55 - cells[y][x] * 2_55
                    __UpperCamelCase    							=(colour, colour, colour)

        # Save image
          images.append(SCREAMING_SNAKE_CASE__				)
          __UpperCamelCase    							=new_generation(SCREAMING_SNAKE_CASE__				)
     return images


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









# flake8: noqa
# Lint as: python3
UpperCAmelCase__   	=							[
    '''VerificationMode''',
    '''Version''',
    '''disable_progress_bar''',
    '''enable_progress_bar''',
    '''is_progress_bar_enabled''',
    '''experimental''',
]

from .info_utils import VerificationMode
from .logging import disable_progress_bar, enable_progress_bar, is_progress_bar_enabled
from .version import Version
from .experimental import experimental

