

'''simple docstring'''
from typing import Any







class 							A__   :





  def __init__(		self				:     List[str]							, _a				:     Any			)     ->   Optional[int]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =data
       _SCREAMING_SNAKE_CASE							   =None





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





       '''simple docstring'''






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







class 							A__   :





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =None





  def __iter__(		self				:     Dict			)     ->   Any:





       '''simple docstring'''






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





  def __len__(		self				:     Tuple			)     ->   int:





       '''simple docstring'''






       return sum(1 for _ in self			)





  def __repr__(		self				:     Tuple			)     ->   str:





       '''simple docstring'''






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





  def __getitem__(		self				:     List[str]							, _a				:     int			)     ->   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				:     Tuple							, _a				:     int							, _a				:     Any			)     ->   None:





       '''simple docstring'''






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





  def 						A  (		self				:     List[str]							, _a				:     Any			)     ->   None:





       '''simple docstring'''






       self.insert_nth(len(self			)							, _a			)





  def 						A  (		self				:     Dict							, _a				:     Any			)     ->   None:





       '''simple docstring'''






       self.insert_nth(0							, _a			)





  def 						A  (		self				:     str							, _a				:     int							, _a				:     Any			)     ->   None:





       '''simple docstring'''






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





  def 						A  (		self				:     Optional[int]			)     ->   None:  # print every node data





       '''simple docstring'''






       print(self			)





  def 						A  (		self				:     int			)     ->   Any:





       '''simple docstring'''






       return self.delete_nth(0			)





  def 						A  (		self				:     List[str]			)     ->   Any:  # delete from tail





       '''simple docstring'''






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





  def 						A  (		self				:     List[Any]							, _a				:     int = 0			)     ->   Any:





       '''simple docstring'''






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





  def 						A  (		self				:     Any			)     ->   bool:





       '''simple docstring'''






       return self.head is None





  def 						A  (		self				:     int			)     ->   None:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =None
       _SCREAMING_SNAKE_CASE							   =self.head

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


def 	_lowerCAmelCase (						)				->      None:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =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							   =-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 	_lowerCAmelCase (						)				->      None:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =[
         -9,
         1_00,
         Node(77_34_51_12    ),
         'dlrow olleH',
         7,
         55_55,
         0,
         -1_92.5_55_55,
         'Hello, world!',
         77.9,
         Node(10    ),
         None,
         None,
         12.20,
     ]
     _SCREAMING_SNAKE_CASE							   =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							   =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							   =linked_list.delete_tail()
     assert result == 12.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							   =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 	_lowerCAmelCase (						)				->      int:
     """simple docstring"""




     from doctest import testmod

     testmod()

     _SCREAMING_SNAKE_CASE							   =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							   =input('Enter New Value: '    ).strip()
     print('New list:'    )
     print(_UpperCamelCase    )
     print(f"length of linked_list is : {len(_UpperCamelCase    )}"    )


if __name__ == "__main__":
    main()



'''simple docstring'''
import warnings
from contextlib import contextmanager

from ....processing_utils import ProcessorMixin







class 							A__   (	A__  ):
  A__					=    'MCTCTFeatureExtractor'
  A__					=    'AutoTokenizer'





  def __init__(		self				:     Optional[Any]							, _a				:     Optional[int]							, _a				:     Union[str, Any]			)     ->   Union[str, Any]:





       '''simple docstring'''






       super().__init__(_a							, _a			)
       _SCREAMING_SNAKE_CASE							   =self.feature_extractor
       _SCREAMING_SNAKE_CASE							   =False





  def __call__(		self				:     Dict							, *_a				:     str							, **_a				:     Dict			)     ->   Dict:





       '''simple docstring'''






       if self._in_target_context_manager:
            return self.current_processor(*_a							, **_a			)

       if "raw_speech" in kwargs:
            warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'			)
            _SCREAMING_SNAKE_CASE							   =kwargs.pop('raw_speech'			)
       else:
            _SCREAMING_SNAKE_CASE							   =kwargs.pop('audio'							, _a			)
       _SCREAMING_SNAKE_CASE							   =kwargs.pop('sampling_rate'							, _a			)
       _SCREAMING_SNAKE_CASE							   =kwargs.pop('text'							, _a			)
       if len(_a			) > 0:
            _SCREAMING_SNAKE_CASE							   =args[0]
            _SCREAMING_SNAKE_CASE							   =args[1:]

       if audio is None and text is None:
            raise ValueError('You need to specify either an `audio` or `text` input to process.'			)

       if audio is not None:
            _SCREAMING_SNAKE_CASE							   =self.feature_extractor(_a							, *_a							, sampling_rate=_a							, **_a			)
       if text is not None:
            _SCREAMING_SNAKE_CASE							   =self.tokenizer(_a							, **_a			)

       if text is None:
            return inputs
       elif audio is None:
            return encodings
       else:
            _SCREAMING_SNAKE_CASE							   =encodings['input_ids']
            return inputs





  def 						A  (		self				:     Any							, *_a				:     List[str]							, **_a				:     Optional[int]			)     ->   Optional[int]:





       '''simple docstring'''






       return self.tokenizer.batch_decode(*_a							, **_a			)





  def 						A  (		self				:     Dict							, *_a				:     Tuple							, **_a				:     Dict			)     ->   List[str]:





       '''simple docstring'''






       if self._in_target_context_manager:
            return self.current_processor.pad(*_a							, **_a			)

       _SCREAMING_SNAKE_CASE							   =kwargs.pop('input_features'							, _a			)
       _SCREAMING_SNAKE_CASE							   =kwargs.pop('labels'							, _a			)
       if len(_a			) > 0:
            _SCREAMING_SNAKE_CASE							   =args[0]
            _SCREAMING_SNAKE_CASE							   =args[1:]

       if input_features is not None:
            _SCREAMING_SNAKE_CASE							   =self.feature_extractor.pad(_a							, *_a							, **_a			)
       if labels is not None:
            _SCREAMING_SNAKE_CASE							   =self.tokenizer.pad(_a							, **_a			)

       if labels is None:
            return input_features
       elif input_features is None:
            return labels
       else:
            _SCREAMING_SNAKE_CASE							   =labels['input_ids']
            return input_features





  def 						A  (		self				:     Tuple							, *_a				:     Dict							, **_a				:     List[Any]			)     ->   Optional[int]:





       '''simple docstring'''






       return self.tokenizer.decode(*_a							, **_a			)





  @contextmanager
  def 						A  (		self				:     Optional[Any]			)     ->   Dict:





       '''simple docstring'''






       warnings.warn(
           '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
           'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
           'your audio inputs, or in a separate call.'			)
       _SCREAMING_SNAKE_CASE							   =True
       _SCREAMING_SNAKE_CASE							   =self.tokenizer
       yield
       _SCREAMING_SNAKE_CASE							   =self.feature_extractor
       _SCREAMING_SNAKE_CASE							   =False
