




from __future__ import annotations

from PIL import Image

# Define glider example
__A						:							Dict							=  [
    [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						:							int							=  [[0, 1, 0], [0, 1, 0], [0, 1, 0]]
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					[]
			for i in range(len(SCREAMING_SNAKE_CASE   )   ):
						SCREAMING_SNAKE_CASE           =					[]
						for j in range(len(cells[i]   )   ):
									# Get the number of live neighbours
									SCREAMING_SNAKE_CASE           =					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.
									SCREAMING_SNAKE_CASE           =					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 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					[]
			for _ in range(SCREAMING_SNAKE_CASE   ):
						# Create output image
						SCREAMING_SNAKE_CASE           =					Image.new("""RGB"""					,	(len(cells[0]   ), len(SCREAMING_SNAKE_CASE   ))   )
						SCREAMING_SNAKE_CASE           =					img.load()

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

        # Save image
						images.append(SCREAMING_SNAKE_CASE   )
						SCREAMING_SNAKE_CASE           =					new_generation(SCREAMING_SNAKE_CASE   )
			return images


if __name__ == "__main__":
		__A						:							str							=  generate_images(GLIDER, 1_6)
		images[0].save("""out.gif""", save_all=True, append_images=images[1:])












def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			if not all(char in """01""" for char in bin_string   ):
						raise ValueError("""Non-binary value was passed to the function"""   )
			if not bin_string:
						raise ValueError("""Empty string was passed to the function"""   )
			SCREAMING_SNAKE_CASE           =					""""""
			while len(SCREAMING_SNAKE_CASE   ) % 3 != 0:
						SCREAMING_SNAKE_CASE           =					"""0""" + bin_string
			SCREAMING_SNAKE_CASE           =					[
			    bin_string[index : index + 3]
			    for index in range(len(SCREAMING_SNAKE_CASE   )   )
			    if index % 3 == 0
			]
			for bin_group in bin_string_in_3_list:
						SCREAMING_SNAKE_CASE           =					0
						for index, val in enumerate(SCREAMING_SNAKE_CASE   ):
									oct_val += int(2 ** (2 - index) * int(SCREAMING_SNAKE_CASE   )   )
						oct_string += str(SCREAMING_SNAKE_CASE   )
			return oct_string


if __name__ == "__main__":
		from doctest import testmod

		testmod()






