





from typing import Any
class 							SCREAMING_SNAKE_CASE  :


   def __init__(       self     :							Tuple     ,	a     :							Optional[int]			)->  int:





     """simple docstring"""







     lowercase__           =    data
     lowercase__           =    None


   def __repr__(       self     :							Dict			)->  str:





     """simple docstring"""







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






class 							SCREAMING_SNAKE_CASE  :


   def __init__(       self     :							Optional[int]			)->  Optional[Any]:





     """simple docstring"""







     lowercase__           =    None


   def __iter__(       self     :							Union[str, Any]			)->  Any:





     """simple docstring"""







     lowercase__           =    self.head
     while node:
       yield node.data
       lowercase__           =    node.next


   def __len__(       self     :							Tuple			)->  int:





     """simple docstring"""







     return sum(1 for _ in self			)


   def __repr__(       self     :							List[Any]			)->  str:





     """simple docstring"""







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


   def __getitem__(       self     :							Optional[int]     ,	a     :							str			)->  Any:





     """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     :							Union[str, Any]     ,	a     :							Dict     ,	a     :							int			)->  None:





     """simple docstring"""







     if not 0 <= index < len(self			):
       raise ValueError('list index out of range.'			)
     lowercase__           =    self.head
     for _ in range(lowerCAmelCase__			):
       lowercase__           =    current.next
     lowercase__           =    data


   def 			SCREAMING_SNAKE_CASE_				(       self     :							Optional[int]     ,	a     :							Union[str, Any]			)->  None:





     """simple docstring"""







     self.insert_nth(len(self			)     ,	lowerCAmelCase__			)


   def 			SCREAMING_SNAKE_CASE_				(       self     :							List[Any]     ,	a     :							Any			)->  None:





     """simple docstring"""







     self.insert_nth(0     ,	lowerCAmelCase__			)


   def 			SCREAMING_SNAKE_CASE_				(       self     :							Dict     ,	a     :							List[str]     ,	a     :							List[Any]			)->  None:





     """simple docstring"""







     if not 0 <= index <= len(self			):
       raise IndexError('list index out of range'			)
     lowercase__           =    Node(lowerCAmelCase__			)
     if self.head is None:
       lowercase__           =    new_node
     elif index == 0:
       lowercase__           =    self.head  # link new_node to head
       lowercase__           =    new_node
     else:
       lowercase__           =    self.head
       for _ in range(index - 1			):
         lowercase__           =    temp.next
       lowercase__           =    temp.next
       lowercase__           =    new_node


   def 			SCREAMING_SNAKE_CASE_				(       self     :							str			)->  None:  # print every node data





     """simple docstring"""







     print(self			)


   def 			SCREAMING_SNAKE_CASE_				(       self     :							Optional[int]			)->  Any:





     """simple docstring"""







     return self.delete_nth(0			)


   def 			SCREAMING_SNAKE_CASE_				(       self     :							Tuple			)->  Any:  # delete from tail





     """simple docstring"""







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


   def 			SCREAMING_SNAKE_CASE_				(       self     :							Optional[int]     ,	a     :							List[str] = 0			)->  Any:





     """simple docstring"""







     if not 0 <= index <= len(self			) - 1:  # test if index is valid
       raise IndexError('List index out of range.'			)
     lowercase__           =    self.head  # default first node
     if index == 0:
       lowercase__           =    self.head.next
     else:
       lowercase__           =    self.head
       for _ in range(index - 1			):
         lowercase__           =    temp.next
       lowercase__           =    temp.next
       lowercase__           =    temp.next.next
     return delete_node.data


   def 			SCREAMING_SNAKE_CASE_				(       self     :							int			)->  bool:





     """simple docstring"""







     return self.head is None


   def 			SCREAMING_SNAKE_CASE_				(       self     :							str			)->  None:





     """simple docstring"""







     lowercase__           =    None
     lowercase__           =    self.head

     while current:
       # Store the current node's next node.
       lowercase__           =    current.next
       # Make the current node's next point backwards
       lowercase__           =    prev
       # Make the previous node be the current node
       lowercase__           =    current
       # Make the current node the next node (to progress iteration)
       lowercase__           =    next_node
     # Return prev in order to put the head at the end
     lowercase__           =    prev






def      __UpperCamelCase    ()							->  Union[str, Any]:
  lowercase__           =    LinkedList()
  assert linked_list.is_empty() is True
  assert str(_SCREAMING_SNAKE_CASE						) == ""

  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(_SCREAMING_SNAKE_CASE						) == i
    linked_list.insert_nth(_SCREAMING_SNAKE_CASE						,		i + 1						)
  assert str(_SCREAMING_SNAKE_CASE						) == "->".join(str(_SCREAMING_SNAKE_CASE						) for i in range(1						,		11						)						)

  linked_list.insert_head(0						)
  linked_list.insert_tail(11						)
  assert str(_SCREAMING_SNAKE_CASE						) == "->".join(str(_SCREAMING_SNAKE_CASE						) 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(_SCREAMING_SNAKE_CASE						) == 9
  assert str(_SCREAMING_SNAKE_CASE						) == "->".join(str(_SCREAMING_SNAKE_CASE						) 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						):
    lowercase__           =    -i
  assert all(linked_list[i] == -i for i in range(0						,		9						)						) is True

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




def      __UpperCamelCase    ()							->  str:
  lowercase__           =    [
      -9,
      100,
      Node(77345112						),
      'dlrow olleH',
      7,
      5555,
      0,
      -1_9_2.5_5_5_5_5,
      'Hello, world!',
      7_7.9,
      Node(10						),
      None,
      None,
      1_2.2_0,
  ]
  lowercase__           =    LinkedList()

  for i in test_input:
    linked_list.insert_tail(_SCREAMING_SNAKE_CASE						)

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

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

  # Delete the tail
  lowercase__           =    linked_list.delete_tail()
  assert result == 1_2.2
  assert (
      str(_SCREAMING_SNAKE_CASE						) == "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
  lowercase__           =    linked_list.delete_nth(10						)
  assert result is None
  assert (
      str(_SCREAMING_SNAKE_CASE						) == "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(_SCREAMING_SNAKE_CASE						)
      == "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(_SCREAMING_SNAKE_CASE						)
  assert (
      str(_SCREAMING_SNAKE_CASE						)
      == "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(_SCREAMING_SNAKE_CASE						)
      == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
      "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
  )




def      __UpperCamelCase    ()							->  List[Any]:
  from doctest import testmod

  testmod()

  lowercase__           =    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(_SCREAMING_SNAKE_CASE						)
  print('\nReading/changing Node data using indexing:'						)
  print(F"""Element at Position 1: {linked_list[1]}"""						)
  lowercase__           =    input('Enter New Value: '						).strip()
  print('New list:'						)
  print(_SCREAMING_SNAKE_CASE						)
  print(F"""length of linked_list is : {len(_SCREAMING_SNAKE_CASE						)}"""						)


if __name__ == "__main__":
      main()



import argparse
import json

import numpy
import torch

from transformers.models.xlm.tokenization_xlm import VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()





def 							UpperCAmelCase		(       lowercase				,     lowercase				):







				"""simple docstring"""



				__lowercase					     =				torch.load(lowercase				,     map_location='''cpu'''				)

				__lowercase					     =				chkpt['''model''']

				# We have the base model one level deeper than the original XLM repository
				__lowercase					     =				{}
				for k, v in state_dict.items():
								if "pred_layer" in k:
												__lowercase					     =				v
								else:
												__lowercase					     =				v

				__lowercase					     =				chkpt['''params''']
				__lowercase					     =				{n: v for n, v in config.items() if not isinstance(lowercase				,     (torch.FloatTensor, numpy.ndarray)				)}

				__lowercase					     =				chkpt['''dico_word2id''']
				__lowercase					     =				{s + '''</w>''' if s.find('''@@'''				) == -1 and i > 13 else s.replace('''@@'''				,     ''''''				): i for s, i in vocab.items()}

				# Save pytorch-model
				__lowercase					     =				pytorch_dump_folder_path + '''/''' + WEIGHTS_NAME
				__lowercase					     =				pytorch_dump_folder_path + '''/''' + CONFIG_NAME
				__lowercase					     =				pytorch_dump_folder_path + '''/''' + VOCAB_FILES_NAMES['''vocab_file''']

				print(F"Save PyTorch model to {pytorch_weights_dump_path}"				)
				torch.save(lowercase				,     lowercase				)

				print(F"Save configuration file to {pytorch_config_dump_path}"				)
				with open(lowercase				,     '''w'''				,     encoding='''utf-8'''				) as f:
								f.write(json.dumps(lowercase				,     indent=2				) + '''\n'''				)

				print(F"Save vocab file to {pytorch_config_dump_path}"				)
				with open(lowercase				,     '''w'''				,     encoding='''utf-8'''				) as f:
								f.write(json.dumps(lowercase				,     indent=2				) + '''\n'''				)


if __name__ == "__main__":
		__a    :	Optional[int]         =    argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    """--xlm_checkpoint_path""", default=None, type=str, required=True, help="""Path the official PyTorch dump."""
		)
		parser.add_argument(
		    """--pytorch_dump_folder_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
		)
		__a    :	Any         =    parser.parse_args()
		convert_xlm_checkpoint_to_pytorch(args.xlm_checkpoint_path, args.pytorch_dump_folder_path)