





'''simple docstring'''


import datasets

from .evaluate import evaluate


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

_SCREAMING_SNAKE_CASE									=				"\nThis metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).\n\nStanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by\ncrowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,\nfrom the corresponding reading passage, or the question might be unanswerable.\n"

_SCREAMING_SNAKE_CASE									=				"\nComputes SQuAD scores (F1 and EM).\nArgs:\n    predictions: List of question-answers dictionaries with the following key-values:\n        - 'id': id of the question-answer pair as given in the references (see below)\n        - 'prediction_text': the text of the answer\n    references: List of question-answers dictionaries with the following key-values:\n        - 'id': id of the question-answer pair (see above),\n        - 'answers': a Dict in the SQuAD dataset format\n            {\n                'text': list of possible texts for the answer, as a list of strings\n                'answer_start': list of start positions for the answer, as a list of ints\n            }\n            Note that answer_start values are not taken into account to compute the metric.\nReturns:\n    'exact_match': Exact match (the normalized answer exactly match the gold answer)\n    'f1': The F-score of predicted tokens versus the gold answer\nExamples:\n\n    >>> predictions = [{'prediction_text': '1976', 'id': '56e10a3be3433e1400422b22'}]\n    >>> references = [{'answers': {'answer_start': [97], 'text': ['1976']}, 'id': '56e10a3be3433e1400422b22'}]\n    >>> squad_metric = datasets.load_metric(\"squad\")\n    >>> results = squad_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'exact_match': 100.0, 'f1': 100.0}\n"

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




 def 				_snake_case (						self		)     ->				List[Any]:
     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 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase		)     ->				int:
     _lowerCAmelCase						      =   {prediction["id"]: prediction["prediction_text"] for prediction in predictions}
     _lowerCAmelCase						      =   [
         {
             "paragraphs": [
                 {
                     "qas": [
                         {
                             "answers": [{"text": answer_text} for answer_text in ref["answers"]["text"]],
                             "id": ref["id"],
                         }
                         for ref in references
                     ]
                 }
             ]
         }
     ]
     _lowerCAmelCase						      =   evaluate(dataset=_lowerCAmelCase      ,  predictions=_lowerCAmelCase		)
     return score








'''simple docstring'''



from typing import Any






class 							_a				:





       '''simple docstring'''






       def __init__(      self,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      str    					=						data
             SCREAMING_SNAKE_CASE   :      Any    					=						None







       def __repr__(      self  ):







             '''simple docstring'''







             return F"Node({self.data})"






class 							_a				:





       '''simple docstring'''






       def __init__(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[str]    					=						None







       def __iter__(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						self.head
             while node:
                   yield node.data
                   SCREAMING_SNAKE_CASE   :      List[str]    					=						node.next







       def __len__(      self  ):







             '''simple docstring'''







             return sum(1 for _ in self  )







       def __repr__(      self  ):







             '''simple docstring'''







             return "->".join([str(A  ) for item in self]  )







       def __getitem__(      self,							A  ):







             '''simple docstring'''







             if not 0 <= index < len(self  ):
                   raise ValueError('list index out of range.'  )
             for i, node in enumerate(self  ):
                   if i == index:
                         return node
             return None







       def __setitem__(      self,							A,							A  ):







             '''simple docstring'''







             if not 0 <= index < len(self  ):
                   raise ValueError('list index out of range.'  )
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						self.head
             for _ in range(A  ):
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						current.next
             SCREAMING_SNAKE_CASE   :      Any    					=						data







       def        UpperCamelCase_							(      self,							A  ):







             '''simple docstring'''







             self.insert_nth(len(self  ),							A  )







       def        UpperCamelCase_							(      self,							A  ):







             '''simple docstring'''







             self.insert_nth(0,							A  )







       def        UpperCamelCase_							(      self,							A,							A  ):







             '''simple docstring'''







             if not 0 <= index <= len(self  ):
                   raise IndexError('list index out of range'  )
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						Node(A  )
             if self.head is None:
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						new_node
             elif index == 0:
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						self.head  # link new_node to head
                   SCREAMING_SNAKE_CASE   :      Tuple    					=						new_node
             else:
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						self.head
                   for _ in range(index - 1  ):
                         SCREAMING_SNAKE_CASE   :      str    					=						temp.next
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						temp.next
                   SCREAMING_SNAKE_CASE   :      List[str]    					=						new_node







       def        UpperCamelCase_							(      self  ):  # print every node data







             '''simple docstring'''







             print(self  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             return self.delete_nth(0  )







       def        UpperCamelCase_							(      self  ):  # delete from tail







             '''simple docstring'''







             return self.delete_nth(len(self  ) - 1  )







       def        UpperCamelCase_							(      self,							A = 0  ):







             '''simple docstring'''







             if not 0 <= index <= len(self  ) - 1:  # test if index is valid
                   raise IndexError('List index out of range.'  )
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						self.head  # default first node
             if index == 0:
                   SCREAMING_SNAKE_CASE   :      List[str]    					=						self.head.next
             else:
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						self.head
                   for _ in range(index - 1  ):
                         SCREAMING_SNAKE_CASE   :      Any    					=						temp.next
                   SCREAMING_SNAKE_CASE   :      List[str]    					=						temp.next
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						temp.next.next
             return delete_node.data







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             return self.head is None







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      int    					=						None
             SCREAMING_SNAKE_CASE   :      Any    					=						self.head

             while current:
                   # Store the current node's next node.
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						current.next
                   # Make the current node's next point backwards
                   SCREAMING_SNAKE_CASE   :      int    					=						prev
                   # Make the previous node be the current node
                   SCREAMING_SNAKE_CASE   :      int    					=						current
                   # Make the current node the next node (to progress iteration)
                   SCREAMING_SNAKE_CASE   :      List[Any]    					=						next_node
             # Return prev in order to put the head at the end
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						prev




def   lowercase__(			):

      """simple docstring"""






      SCREAMING_SNAKE_CASE   :      Dict    					=						LinkedList()
      assert linked_list.is_empty() is True
      assert str(__UpperCamelCase    ) == ""

      try:
            linked_list.delete_head()
            raise AssertionError  # This should not happen.
      except IndexError:
            assert True  # This should happen.

      try:
            linked_list.delete_tail()
            raise AssertionError  # This should not happen.
      except IndexError:
            assert True  # This should happen.

      for i in range(10    ):
            assert len(__UpperCamelCase    ) == i
            linked_list.insert_nth(__UpperCamelCase      ,i + 1    )
      assert str(__UpperCamelCase    ) == "->".join(str(__UpperCamelCase    ) for i in range(1      ,11    )    )

      linked_list.insert_head(0    )
      linked_list.insert_tail(11    )
      assert str(__UpperCamelCase    ) == "->".join(str(__UpperCamelCase    ) for i in range(0      ,12    )    )

      assert linked_list.delete_head() == 0
      assert linked_list.delete_nth(9    ) == 10
      assert linked_list.delete_tail() == 11
      assert len(__UpperCamelCase    ) == 9
      assert str(__UpperCamelCase    ) == "->".join(str(__UpperCamelCase    ) for i in range(1      ,10    )    )

      assert all(linked_list[i] == i + 1 for i in range(0      ,9    )    ) is True

      for i in range(0      ,9    ):
            SCREAMING_SNAKE_CASE   :      Any    					=						-i
      assert all(linked_list[i] == -i for i in range(0      ,9    )    ) is True

      linked_list.reverse()
      assert str(__UpperCamelCase    ) == "->".join(str(__UpperCamelCase    ) for i in range(-8      ,1    )    )




def   lowercase__(			):

      """simple docstring"""






      SCREAMING_SNAKE_CASE   :      List[str]    					=						[
          -9,
          1_00,
          Node(77_34_51_12    ),
          'dlrow olleH',
          7,
          55_55,
          0,
          -1_9_2.5_5_5_5_5,
          'Hello, world!',
          7_7.9,
          Node(10    ),
          None,
          None,
          1_2.2_0,
      ]
      SCREAMING_SNAKE_CASE   :      Optional[int]    					=						LinkedList()

      for i in test_input:
            linked_list.insert_tail(__UpperCamelCase    )

      # Check if it's empty or not
      assert linked_list.is_empty() is False
      assert (
          str(__UpperCamelCase    ) == "-9->100->Node(77345112)->dlrow olleH->7->5555->0->"
          "-192.55555->Hello, world!->77.9->Node(10)->None->None->12.2"
      )

      # Delete the head
      SCREAMING_SNAKE_CASE   :      str    					=						linked_list.delete_head()
      assert result == -9
      assert (
          str(__UpperCamelCase    ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
          "Hello, world!->77.9->Node(10)->None->None->12.2"
      )

      # Delete the tail
      SCREAMING_SNAKE_CASE   :      Dict    					=						linked_list.delete_tail()
      assert result == 1_2.2
      assert (
          str(__UpperCamelCase    ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
          "Hello, world!->77.9->Node(10)->None->None"
      )

      # Delete a node in specific location in linked list
      SCREAMING_SNAKE_CASE   :      str    					=						linked_list.delete_nth(10    )
      assert result is None
      assert (
          str(__UpperCamelCase    ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
          "Hello, world!->77.9->Node(10)->None"
      )

      # Add a Node instance to its head
      linked_list.insert_head(Node('Hello again, world!'    )    )
      assert (
          str(__UpperCamelCase    )
          == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
          "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None"
      )

      # Add None to its tail
      linked_list.insert_tail(__UpperCamelCase    )
      assert (
          str(__UpperCamelCase    )
          == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
          "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None->None"
      )

      # Reverse the linked list
      linked_list.reverse()
      assert (
          str(__UpperCamelCase    )
          == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
          "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
      )




def   lowercase__(			):

      """simple docstring"""






      from doctest import testmod

      testmod()

      SCREAMING_SNAKE_CASE   :      Dict    					=						LinkedList()
      linked_list.insert_head(input('Inserting 1st at head '    ).strip()    )
      linked_list.insert_head(input('Inserting 2nd at head '    ).strip()    )
      print('\nPrint list:'    )
      linked_list.print_list()
      linked_list.insert_tail(input('\nInserting 1st at tail '    ).strip()    )
      linked_list.insert_tail(input('Inserting 2nd at tail '    ).strip()    )
      print('\nPrint list:'    )
      linked_list.print_list()
      print('\nDelete head'    )
      linked_list.delete_head()
      print('Delete tail'    )
      linked_list.delete_tail()
      print('\nPrint list:'    )
      linked_list.print_list()
      print('\nReverse linked list'    )
      linked_list.reverse()
      print('\nPrint list:'    )
      linked_list.print_list()
      print('\nString representation of linked list:'    )
      print(__UpperCamelCase    )
      print('\nReading/changing Node data using indexing:'    )
      print(f"Element at Position 1: {linked_list[1]}"    )
      SCREAMING_SNAKE_CASE   :      str    					=						input('Enter New Value: '    ).strip()
      print('New list:'    )
      print(__UpperCamelCase    )
      print(f"length of linked_list is : {len(__UpperCamelCase    )}"    )


if __name__ == "__main__":
      main()


