

from __future__ import annotations

from PIL import Image

# Define glider example
_SCREAMING_SNAKE_CASE					:  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
_SCREAMING_SNAKE_CASE					:  Optional[Any]             =      [[0, 1, 0], [0, 1, 0], [0, 1, 0]]
def     UpperCAmelCase_       (						_A    ):
     SCREAMING_SNAKE_CASE__   =   []
     for i in range(len(_A    )    ):
          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(_A    ) - 1 and j > 0:
                    neighbour_count += cells[i + 1][j - 1]
               if i < len(_A    ) - 1:
                    neighbour_count += cells[i + 1][j]
               if i < len(_A    ) - 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(_A    )
     return next_generation
def     UpperCAmelCase_       (						_A				,		_A    ):
     SCREAMING_SNAKE_CASE__   =   []
     for _ in range(_A    ):
          # Create output image
          SCREAMING_SNAKE_CASE__   =   Image.new('''RGB'''				,		(len(cells[0]    ), len(_A    ))    )
          SCREAMING_SNAKE_CASE__   =   img.load()

          # Save cells to image
          for x in range(len(_A    )    ):
               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(_A    )
          SCREAMING_SNAKE_CASE__   =   new_generation(_A    )
     return images


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





import datasets

from .evaluate import evaluate


_SCREAMING_SNAKE_CASE					:  Union[str, Any]             =      '''\
@inproceedings{Rajpurkar2016SQuAD10,
  title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},
  author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},
  booktitle={EMNLP},
  year={2016}
}
'''

_SCREAMING_SNAKE_CASE					:  Dict             =      '''
This metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).

Stanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by
crowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,
from the corresponding reading passage, or the question might be unanswerable.
'''

_SCREAMING_SNAKE_CASE					:  str             =      '''
Computes SQuAD scores (F1 and EM).
Args:
    predictions: List of question-answers dictionaries with the following key-values:
        - \'id\': id of the question-answer pair as given in the references (see below)
        - \'prediction_text\': the text of the answer
    references: List of question-answers dictionaries with the following key-values:
        - \'id\': id of the question-answer pair (see above),
        - \'answers\': a Dict in the SQuAD dataset format
            {
                \'text\': list of possible texts for the answer, as a list of strings
                \'answer_start\': list of start positions for the answer, as a list of ints
            }
            Note that answer_start values are not taken into account to compute the metric.
Returns:
    \'exact_match\': Exact match (the normalized answer exactly match the gold answer)
    \'f1\': The F-score of predicted tokens versus the gold answer
Examples:

    >>> predictions = [{\'prediction_text\': \'1976\', \'id\': \'56e10a3be3433e1400422b22\'}]
    >>> references = [{\'answers\': {\'answer_start\': [97], \'text\': [\'1976\']}, \'id\': \'56e10a3be3433e1400422b22\'}]
    >>> squad_metric = datasets.load_metric("squad")
    >>> results = squad_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'exact_match\': 100.0, \'f1\': 100.0}
'''






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,					_KWARGS_DESCRIPTION	)
class 	UpperCAmelCase__		(	datasets.Metric	):






  """simple docstring"""


  def 				lowercase_		(							self						:		List[Any] )		->							Optional[int]:
       return datasets.MetricInfo(
           description=_DESCRIPTION     ,       citation=_CITATION     ,       inputs_description=_KWARGS_DESCRIPTION     ,       features=datasets.Features(
               {
                   '''predictions''': {'''id''': datasets.Value('''string''' ), '''prediction_text''': datasets.Value('''string''' )},
                   '''references''': {
                       '''id''': datasets.Value('''string''' ),
                       '''answers''': datasets.features.Sequence(
                           {
                               '''text''': datasets.Value('''string''' ),
                               '''answer_start''': datasets.Value('''int32''' ),
                           } ),
                   },
               } )     ,       codebase_urls=['''https://rajpurkar.github.io/SQuAD-explorer/''']     ,       reference_urls=['''https://rajpurkar.github.io/SQuAD-explorer/''']     ,       )







  def 				lowercase_		(							self						:		Optional[Any]     ,       __lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		List[Any] )		->							Optional[int]:
       SCREAMING_SNAKE_CASE__   =   {prediction['''id''']: prediction['''prediction_text'''] for prediction in predictions}
       SCREAMING_SNAKE_CASE__   =   [
           {
               '''paragraphs''': [
                   {
                       '''qas''': [
                           {
                               '''answers''': [{'''text''': answer_text} for answer_text in ref['''answers''']['''text''']],
                               '''id''': ref['''id'''],
                           }
                           for ref in references
                       ]
                   }
               ]
           }
       ]
       SCREAMING_SNAKE_CASE__   =   evaluate(dataset=__lowerCamelCase     ,       predictions=__lowerCamelCase )
       return score


