



"""simple docstring"""







import unittest

import numpy as np
import torch

from .utils_summarization import build_mask, compute_token_type_ids, process_story, truncate_or_pad






class      UpperCAmelCase__		(      unittest.TestCase     ):



		def 					A_		( self  :    Dict				)			->						str:






									'''simple docstring'''

									A         =					10



		def 					A_		( self  :    Optional[Any]				)			->						Optional[Any]:






									'''simple docstring'''

									A         =					[1, 2, 3, 4]
									A         =					[1, 2, 3, 4, 0, 0, 0, 0, 0, 0]
									self.assertEqual(truncate_or_pad(snake_case      ,							self.block_size      ,							0				)      ,							snake_case				)



		def 					A_		( self  :    Any				)			->						str:






									'''simple docstring'''

									A         =					[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
									A         =					[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
									self.assertEqual(truncate_or_pad(snake_case      ,							self.block_size      ,							0				)      ,							snake_case				)



		def 					A_		( self  :    Any				)			->						int:






									'''simple docstring'''

									A         =					[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
									A         =					[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
									self.assertEqual(truncate_or_pad(snake_case      ,							self.block_size      ,							0				)      ,							snake_case				)



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






									'''simple docstring'''

									A         =					'It was the year of Our Lord one thousand seven hundred and\n        seventy-five.\n\nSpiritual revelations were conceded to England at that\n        favoured period, as at this.'
									A      ,  A         =					process_story(snake_case				)
									self.assertEqual(snake_case      ,							[]				)



		def 					A_		( self  :    Tuple				)			->						str:






									'''simple docstring'''

									A         =					''
									A      ,  A         =					process_story(snake_case				)
									self.assertEqual(snake_case      ,							[]				)
									self.assertEqual(snake_case      ,							[]				)



		def 					A_		( self  :    List[Any]				)			->						Optional[Any]:






									'''simple docstring'''

									A         =					(
									    'It was the year of Our Lord one thousand seven hundred and '
									    'seventy-five\n\nSpiritual revelations were conceded to England '
									    'at that favoured period, as at this.\n@highlight\n\nIt was the best of times'
									)
									A      ,  A         =					process_story(snake_case				)

									A         =					[
									    'It was the year of Our Lord one thousand seven hundred and seventy-five.',
									    'Spiritual revelations were conceded to England at that favoured period, as at this.',
									]
									self.assertEqual(snake_case      ,							snake_case				)

									A         =					['It was the best of times.']
									self.assertEqual(snake_case      ,							snake_case				)



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






									'''simple docstring'''

									A         =					torch.tensor([1, 2, 3, 4]				)
									A         =					torch.tensor([1, 1, 1, 1]				)
									np.testing.assert_array_equal(build_mask(snake_case      ,							0				).numpy()      ,							expected.numpy()				)



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






									'''simple docstring'''

									A         =					torch.tensor([1, 2, 3, 4, 23, 23, 23]				)
									A         =					torch.tensor([1, 1, 1, 1, 0, 0, 0]				)
									np.testing.assert_array_equal(build_mask(snake_case      ,							23				).numpy()      ,							expected.numpy()				)



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






									'''simple docstring'''

									A         =					torch.tensor([8, 2, 3, 4, 1, 1, 1]				)
									A         =					torch.tensor([1, 1, 1, 1, 0, 0, 0]				)
									np.testing.assert_array_equal(build_mask(snake_case      ,							1				).numpy()      ,							expected.numpy()				)



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






									'''simple docstring'''

									A         =					101
									A         =					torch.tensor([[1, 2, 3, 4, 5, 6], [1, 2, 3, 101, 5, 6], [1, 101, 3, 4, 101, 6]]				)
									A         =					torch.tensor([[1, 1, 1, 1, 1, 1], [1, 1, 1, 0, 0, 0], [1, 0, 0, 0, 1, 1]]				)

									A         =					compute_token_type_ids(snake_case      ,							snake_case				)
									np.testing.assert_array_equal(snake_case      ,							snake_case				)








"""simple docstring"""







from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching

def   lowerCAmelCase__			(     ) ->							Optional[Any]:
							import os as original_os
							from os import path as original_path
							from os import rename as original_rename
							from os.path import dirname as original_dirname
							from os.path import join as original_join

							assert _test_patching.os is original_os
							assert _test_patching.path is original_path
							assert _test_patching.join is original_join

							assert _test_patching.renamed_os is original_os
							assert _test_patching.renamed_path is original_path
							assert _test_patching.renamed_join is original_join

							A         =					'__test_patch_submodule_mock__'
							with patch_submodule(_test_patching				,      'os.path.join'				,      lowerCamelCase__			):
														# Every way to access os.path.join must be patched, and the rest must stay untouched

														# check os.path.join
														assert isinstance(_test_patching.os				,      _PatchedModuleObj			)
														assert isinstance(_test_patching.os.path				,      _PatchedModuleObj			)
														assert _test_patching.os.path.join is mock

														# check path.join
														assert isinstance(_test_patching.path				,      _PatchedModuleObj			)
														assert _test_patching.path.join is mock

														# check join
														assert _test_patching.join is mock

														# check that the other attributes are untouched
														assert _test_patching.os.rename is original_rename
														assert _test_patching.path.dirname is original_dirname
														assert _test_patching.os.path.dirname is original_dirname

														# Even renamed modules or objects must be patched

														# check renamed_os.path.join
														assert isinstance(_test_patching.renamed_os				,      _PatchedModuleObj			)
														assert isinstance(_test_patching.renamed_os.path				,      _PatchedModuleObj			)
														assert _test_patching.renamed_os.path.join is mock

														# check renamed_path.join
														assert isinstance(_test_patching.renamed_path				,      _PatchedModuleObj			)
														assert _test_patching.renamed_path.join is mock

														# check renamed_join
														assert _test_patching.renamed_join is mock

														# check that the other attributes are untouched
														assert _test_patching.renamed_os.rename is original_rename
														assert _test_patching.renamed_path.dirname is original_dirname
														assert _test_patching.renamed_os.path.dirname is original_dirname

							# check that everthing is back to normal when the patch is over

							assert _test_patching.os is original_os
							assert _test_patching.path is original_path
							assert _test_patching.join is original_join

							assert _test_patching.renamed_os is original_os
							assert _test_patching.renamed_path is original_path
							assert _test_patching.renamed_join is original_join

def   lowerCAmelCase__			(     ) ->							str:
							assert _test_patching.open is open

							A         =					'__test_patch_submodule_builtin_mock__'
							# _test_patching has "open" in its globals
							assert _test_patching.open is open
							with patch_submodule(_test_patching				,      'open'				,      lowerCamelCase__			):
														assert _test_patching.open is mock

							# check that everthing is back to normal when the patch is over

							assert _test_patching.open is open

def   lowerCAmelCase__			(     ) ->							List[Any]:
							# pandas.read_csv is not present in _test_patching
							A         =					'__test_patch_submodule_missing_mock__'
							with patch_submodule(_test_patching				,      'pandas.read_csv'				,      lowerCamelCase__			):
														pass

def   lowerCAmelCase__			(     ) ->							Union[str, Any]:
							# builtin should always be mocked even if they're not in the globals
							# in case they're loaded at one point
							A         =					'__test_patch_submodule_missing_builtin_mock__'
							# _test_patching doesn't have "len" in its globals
							assert getattr(_test_patching				,      'len'				,      lowerCamelCase__			) is None
							with patch_submodule(_test_patching				,      'len'				,      lowerCamelCase__			):
														assert _test_patching.len is mock
							assert _test_patching.len is len

def   lowerCAmelCase__			(     ) ->							Union[str, Any]:
							A         =					'__test_patch_submodule_start_and_stop_mock__'
							A         =					patch_submodule(_test_patching				,      'open'				,      lowerCamelCase__			)
							assert _test_patching.open is open
							patch.start()
							assert _test_patching.open is mock
							patch.stop()
							assert _test_patching.open is open

def   lowerCAmelCase__			(     ) ->							int:
							from os import rename as original_rename
							from os.path import dirname as original_dirname
							from os.path import join as original_join

							A         =					'__test_patch_submodule_successive_join__'
							A         =					'__test_patch_submodule_successive_dirname__'
							A         =					'__test_patch_submodule_successive_rename__'
							assert _test_patching.os.path.join is original_join
							assert _test_patching.os.path.dirname is original_dirname
							assert _test_patching.os.rename is original_rename

							with patch_submodule(_test_patching				,      'os.path.join'				,      lowerCamelCase__			):
														with patch_submodule(_test_patching				,      'os.rename'				,      lowerCamelCase__			):
																					with patch_submodule(_test_patching				,      'os.path.dirname'				,      lowerCamelCase__			):
																												assert _test_patching.os.path.join is mock_join
																												assert _test_patching.os.path.dirname is mock_dirname
																												assert _test_patching.os.rename is mock_rename

    # try another order
							with patch_submodule(_test_patching				,      'os.rename'				,      lowerCamelCase__			):
														with patch_submodule(_test_patching				,      'os.path.join'				,      lowerCamelCase__			):
																					with patch_submodule(_test_patching				,      'os.path.dirname'				,      lowerCamelCase__			):
																												assert _test_patching.os.path.join is mock_join
																												assert _test_patching.os.path.dirname is mock_dirname
																												assert _test_patching.os.rename is mock_rename

							assert _test_patching.os.path.join is original_join
							assert _test_patching.os.path.dirname is original_dirname
							assert _test_patching.os.rename is original_rename

def   lowerCAmelCase__			(     ) ->							Optional[Any]:
							A         =					'__test_patch_submodule_doesnt_exist_mock__'
							with patch_submodule(_test_patching				,      '__module_that_doesn_exist__.__attribute_that_doesn_exist__'				,      lowerCamelCase__			):
														pass
							with patch_submodule(_test_patching				,      'os.__attribute_that_doesn_exist__'				,      lowerCamelCase__			):
														pass



