code: 
  
  from transformers import (
      DPRContextEncoderTokenizer,
      DPRContextEncoderTokenizerFast,
      DPRQuestionEncoderTokenizer,
      DPRQuestionEncoderTokenizerFast,
      DPRReaderOutput,
      DPRReaderTokenizer,
      DPRReaderTokenizerFast,
  )
  from transformers.testing_utils import require_tokenizers, slow
  from transformers.tokenization_utils_base import BatchEncoding
  
  from ..bert.test_tokenization_bert import BertTokenizationTest
  
  
  @require_tokenizers
  class 							_lowerCAmelCase		(     UpperCamelCase__	):
  				lowerCamelCase__									=    DPRContextEncoderTokenizer
  				lowerCamelCase__									=    DPRContextEncoderTokenizerFast
  				lowerCamelCase__									=    True
  
  
  
  
  
  
  
  @require_tokenizers
  class 							_lowerCAmelCase		(     UpperCamelCase__	):
  				lowerCamelCase__									=    DPRQuestionEncoderTokenizer
  				lowerCamelCase__									=    DPRQuestionEncoderTokenizerFast
  				lowerCamelCase__									=    True
  
  
  
  
  
  
  
  @require_tokenizers
  class 							_lowerCAmelCase		(     UpperCamelCase__	):
  				lowerCamelCase__									=    DPRReaderTokenizer
  				lowerCamelCase__									=    DPRReaderTokenizerFast
  				lowerCamelCase__									=    True
  
  
  
  
  				@slow
  				def     __a		( self							)    ->      Optional[int]:
  											SCREAMING_SNAKE_CASE			: List[Any]	     =self.tokenizer_class.from_pretrained('''bert-base-uncased'''							)
  
  											SCREAMING_SNAKE_CASE			: List[Any]	     =tokenizer.encode('''question sequence'''		,		add_special_tokens=snake_case_							)
  											SCREAMING_SNAKE_CASE			: str	     =tokenizer.encode('''title sequence'''		,		add_special_tokens=snake_case_							)
  											SCREAMING_SNAKE_CASE			: Optional[int]	     =tokenizer.encode('''text sequence ''' * 4		,		add_special_tokens=snake_case_							)
  											SCREAMING_SNAKE_CASE			: List[Any]	     =[[101] + text_a + [102] + text_a + [102] + text_a]
  											SCREAMING_SNAKE_CASE			: Union[str, Any]	     =BatchEncoding({'''input_ids''': input_ids}							)
  
  											SCREAMING_SNAKE_CASE			: List[Any]	     =[[0] * len(input_ids[0]							)]
  											SCREAMING_SNAKE_CASE			: List[Any]	     =[[0] * len(input_ids[0]							)]
  											SCREAMING_SNAKE_CASE			: List[Any]	     =[0]
  											SCREAMING_SNAKE_CASE			: Optional[Any]	     =DPRReaderOutput(snake_case_		,		snake_case_		,		snake_case_							)
  
  											SCREAMING_SNAKE_CASE			: int	     =8, 9
  											SCREAMING_SNAKE_CASE			: Optional[int]	     =10
  											SCREAMING_SNAKE_CASE			: Any	     =10
  											SCREAMING_SNAKE_CASE			: Optional[Any]	     =tokenizer.decode_best_spans(snake_case_		,		snake_case_							)
  											self.assertEqual(predicted_spans[0].start_index		,		snake_case_							)
  											self.assertEqual(predicted_spans[0].end_index		,		snake_case_							)
  											self.assertEqual(predicted_spans[0].doc_id		,		0							)
  
  
  
  
  
  
  
  				@slow
  				def     __a		( self							)    ->      str:
  											SCREAMING_SNAKE_CASE			: List[str]	     =self.tokenizer_class.from_pretrained('''bert-base-uncased'''							)
  
  											SCREAMING_SNAKE_CASE			: Optional[Any]	     =tokenizer.encode('''question sequence'''		,		add_special_tokens=snake_case_							)
  											SCREAMING_SNAKE_CASE			: Dict	     =tokenizer.encode('''title sequence'''		,		add_special_tokens=snake_case_							)
  											SCREAMING_SNAKE_CASE			: str	     =tokenizer.encode('''text sequence'''		,		add_special_tokens=snake_case_							)
  											SCREAMING_SNAKE_CASE			: List[Any]	     =[101] + text_a + [102] + text_a + [102] + text_a
  											SCREAMING_SNAKE_CASE			: Tuple	     =tokenizer(questions=['''question sequence''']		,		titles=['''title sequence''']		,		texts=['''text sequence''']							)
  											self.assertIn('''input_ids'''		,		snake_case_							)
  											self.assertIn('''attention_mask'''		,		snake_case_							)
  											self.assertListEqual(encoded_input['''input_ids'''][0]		,		snake_case_							)
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  from __future__ import annotations
  def 						lowerCAmelCase_       (	__a	,	__a	,	__a	,	__a )       ->			None:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							SCREAMING_SNAKE_CASE     ,							SCREAMING_SNAKE_CASE			: Any	     =m - 1, 0
  							while i >= 0 and j < n:
  														if key == mat[i][j]:
  																					print(f'Key {key} found at row- {i + 1} column- {j + 1}' )
  																					return
  														if key < mat[i][j]:
  																					i -= 1
  														else:
  																					j += 1
  							print(f'Key {key} not found' )
  def 						lowerCAmelCase_       (	)       ->			None:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							SCREAMING_SNAKE_CASE			: int	     =[[2, 5, 7], [4, 8, 13], [9, 11, 15], [12, 17, 20]]
  							SCREAMING_SNAKE_CASE			: List[str]	     =int(input('''Enter the element to be searched:''' ) )
  							print(__a )
  							search_in_a_sorted_matrix(__a	,	len(__a )	,	len(mat[0] )	,	__a )
  
  
  if __name__ == "__main__":
  							import doctest
  
  							doctest.testmod()
  							main()
  
  
  
  
  
  
  