




import copy
import os
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
import pyarrow as pa
import pyarrow.parquet as pq
import pytest

from datasets.arrow_writer import ArrowWriter, OptimizedTypedSequence, ParquetWriter, TypedSequence
from datasets.features import ArrayaD, ClassLabel, Features, Image, Value
from datasets.features.features import ArrayaDExtensionType, cast_to_python_objects
from datasets.keyhash import DuplicatedKeysError, InvalidKeyError

from .utils import require_pil







class 				lowerCAmelCase_       (					lowerCamelCase_							):






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : str					  =      pa.array(TypedSequence([1, 2, 3] ) )
							self.assertEqual(arr.type      ,pa.intaa() )






				def 		snake_case	(			self ):
							with self.assertRaises(snake_case__ ):
										SCREAMING_SNAKE_CASE_   : List[str]					  =      pa.array(TypedSequence([1, 2, 3] )      ,type=pa.intaa() )






				def 		snake_case	(			self ):
							with self.assertRaises(snake_case__ ):
										SCREAMING_SNAKE_CASE_   : Tuple					  =      pa.array(TypedSequence([1, 2, 3]      ,try_type=Value('bool' )      ,type=Value('int64' ) ) )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Any					  =      pa.array(TypedSequence([1, 2, 3]      ,type=Value('int32' ) ) )
							self.assertEqual(arr.type      ,pa.intaa() )






				def 		snake_case	(			self ):
							with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ):
										SCREAMING_SNAKE_CASE_   : Any					  =      pa.array(TypedSequence(['foo', 'bar']      ,type=Value('int64' ) ) )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      pa.array(TypedSequence([1, 2, 3]      ,try_type=Value('int32' ) ) )
							self.assertEqual(arr.type      ,pa.intaa() )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      pa.array(TypedSequence(['foo', 'bar']      ,try_type=Value('int64' ) ) )
							self.assertEqual(arr.type      ,pa.string() )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : List[str]					  =      pa.array(TypedSequence([[[1, 2, 3]]]      ,type=ArrayaD((1, 3)      ,'int64' ) ) )
							self.assertEqual(arr.type      ,ArrayaDExtensionType((1, 3)      ,'int64' ) )






				def 		snake_case	(			self ):
							with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ):
										SCREAMING_SNAKE_CASE_   : Any					  =      pa.array(TypedSequence(['foo', 'bar']      ,type=ArrayaD((1, 3)      ,'int64' ) ) )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      pa.array(TypedSequence([[[1, 2, 3]]]      ,try_type=ArrayaD((1, 3)      ,'int64' ) ) )
							self.assertEqual(arr.type      ,ArrayaDExtensionType((1, 3)      ,'int64' ) )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : str					  =      pa.array(TypedSequence(['foo', 'bar']      ,try_type=ArrayaD((1, 3)      ,'int64' ) ) )
							self.assertEqual(arr.type      ,pa.string() )






				@require_pil
				def 		snake_case	(			self ):
							import PIL.Image

							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      PIL.Image.fromarray(np.arange(10      ,dtype=np.uinta ).reshape(2      ,5 ) )
							with patch(
							    'datasets.arrow_writer.cast_to_python_objects'      ,side_effect=snake_case__ ) as mock_cast_to_python_objects:
										SCREAMING_SNAKE_CASE_   : Optional[int]					  =      pa.array(TypedSequence([{'path': None, 'bytes': b'image_bytes'}, pil_image]      ,type=Image() ) )
										SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Dict					  =      mock_cast_to_python_objects.call_args_list[-1]
										self.assertIn('optimize_list_casting'      ,snake_case__ )
										self.assertFalse(kwargs['optimize_list_casting'] )





def        __UpperCAmelCase						(							lowerCamelCase_ :     Any  ,							lowerCamelCase_ :     int  )       ->  int:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : str					  =      pa.BufferReader(lowerCamelCase_  ) if isinstance(lowerCamelCase_  ,							pa.Buffer  ) else pa.memory_map(lowerCamelCase_  )
			SCREAMING_SNAKE_CASE_   : str					  =      pa.ipc.open_stream(lowerCamelCase_  )
			SCREAMING_SNAKE_CASE_   : pa.Table					  =      f.read_all()
			assert len(pa_table.to_batches()  ) == expected_num_chunks
			assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]}
			del pa_table





@pytest.mark.parametrize('writer_batch_size'  ,							[None, 1, 10]  )
@pytest.mark.parametrize(
    'fields'  ,							[None, {'col_1': pa.string(), 'col_2': pa.intaa()}, {'col_1': pa.string(), 'col_2': pa.intaa()}]  )
def        __UpperCAmelCase						(							lowerCamelCase_ :     Tuple  ,							lowerCamelCase_ :     Dict  )       ->  Dict:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : Any					  =      pa.BufferOutputStream()
			SCREAMING_SNAKE_CASE_   : Any					  =      pa.schema(lowerCamelCase_  ) if fields else None
			with ArrowWriter(stream=lowerCamelCase_  ,							schema=lowerCamelCase_  ,							writer_batch_size=lowerCamelCase_  ) as writer:
						writer.write({'col_1': 'foo', 'col_2': 1}  )
						writer.write({'col_1': 'bar', 'col_2': 2}  )
						SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Optional[int]					  =      writer.finalize()
			assert num_examples == 2
			assert num_bytes > 0
			if not fields:
						SCREAMING_SNAKE_CASE_   : str					  =      {'col_1': pa.string(), 'col_2': pa.intaa()}
			assert writer._schema == pa.schema(lowerCamelCase_  ,							metadata=writer._schema.metadata  )
			_check_output(output.getvalue()  ,							expected_num_chunks=num_examples if writer_batch_size == 1 else 1  )





def        __UpperCAmelCase						(							)       ->  Any:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : Tuple					  =      pa.BufferOutputStream()
			SCREAMING_SNAKE_CASE_   : int					  =      Features({'labels': ClassLabel(names=['neg', 'pos']  )}  )
			with ArrowWriter(stream=lowerCamelCase_  ,							features=lowerCamelCase_  ) as writer:
						writer.write({'labels': 0}  )
						writer.write({'labels': 1}  )
						SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : str					  =      writer.finalize()
			assert num_examples == 2
			assert num_bytes > 0
			assert writer._schema == features.arrow_schema
			assert writer._schema.metadata == features.arrow_schema.metadata
			SCREAMING_SNAKE_CASE_   : List[str]					  =      pa.BufferReader(output.getvalue()  )
			SCREAMING_SNAKE_CASE_   : Tuple					  =      pa.ipc.open_stream(lowerCamelCase_  )
			SCREAMING_SNAKE_CASE_   : pa.Table					  =      f.read_all()
			SCREAMING_SNAKE_CASE_   : int					  =      pa_table.schema
			assert pa_table.num_rows == 2
			assert schema == features.arrow_schema
			assert schema.metadata == features.arrow_schema.metadata
			assert features == Features.from_arrow_schema(lowerCamelCase_  )





@pytest.mark.parametrize('writer_batch_size'  ,							[None, 1, 10]  )
def        __UpperCAmelCase						(							lowerCamelCase_ :     List[Any]  )       ->  List[Any]:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : Tuple					  =      pa.BufferOutputStream()
			with ArrowWriter(
			    stream=lowerCamelCase_  ,							writer_batch_size=lowerCamelCase_  ,							hash_salt='split_name'  ,							check_duplicates=lowerCamelCase_  ,							) as writer:
						with pytest.raises(lowerCamelCase_  ):
									writer.write({'col_1': 'foo', 'col_2': 1}  ,							key=[1, 2]  )
									SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      writer.finalize()





@pytest.mark.parametrize('writer_batch_size'  ,							[None, 2, 10]  )
def        __UpperCAmelCase						(							lowerCamelCase_ :     Optional[int]  )       ->  Union[str, Any]:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      pa.BufferOutputStream()
			with ArrowWriter(
			    stream=lowerCamelCase_  ,							writer_batch_size=lowerCamelCase_  ,							hash_salt='split_name'  ,							check_duplicates=lowerCamelCase_  ,							) as writer:
						with pytest.raises(lowerCamelCase_  ):
									writer.write({'col_1': 'foo', 'col_2': 1}  ,							key=10  )
									writer.write({'col_1': 'bar', 'col_2': 2}  ,							key=10  )
									SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Tuple					  =      writer.finalize()





@pytest.mark.parametrize('writer_batch_size'  ,							[None, 2, 10]  )
def        __UpperCAmelCase						(							lowerCamelCase_ :     Any  )       ->  Any:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : int					  =      pa.BufferOutputStream()
			with ArrowWriter(
			    stream=lowerCamelCase_  ,							writer_batch_size=lowerCamelCase_  ,							hash_salt='split_name'  ,							check_duplicates=lowerCamelCase_  ,							) as writer:
						writer.write({'col_1': 'foo', 'col_2': 1}  ,							key=1  )
						writer.write({'col_1': 'bar', 'col_2': 2}  ,							key=2  )
						SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : List[Any]					  =      writer.finalize()
			assert num_examples == 2
			assert num_bytes > 0
			_check_output(output.getvalue()  ,							expected_num_chunks=num_examples if writer_batch_size == 1 else 1  )





@pytest.mark.parametrize('writer_batch_size'  ,							[None, 1, 10]  )
@pytest.mark.parametrize(
    'fields'  ,							[None, {'col_1': pa.string(), 'col_2': pa.intaa()}, {'col_1': pa.string(), 'col_2': pa.intaa()}]  )
def        __UpperCAmelCase						(							lowerCamelCase_ :     Optional[Any]  ,							lowerCamelCase_ :     str  )       ->  List[str]:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : List[Any]					  =      pa.BufferOutputStream()
			SCREAMING_SNAKE_CASE_   : int					  =      pa.schema(lowerCamelCase_  ) if fields else None
			with ArrowWriter(stream=lowerCamelCase_  ,							schema=lowerCamelCase_  ,							writer_batch_size=lowerCamelCase_  ) as writer:
						writer.write_batch({'col_1': ['foo', 'bar'], 'col_2': [1, 2]}  )
						writer.write_batch({'col_1': [], 'col_2': []}  )
						SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : str					  =      writer.finalize()
			assert num_examples == 2
			assert num_bytes > 0
			if not fields:
						SCREAMING_SNAKE_CASE_   : str					  =      {'col_1': pa.string(), 'col_2': pa.intaa()}
			assert writer._schema == pa.schema(lowerCamelCase_  ,							metadata=writer._schema.metadata  )
			_check_output(output.getvalue()  ,							expected_num_chunks=num_examples if writer_batch_size == 1 else 1  )





@pytest.mark.parametrize('writer_batch_size'  ,							[None, 1, 10]  )
@pytest.mark.parametrize(
    'fields'  ,							[None, {'col_1': pa.string(), 'col_2': pa.intaa()}, {'col_1': pa.string(), 'col_2': pa.intaa()}]  )
def        __UpperCAmelCase						(							lowerCamelCase_ :     str  ,							lowerCamelCase_ :     Optional[int]  )       ->  int:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : Dict					  =      pa.BufferOutputStream()
			SCREAMING_SNAKE_CASE_   : int					  =      pa.schema(lowerCamelCase_  ) if fields else None
			with ArrowWriter(stream=lowerCamelCase_  ,							schema=lowerCamelCase_  ,							writer_batch_size=lowerCamelCase_  ) as writer:
						writer.write_table(pa.Table.from_pydict({'col_1': ['foo', 'bar'], 'col_2': [1, 2]}  )  )
						SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : int					  =      writer.finalize()
			assert num_examples == 2
			assert num_bytes > 0
			if not fields:
						SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      {'col_1': pa.string(), 'col_2': pa.intaa()}
			assert writer._schema == pa.schema(lowerCamelCase_  ,							metadata=writer._schema.metadata  )
			_check_output(output.getvalue()  ,							expected_num_chunks=num_examples if writer_batch_size == 1 else 1  )





@pytest.mark.parametrize('writer_batch_size'  ,							[None, 1, 10]  )
@pytest.mark.parametrize(
    'fields'  ,							[None, {'col_1': pa.string(), 'col_2': pa.intaa()}, {'col_1': pa.string(), 'col_2': pa.intaa()}]  )
def        __UpperCAmelCase						(							lowerCamelCase_ :     List[Any]  ,							lowerCamelCase_ :     List[str]  )       ->  Union[str, Any]:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : List[Any]					  =      pa.BufferOutputStream()
			SCREAMING_SNAKE_CASE_   : Optional[int]					  =      pa.schema(lowerCamelCase_  ) if fields else None
			with ArrowWriter(stream=lowerCamelCase_  ,							schema=lowerCamelCase_  ,							writer_batch_size=lowerCamelCase_  ) as writer:
						writer.write_row(pa.Table.from_pydict({'col_1': ['foo'], 'col_2': [1]}  )  )
						writer.write_row(pa.Table.from_pydict({'col_1': ['bar'], 'col_2': [2]}  )  )
						SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : int					  =      writer.finalize()
			assert num_examples == 2
			assert num_bytes > 0
			if not fields:
						SCREAMING_SNAKE_CASE_   : Any					  =      {'col_1': pa.string(), 'col_2': pa.intaa()}
			assert writer._schema == pa.schema(lowerCamelCase_  ,							metadata=writer._schema.metadata  )
			_check_output(output.getvalue()  ,							expected_num_chunks=num_examples if writer_batch_size == 1 else 1  )





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







			"""simple docstring"""





			with tempfile.TemporaryDirectory() as tmp_dir:
						SCREAMING_SNAKE_CASE_   : Optional[int]					  =      {'col_1': pa.string(), 'col_2': pa.intaa()}
						SCREAMING_SNAKE_CASE_   : Any					  =      os.path.join(lowerCamelCase_  ,							'test.arrow'  )
						with ArrowWriter(path=lowerCamelCase_  ,							schema=pa.schema(lowerCamelCase_  )  ) as writer:
									writer.write_batch({'col_1': ['foo', 'bar'], 'col_2': [1, 2]}  )
									SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Any					  =      writer.finalize()
						assert num_examples == 2
						assert num_bytes > 0
						assert writer._schema == pa.schema(lowerCamelCase_  ,							metadata=writer._schema.metadata  )
						_check_output(lowerCamelCase_  ,							1  )





def        __UpperCAmelCase						(							lowerCamelCase_ :     Union[str, Any]  )       ->  List[str]:







			"""simple docstring"""





			if pa.types.is_list(lowerCamelCase_  ):
						return get_base_dtype(arr_type.value_type  )
			else:
						return arr_type





def        __UpperCAmelCase						(							lowerCamelCase_ :     Optional[int]  ,							lowerCamelCase_ :     Dict  )       ->  List[Any]:







			"""simple docstring"""





			if isinstance(lst[0]  ,							lowerCamelCase_  ):
						change_first_primitive_element_in_list(lst[0]  ,							lowerCamelCase_  )
			else:
						SCREAMING_SNAKE_CASE_   : int					  =      value





@pytest.mark.parametrize('optimized_int_type, expected_dtype'  ,							[(None, pa.intaa()), (Value('int32'  ), pa.intaa())]  )
@pytest.mark.parametrize('sequence'  ,							[[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]]  )
def        __UpperCAmelCase						(							lowerCamelCase_ :     Tuple  ,							lowerCamelCase_ :     Any  ,							lowerCamelCase_ :     Tuple  )       ->  List[Any]:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : List[Any]					  =      pa.array(TypedSequence(lowerCamelCase_  ,							optimized_int_type=lowerCamelCase_  )  )
			assert get_base_dtype(arr.type  ) == expected_dtype





@pytest.mark.parametrize(
    'col, expected_dtype'  ,							[
        ('attention_mask', pa.inta()),
        ('special_tokens_mask', pa.inta()),
        ('token_type_ids', pa.inta()),
        ('input_ids', pa.intaa()),
        ('other', pa.intaa()),
    ]  ,							)
@pytest.mark.parametrize('sequence'  ,							[[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]]  )
def        __UpperCAmelCase						(							lowerCamelCase_ :     Optional[Any]  ,							lowerCamelCase_ :     int  ,							lowerCamelCase_ :     Union[str, Any]  )       ->  str:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : List[str]					  =      pa.array(OptimizedTypedSequence(lowerCamelCase_  ,							col=lowerCamelCase_  )  )
			assert get_base_dtype(arr.type  ) == expected_dtype

			# not in range
			if col != "other":
						# avoids errors due to in-place modifications
						SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      copy.deepcopy(lowerCamelCase_  )
						SCREAMING_SNAKE_CASE_   : int					  =      np.iinfo(expected_dtype.to_pandas_dtype()  ).max + 1
						change_first_primitive_element_in_list(lowerCamelCase_  ,							lowerCamelCase_  )
						SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      pa.array(OptimizedTypedSequence(lowerCamelCase_  ,							col=lowerCamelCase_  )  )
						assert get_base_dtype(arr.type  ) == pa.intaa()





@pytest.mark.parametrize('raise_exception'  ,							[False, True]  )
def        __UpperCAmelCase						(							lowerCamelCase_ :     Any  ,							lowerCamelCase_ :     Any  )       ->  Tuple:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : List[str]					  =      str(tmp_path / 'dataset-train.arrow'  )
			try:
						with ArrowWriter(path=lowerCamelCase_  ) as writer:
									if raise_exception:
												raise pa.lib.ArrowInvalid()
									else:
												writer.stream.close()
			except pa.lib.ArrowInvalid:
						pass
			finally:
						assert writer.stream.closed





def        __UpperCAmelCase						(							lowerCamelCase_ :     List[Any]  )       ->  List[str]:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : str					  =      'mock://dataset-train.arrow'
			with ArrowWriter(path=lowerCamelCase_  ,							storage_options=mockfs.storage_options  ) as writer:
						assert isinstance(writer._fs  ,							type(lowerCamelCase_  )  )
						assert writer._fs.storage_options == mockfs.storage_options
						writer.write({'col_1': 'foo', 'col_2': 1}  )
						writer.write({'col_1': 'bar', 'col_2': 2}  )
						SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Dict					  =      writer.finalize()
			assert num_examples == 2
			assert num_bytes > 0
			assert mockfs.exists(lowerCamelCase_  )





def        __UpperCAmelCase						(							)       ->  int:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      pa.BufferOutputStream()
			with ParquetWriter(stream=lowerCamelCase_  ) as writer:
						writer.write({'col_1': 'foo', 'col_2': 1}  )
						writer.write({'col_1': 'bar', 'col_2': 2}  )
						SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Dict					  =      writer.finalize()
			assert num_examples == 2
			assert num_bytes > 0
			SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      pa.BufferReader(output.getvalue()  )
			SCREAMING_SNAKE_CASE_   : pa.Table					  =      pq.read_table(lowerCamelCase_  )
			assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]}





@require_pil
@pytest.mark.parametrize('embed_local_files'  ,							[False, True]  )
def        __UpperCAmelCase						(							lowerCamelCase_ :     Tuple  ,							lowerCamelCase_ :     Any  )       ->  Union[str, Any]:







			"""simple docstring"""





			import PIL.Image

			SCREAMING_SNAKE_CASE_   : Tuple					  =      str(tmp_path / 'test_image_rgb.jpg'  )
			PIL.Image.fromarray(np.zeros((5, 5)  ,							dtype=np.uinta  )  ).save(lowerCamelCase_  ,							format='png'  )
			SCREAMING_SNAKE_CASE_   : Optional[int]					  =      pa.BufferOutputStream()
			with ParquetWriter(
			    stream=lowerCamelCase_  ,							features=Features({'image': Image()}  )  ,							embed_local_files=lowerCamelCase_  ) as writer:
						writer.write({'image': image_path}  )
						writer.finalize()
			SCREAMING_SNAKE_CASE_   : Tuple					  =      pa.BufferReader(output.getvalue()  )
			SCREAMING_SNAKE_CASE_   : pa.Table					  =      pq.read_table(lowerCamelCase_  )
			SCREAMING_SNAKE_CASE_   : Tuple					  =      pa_table.to_pydict()
			if embed_local_files:
						assert isinstance(out['image'][0]['path']  ,							lowerCamelCase_  )
						with open(lowerCamelCase_  ,							'rb'  ) as f:
									assert out["image"][0]["bytes"] == f.read()
			else:
						assert out["image"][0]["path"] == image_path
						assert out["image"][0]["bytes"] is None





def        __UpperCAmelCase						(							)       ->  Optional[Any]:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : List[str]					  =      pa.schema([pa.field('col_1'  ,							pa.string()  ,							nullable=lowerCamelCase_  )]  )
			SCREAMING_SNAKE_CASE_   : List[Any]					  =      pa.BufferOutputStream()
			with ArrowWriter(stream=lowerCamelCase_  ) as writer:
						writer._build_writer(inferred_schema=lowerCamelCase_  )
						assert writer._schema == pa.schema([pa.field('col_1'  ,							pa.string()  )]  )







import pytest

import datasets


# Import fixture modules as plugins
__snake_case   							=						['''tests.fixtures.files''', '''tests.fixtures.hub''', '''tests.fixtures.fsspec''']






def 		_A		(		_lowercase					,  _lowercase )					-> Tuple:


     """simple docstring"""


     for item in items:
          if any(marker in item.keywords for marker in ['integration', 'unit'] ):
               continue
          item.add_marker(pytest.mark.unit )






def 		_A		(		_lowercase )					-> str:


     """simple docstring"""


     config.addinivalue_line('markers'					,  'torchaudio_latest: mark test to run with torchaudio>=0.12' )






@pytest.fixture(autouse=_lowercase )
def 		_A		(		_lowercase					,  _lowercase )					-> Any:


     """simple docstring"""


     __UpperCamelCase =			tmp_path_factory.getbasetemp() / 'cache'
     __UpperCamelCase =			test_hf_cache_home / 'datasets'
     __UpperCamelCase =			test_hf_cache_home / 'metrics'
     __UpperCamelCase =			test_hf_cache_home / 'modules'
     monkeypatch.setattr('datasets.config.HF_DATASETS_CACHE'					,  str(_lowercase ) )
     monkeypatch.setattr('datasets.config.HF_METRICS_CACHE'					,  str(_lowercase ) )
     monkeypatch.setattr('datasets.config.HF_MODULES_CACHE'					,  str(_lowercase ) )
     __UpperCamelCase =			test_hf_datasets_cache / 'downloads'
     monkeypatch.setattr('datasets.config.DOWNLOADED_DATASETS_PATH'					,  str(_lowercase ) )
     __UpperCamelCase =			test_hf_datasets_cache / 'downloads' / 'extracted'
     monkeypatch.setattr('datasets.config.EXTRACTED_DATASETS_PATH'					,  str(_lowercase ) )






@pytest.fixture(autouse=_lowercase					,  scope='session' )
def 		_A		(		)					-> Dict:


     """simple docstring"""


     datasets.disable_progress_bar()






@pytest.fixture(autouse=_lowercase )
def 		_A		(		_lowercase )					-> Tuple:


     """simple docstring"""


     monkeypatch.setattr('datasets.config.HF_UPDATE_DOWNLOAD_COUNTS'					,  _lowercase )






@pytest.fixture
def 		_A		(		_lowercase )					-> Any:


     """simple docstring"""


     monkeypatch.setattr('sqlalchemy.util.deprecations.SILENCE_UBER_WARNING'					,  _lowercase )


