

import inspect
import os
from argparse import ArgumentParser, Namespace
from importlib import import_module

import huggingface_hub
import numpy as np
from packaging import version

from .. import (
    FEATURE_EXTRACTOR_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoImageProcessor,
    AutoProcessor,
    AutoTokenizer,
    is_datasets_available,
    is_tf_available,
    is_torch_available,
)
from ..utils import TF2_WEIGHTS_INDEX_NAME, TF2_WEIGHTS_NAME, logging
from . import BaseTransformersCLICommand


if is_tf_available():
      import tensorflow as tf

      tf.config.experimental.enable_tensor_float_aa_execution(False)

if is_torch_available():
      import torch

if is_datasets_available():
      from datasets import load_dataset


snake_case_					  =	5E-5  # larger error tolerance than in our internal tests, to avoid flaky user-facing errors


def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     Any   )							->       Any:
      """simple docstring"""

      return PTtoTFCommand(
          args.model_name  ,  args.local_dir  ,  args.max_error  ,  args.new_weights  ,  args.no_pr  ,  args.push  ,  args.extra_commit_description  ,  args.override_model_class  ,  )





class      SCREAMING_SNAKE_CASE__      (    UpperCamelCase__				):




    @staticmethod
    def   __lowerCamelCase				( lowercase__      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      str					=	parser.add_parser(
              "pt-to-tf"    ,					help=(
                  "CLI tool to run convert a transformers model from a PyTorch checkpoint to a TensorFlow checkpoint."
                  " Can also be used to validate existing weights without opening PRs, with --no-pr."
              )    ,					)
          train_parser.add_argument(
              "--model-name"    ,					type=__lowerCamelCase    ,					required=__lowerCamelCase    ,					help="The model name, including owner/organization, as seen on the hub."    ,					)
          train_parser.add_argument(
              "--local-dir"    ,					type=__lowerCamelCase    ,					default=""    ,					help="Optional local directory of the model repository. Defaults to /tmp/{model_name}"    ,					)
          train_parser.add_argument(
              "--max-error"    ,					type=__lowerCamelCase    ,					default=__lowerCamelCase    ,					help=(
                  F"Maximum error tolerance. Defaults to {MAX_ERROR}. This flag should be avoided, use at your own risk."
              )    ,					)
          train_parser.add_argument(
              "--new-weights"    ,					action="store_true"    ,					help="Optional flag to create new TensorFlow weights, even if they already exist."    ,					)
          train_parser.add_argument(
              "--no-pr"    ,					action="store_true"    ,					help="Optional flag to NOT open a PR with converted weights."      )
          train_parser.add_argument(
              "--push"    ,					action="store_true"    ,					help="Optional flag to push the weights directly to `main` (requires permissions)"    ,					)
          train_parser.add_argument(
              "--extra-commit-description"    ,					type=__lowerCamelCase    ,					default=""    ,					help="Optional additional commit description to use when opening a PR (e.g. to tag the owner)."    ,					)
          train_parser.add_argument(
              "--override-model-class"    ,					type=__lowerCamelCase    ,					default=__lowerCamelCase    ,					help="If you think you know better than the auto-detector, you can specify the model class here. "
              "Can be either an AutoModel class or a specific model class like BertForSequenceClassification."    ,					)
          train_parser.set_defaults(func=__lowerCamelCase      )




    @staticmethod
    def   __lowerCamelCase				( lowercase__    ,					lowercase__      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      str					=	set(pt_outputs.keys()      )
          SCREAMING_SNAKE_CASE_				:      Dict					=	set(tf_outputs.keys()      )
          if pt_out_attrs != tf_out_attrs:
                raise ValueError(
                    F"The model outputs have different attributes, aborting. (Pytorch: {pt_out_attrs}, TensorFlow:"
                    F" {tf_out_attrs})"      )

          # 2. For each output attribute, computes the difference
          def _find_pt_tf_differences(lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__=""      ):
                # If the current attribute is a tensor, it is a leaf and we make the comparison. Otherwise, we will dig in
                # recursivelly, keeping the name of the attribute.
                if isinstance(__lowerCamelCase    ,					torch.Tensor      ):
                      SCREAMING_SNAKE_CASE_				:      Any					=	np.max(np.abs(pt_out.numpy() - tf_out.numpy()      )      )
                      SCREAMING_SNAKE_CASE_				:      Any					=	tensor_difference
                else:
                      SCREAMING_SNAKE_CASE_				:      Optional[int]					=	attr_name
                      for i, pt_item in enumerate(__lowerCamelCase      ):
                            # If it is a named attribute, we keep the name. Otherwise, just its index.
                            if isinstance(__lowerCamelCase    ,					__lowerCamelCase      ):
                                  SCREAMING_SNAKE_CASE_				:      Dict					=	root_name + pt_item
                                  SCREAMING_SNAKE_CASE_				:      List[Any]					=	tf_out[pt_item]
                                  SCREAMING_SNAKE_CASE_				:      List[Any]					=	pt_out[pt_item]
                            else:
                                  SCREAMING_SNAKE_CASE_				:      Optional[int]					=	root_name + F"[{i}]"
                                  SCREAMING_SNAKE_CASE_				:      List[Any]					=	tf_out[i]
                            SCREAMING_SNAKE_CASE_				:      List[Any]					=	_find_pt_tf_differences(__lowerCamelCase    ,					__lowerCamelCase    ,					__lowerCamelCase    ,					__lowerCamelCase      )

                return differences

          return _find_pt_tf_differences(__lowerCamelCase    ,					__lowerCamelCase    ,					{}      )




    def __init__( self    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					*lowercase__    ,					):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Tuple					=	logging.get_logger("transformers-cli/pt_to_tf"      )
          SCREAMING_SNAKE_CASE_				:      Tuple					=	model_name
          SCREAMING_SNAKE_CASE_				:      List[str]					=	local_dir if local_dir else os.path.join("/tmp"    ,					__lowerCamelCase      )
          SCREAMING_SNAKE_CASE_				:      str					=	max_error
          SCREAMING_SNAKE_CASE_				:      Dict					=	new_weights
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	no_pr
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	push
          SCREAMING_SNAKE_CASE_				:      int					=	extra_commit_description
          SCREAMING_SNAKE_CASE_				:      Any					=	override_model_class




    def   __lowerCamelCase				( self    ,					lowercase__    ,					lowercase__    ,					lowercase__      ):






          """simple docstring"""






          def _get_audio_input():
                SCREAMING_SNAKE_CASE_				:      Dict					=	load_dataset("hf-internal-testing/librispeech_asr_dummy"    ,					"clean"    ,					split="validation"      )
                SCREAMING_SNAKE_CASE_				:      List[Any]					=	ds.sort("id"      ).select(range(2      )      )[:2]["audio"]
                SCREAMING_SNAKE_CASE_				:      List[Any]					=	[x["array"] for x in speech_samples]
                return raw_samples

          SCREAMING_SNAKE_CASE_				:      List[str]					=	type(pt_model.config      )
          if model_config_class in PROCESSOR_MAPPING:
                SCREAMING_SNAKE_CASE_				:      Optional[int]					=	AutoProcessor.from_pretrained(self._local_dir      )
                if model_config_class in TOKENIZER_MAPPING and processor.tokenizer.pad_token is None:
                      SCREAMING_SNAKE_CASE_				:      Any					=	processor.tokenizer.eos_token
          elif model_config_class in IMAGE_PROCESSOR_MAPPING:
                SCREAMING_SNAKE_CASE_				:      int					=	AutoImageProcessor.from_pretrained(self._local_dir      )
          elif model_config_class in FEATURE_EXTRACTOR_MAPPING:
                SCREAMING_SNAKE_CASE_				:      Tuple					=	AutoFeatureExtractor.from_pretrained(self._local_dir      )
          elif model_config_class in TOKENIZER_MAPPING:
                SCREAMING_SNAKE_CASE_				:      str					=	AutoTokenizer.from_pretrained(self._local_dir      )
                if processor.pad_token is None:
                      SCREAMING_SNAKE_CASE_				:      List[Any]					=	processor.eos_token
          else:
                raise ValueError(F"Unknown data processing type (model config type: {model_config_class})"      )

          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	set(inspect.signature(pt_model.forward      ).parameters.keys()      )
          SCREAMING_SNAKE_CASE_				:      List[str]					=	{}
          if "input_ids" in model_forward_signature:
                processor_inputs.update(
                    {
                        "text": ["Hi there!", "I am a batch with more than one row and different input lengths."],
                        "padding": True,
                        "truncation": True,
                    }      )
          if "pixel_values" in model_forward_signature:
                SCREAMING_SNAKE_CASE_				:      str					=	load_dataset("cifar10"    ,					"plain_text"    ,					split="test"      )[:2]["img"]
                processor_inputs.update({"images": sample_images}      )
          if "input_features" in model_forward_signature:
                SCREAMING_SNAKE_CASE_				:      List[str]					=	inspect.signature(processor.feature_extractor      ).parameters
                # Pad to the largest input length by default but take feature extractor default
                # padding value if it exists e.g. "max_length" and is not False or None
                if "padding" in feature_extractor_signature:
                      SCREAMING_SNAKE_CASE_				:      List[Any]					=	feature_extractor_signature["padding"].default
                      if default_strategy is not False and default_strategy is not None:
                            SCREAMING_SNAKE_CASE_				:      List[Any]					=	default_strategy
                      else:
                            SCREAMING_SNAKE_CASE_				:      List[str]					=	True
                else:
                      SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	True
                processor_inputs.update({"audio": _get_audio_input(), "padding": padding_strategy}      )
          if "input_values" in model_forward_signature:  # Wav2Vec2 audio input
                processor_inputs.update({"audio": _get_audio_input(), "padding": True}      )
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	processor(**__lowerCamelCase    ,					return_tensors="pt"      )
          SCREAMING_SNAKE_CASE_				:      str					=	processor(**__lowerCamelCase    ,					return_tensors="tf"      )

          # Extra input requirements, in addition to the input modality
          if (
              config.is_encoder_decoder
              or (hasattr(__lowerCamelCase    ,					"encoder"      ) and hasattr(__lowerCamelCase    ,					"decoder"      ))
              or "decoder_input_ids" in tf_dummy_inputs
          ):
                SCREAMING_SNAKE_CASE_				:      Optional[int]					=	np.asarray([[1], [1]]    ,					dtype=__lowerCamelCase      ) * (pt_model.config.decoder_start_token_id or 0)
                pt_input.update({"decoder_input_ids": torch.tensor(__lowerCamelCase      )}      )
                tf_input.update({"decoder_input_ids": tf.convert_to_tensor(__lowerCamelCase      )}      )

          return pt_input, tf_input







    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          if version.parse(huggingface_hub.__version__      ) < version.parse("0.9.0"      ):
                raise ImportError(
                    "The huggingface_hub version must be >= 0.9.0 to use this command. Please update your huggingface_hub"
                    " installation."      )
          else:
                from huggingface_hub import Repository, create_commit
                from huggingface_hub._commit_api import CommitOperationAdd

          # Fetch remote data
          SCREAMING_SNAKE_CASE_				:      int					=	Repository(local_dir=self._local_dir    ,					clone_from=self._model_name      )

          # Load config and get the appropriate architecture -- the latter is needed to convert the head's weights
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	AutoConfig.from_pretrained(self._local_dir      )
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	config.architectures
          if self._override_model_class is not None:
                if self._override_model_class.startswith("TF"      ):
                      SCREAMING_SNAKE_CASE_				:      Tuple					=	[self._override_model_class[2:]]
                else:
                      SCREAMING_SNAKE_CASE_				:      List[Any]					=	[self._override_model_class]
                try:
                      SCREAMING_SNAKE_CASE_				:      Dict					=	getattr(import_module("transformers"      )    ,					architectures[0]      )
                except AttributeError:
                      raise ValueError(F"Model class {self._override_model_class} not found in transformers."      )
                try:
                      SCREAMING_SNAKE_CASE_				:      str					=	getattr(import_module("transformers"      )    ,					"TF" + architectures[0]      )
                except AttributeError:
                      raise ValueError(F"TF model class TF{self._override_model_class} not found in transformers."      )
          elif architectures is None:  # No architecture defined -- use auto classes
                SCREAMING_SNAKE_CASE_				:      Any					=	getattr(import_module("transformers"      )    ,					"AutoModel"      )
                SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	getattr(import_module("transformers"      )    ,					"TFAutoModel"      )
                self._logger.warning("No detected architecture, using AutoModel/TFAutoModel"      )
          else:  # Architecture defined -- use it
                if len(__lowerCamelCase      ) > 1:
                      raise ValueError(F"More than one architecture was found, aborting. (architectures = {architectures})"      )
                self._logger.warning(F"Detected architecture: {architectures[0]}"      )
                SCREAMING_SNAKE_CASE_				:      List[Any]					=	getattr(import_module("transformers"      )    ,					architectures[0]      )
                try:
                      SCREAMING_SNAKE_CASE_				:      str					=	getattr(import_module("transformers"      )    ,					"TF" + architectures[0]      )
                except AttributeError:
                      raise AttributeError(F"The TensorFlow equivalent of {architectures[0]} doesn't exist in transformers."      )

        # Check the TF dummy inputs to see what keys we need in the forward pass
          SCREAMING_SNAKE_CASE_				:      List[str]					=	tf_class.from_config(__lowerCamelCase      )
          SCREAMING_SNAKE_CASE_				:      Any					=	tf_from_pt_model.dummy_inputs

          del tf_from_pt_model  # Try to keep only one model in memory at a time

          # Load the model and get some basic inputs
          SCREAMING_SNAKE_CASE_				:      List[str]					=	pt_class.from_pretrained(self._local_dir      )
          pt_model.eval()

          SCREAMING_SNAKE_CASE_				:      str					=	self.get_inputs(__lowerCamelCase    ,					__lowerCamelCase    ,					__lowerCamelCase      )

          with torch.no_grad():
                SCREAMING_SNAKE_CASE_				:      List[str]					=	pt_model(**__lowerCamelCase    ,					output_hidden_states=__lowerCamelCase      )
          del pt_model  # will no longer be used, and may have a large memory footprint

          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	tf_class.from_pretrained(self._local_dir    ,					from_pt=__lowerCamelCase      )
          SCREAMING_SNAKE_CASE_				:      List[str]					=	tf_from_pt_model(**__lowerCamelCase    ,					output_hidden_states=__lowerCamelCase    ,					training=__lowerCamelCase      )

          # Confirms that cross loading PT weights into TF worked.
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	self.find_pt_tf_differences(__lowerCamelCase    ,					__lowerCamelCase      )
          SCREAMING_SNAKE_CASE_				:      Tuple					=	{k: v for k, v in crossload_differences.items() if "hidden" not in k}
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	{k: v for k, v in crossload_differences.items() if "hidden" in k}
          if len(__lowerCamelCase      ) == 0 and architectures is not None:
                raise ValueError(
                    F"Something went wrong -- the config file has architectures ({architectures}), but no model head"
                    " output was found. All outputs start with 'hidden'"      )
          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	max(output_differences.values()      ) if output_differences else 0.0
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	max(hidden_differences.values()      )
          if max_crossload_output_diff > self._max_error or max_crossload_hidden_diff > self._max_error:
                raise ValueError(
                    "The cross-loaded TensorFlow model has different outputs, something went wrong!\n"
                    + F"\nList of maximum output differences above the threshold ({self._max_error}):\n"
                    + "\n".join([F"{k}: {v:.3e}" for k, v in output_differences.items() if v > self._max_error]      )
                    + F"\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n"
                    + "\n".join([F"{k}: {v:.3e}" for k, v in hidden_differences.items() if v > self._max_error]      )      )

          # Save the weights in a TF format (if needed) and confirms that the results are still good
          SCREAMING_SNAKE_CASE_				:      List[str]					=	os.path.join(self._local_dir    ,					__lowerCamelCase      )
          SCREAMING_SNAKE_CASE_				:      Any					=	os.path.join(self._local_dir    ,					__lowerCamelCase      )
          if (not os.path.exists(__lowerCamelCase      ) and not os.path.exists(__lowerCamelCase      )) or self._new_weights:
                tf_from_pt_model.save_pretrained(self._local_dir      )
          del tf_from_pt_model  # will no longer be used, and may have a large memory footprint

          SCREAMING_SNAKE_CASE_				:      str					=	tf_class.from_pretrained(self._local_dir      )
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	tf_model(**__lowerCamelCase    ,					output_hidden_states=__lowerCamelCase      )

          SCREAMING_SNAKE_CASE_				:      List[Any]					=	self.find_pt_tf_differences(__lowerCamelCase    ,					__lowerCamelCase      )
          SCREAMING_SNAKE_CASE_				:      List[Any]					=	{k: v for k, v in conversion_differences.items() if "hidden" not in k}
          SCREAMING_SNAKE_CASE_				:      Tuple					=	{k: v for k, v in conversion_differences.items() if "hidden" in k}
          if len(__lowerCamelCase      ) == 0 and architectures is not None:
                raise ValueError(
                    F"Something went wrong -- the config file has architectures ({architectures}), but no model head"
                    " output was found. All outputs start with 'hidden'"      )
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	max(output_differences.values()      ) if output_differences else 0.0
          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	max(hidden_differences.values()      )
          if max_conversion_output_diff > self._max_error or max_conversion_hidden_diff > self._max_error:
                raise ValueError(
                    "The converted TensorFlow model has different outputs, something went wrong!\n"
                    + F"\nList of maximum output differences above the threshold ({self._max_error}):\n"
                    + "\n".join([F"{k}: {v:.3e}" for k, v in output_differences.items() if v > self._max_error]      )
                    + F"\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n"
                    + "\n".join([F"{k}: {v:.3e}" for k, v in hidden_differences.items() if v > self._max_error]      )      )

          SCREAMING_SNAKE_CASE_				:      str					=	"Update TF weights" if self._new_weights else "Add TF weights"
          if self._push:
                repo.git_add(auto_lfs_track=__lowerCamelCase      )
                repo.git_commit(__lowerCamelCase      )
                repo.git_push(blocking=__lowerCamelCase      )  # this prints a progress bar with the upload
                self._logger.warning(F"TF weights pushed into {self._model_name}"      )
          elif not self._no_pr:
                self._logger.warning("Uploading the weights into a new PR..."      )
                SCREAMING_SNAKE_CASE_				:      Tuple					=	(
                    "Model converted by the [`transformers`' `pt_to_tf`"
                    " CLI](https://github.com/huggingface/transformers/blob/main/src/transformers/commands/pt_to_tf.py). "
                    "All converted model outputs and hidden layers were validated against its PyTorch counterpart.\n\n"
                    F"Maximum crossload output difference={max_crossload_output_diff:.3e}; "
                    F"Maximum crossload hidden layer difference={max_crossload_hidden_diff:.3e};\n"
                    F"Maximum conversion output difference={max_conversion_output_diff:.3e}; "
                    F"Maximum conversion hidden layer difference={max_conversion_hidden_diff:.3e};\n"
                )
                if self._max_error > MAX_ERROR:
                      commit_descrition += (
                          F"\n\nCAUTION: The maximum admissible error was manually increased to {self._max_error}!"
                      )
                if self._extra_commit_description:
                      commit_descrition += "\n\n" + self._extra_commit_description

                # sharded model -> adds all related files (index and .h5 shards)
                if os.path.exists(__lowerCamelCase      ):
                      SCREAMING_SNAKE_CASE_				:      Dict					=	[
                          CommitOperationAdd(path_in_repo=__lowerCamelCase    ,					path_or_fileobj=__lowerCamelCase      )
                      ]
                      for shard_path in tf.io.gfile.glob(self._local_dir + "/tf_model-*.h5"      ):
                            operations += [
                                CommitOperationAdd(path_in_repo=os.path.basename(__lowerCamelCase      )    ,					path_or_fileobj=__lowerCamelCase      )
                            ]
                else:
                      SCREAMING_SNAKE_CASE_				:      int					=	[CommitOperationAdd(path_in_repo=__lowerCamelCase    ,					path_or_fileobj=__lowerCamelCase      )]

                SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	create_commit(
                    repo_id=self._model_name    ,					operations=__lowerCamelCase    ,					commit_message=__lowerCamelCase    ,					commit_description=__lowerCamelCase    ,					repo_type="model"    ,					create_pr=__lowerCamelCase    ,					).pr_url
                self._logger.warning(F"PR open in {hub_pr_url}"      )




'''simple docstring'''






from __future__ import annotations

from PIL import Image

# Define the first generation of cells
# fmt: off
snake_case_					  =	[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]


def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     int   )							->       list[int]:
      """simple docstring"""

      return [int(SCREAMING_SNAKE_CASE_   ) for c in F"{ruleset:08}"[:8]]


def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     list[list[int]]  ,  SCREAMING_SNAKE_CASE_					:     list[int]  ,  SCREAMING_SNAKE_CASE_					:     int   )							->       list[int]:
      """simple docstring"""

      SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	len(cells[0]   )  # 31
      SCREAMING_SNAKE_CASE_				:      Dict					=	[]
      for i in range(SCREAMING_SNAKE_CASE_   ):
            # Get the neighbors of each cell
            # Handle neighbours outside bounds by using 0 as their value
            SCREAMING_SNAKE_CASE_				:      Any					=	0 if i == 0 else cells[time][i - 1]
            SCREAMING_SNAKE_CASE_				:      Dict					=	0 if i == population - 1 else cells[time][i + 1]
            # Define a new cell and add it to the new generation
            SCREAMING_SNAKE_CASE_				:      List[Any]					=	7 - int(F"{left_neighbor}{cells[time][i]}{right_neighbor}"  ,  2   )
            next_generation.append(rule[situation]   )
      return next_generation


def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     list[list[int]]   )							->       Image.Image:
      """simple docstring"""

      SCREAMING_SNAKE_CASE_				:      Tuple					=	Image.new("RGB"  ,  (len(cells[0]   ), len(SCREAMING_SNAKE_CASE_   ))   )
      SCREAMING_SNAKE_CASE_				:      Optional[int]					=	img.load()
      # Generates image
      for w in range(img.width   ):
            for h in range(img.height   ):
                  SCREAMING_SNAKE_CASE_				:      List[Any]					=	2_5_5 - int(2_5_5 * cells[h][w]   )
                  SCREAMING_SNAKE_CASE_				:      Optional[int]					=	(color, color, color)
      return img


if __name__ == "__main__":
      snake_case_					  =	bin(int(input('Rule:\n').strip()))[2:]
      snake_case_					  =	format_ruleset(int(rule_num))
      for time in range(1_6):
            CELLS.append(new_generation(CELLS, rule, time))
      snake_case_					  =	generate_image(CELLS)
      # Uncomment to save the image
      # img.save(f"rule_{rule_num}.png")
      img.show()

