




import unittest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TextaTextGenerationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch
from transformers.utils import is_torch_available

from .test_pipelines_common import ANY


if is_torch_available():
						import torch







@is_pipeline_test
class 				lowerCAmelCase_       (					unittest.TestCase							):
				__a     :       Tuple						=     MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
				__a     :       Any						=     TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING






				def 		snake_case	(			self      ,snake_case__      ,snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : Tuple					  =      TextaTextGenerationPipeline(model=snake_case__      ,tokenizer=snake_case__ )
							return generator, ["Something to write", "Something else"]






				def 		snake_case	(			self      ,snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      generator('Something there' )
							self.assertEqual(snake_case__      ,[{'generated_text': ANY(snake_case__ )}] )
							# These are encoder decoder, they don't just append to incoming string
							self.assertFalse(outputs[0]['generated_text'].startswith('Something there' ) )

							SCREAMING_SNAKE_CASE_   : List[Any]					  =      generator(['This is great !', 'Something else']      ,num_return_sequences=2      ,do_sample=snake_case__ )
							self.assertEqual(
							    snake_case__      ,[
							        [{'generated_text': ANY(snake_case__ )}, {'generated_text': ANY(snake_case__ )}],
							        [{'generated_text': ANY(snake_case__ )}, {'generated_text': ANY(snake_case__ )}],
							    ]      ,)

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      generator(
							    ['This is great !', 'Something else']      ,num_return_sequences=2      ,batch_size=2      ,do_sample=snake_case__ )
							self.assertEqual(
							    snake_case__      ,[
							        [{'generated_text': ANY(snake_case__ )}, {'generated_text': ANY(snake_case__ )}],
							        [{'generated_text': ANY(snake_case__ )}, {'generated_text': ANY(snake_case__ )}],
							    ]      ,)

							with self.assertRaises(snake_case__ ):
										generator(4 )






				@require_torch
				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      pipeline('text2text-generation'      ,model='patrickvonplaten/t5-tiny-random'      ,framework='pt' )
							# do_sample=False necessary for reproducibility
							SCREAMING_SNAKE_CASE_   : str					  =      generator('Something there'      ,do_sample=snake_case__ )
							self.assertEqual(snake_case__      ,[{'generated_text': ''}] )

							SCREAMING_SNAKE_CASE_   : List[str]					  =      3
							SCREAMING_SNAKE_CASE_   : Dict					  =      generator(
							    'Something there'      ,num_return_sequences=snake_case__      ,num_beams=snake_case__      ,)
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      [
							    {'generated_text': 'Beide Beide Beide Beide Beide Beide Beide Beide Beide'},
							    {'generated_text': 'Beide Beide Beide Beide Beide Beide Beide Beide'},
							    {'generated_text': ''},
							]
							self.assertEqual(snake_case__      ,snake_case__ )

							SCREAMING_SNAKE_CASE_   : List[str]					  =      generator('This is a test'      ,do_sample=snake_case__      ,num_return_sequences=2      ,return_tensors=snake_case__ )
							self.assertEqual(
							    snake_case__      ,[
							        {'generated_token_ids': ANY(torch.Tensor )},
							        {'generated_token_ids': ANY(torch.Tensor )},
							    ]      ,)
							SCREAMING_SNAKE_CASE_   : Any					  =      generator.model.config.eos_token_id
							SCREAMING_SNAKE_CASE_   : str					  =      '<pad>'
							SCREAMING_SNAKE_CASE_   : str					  =      generator(
							    ['This is a test', 'This is a second test']      ,do_sample=snake_case__      ,num_return_sequences=2      ,batch_size=2      ,return_tensors=snake_case__      ,)
							self.assertEqual(
							    snake_case__      ,[
							        [
							            {'generated_token_ids': ANY(torch.Tensor )},
							            {'generated_token_ids': ANY(torch.Tensor )},
							        ],
							        [
							            {'generated_token_ids': ANY(torch.Tensor )},
							            {'generated_token_ids': ANY(torch.Tensor )},
							        ],
							    ]      ,)






				@require_tf
				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Any					  =      pipeline('text2text-generation'      ,model='patrickvonplaten/t5-tiny-random'      ,framework='tf' )
							# do_sample=False necessary for reproducibility
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      generator('Something there'      ,do_sample=snake_case__ )
							self.assertEqual(snake_case__      ,[{'generated_text': ''}] )









import os

import pytest

from datasets import (
    get_dataset_config_info,
    get_dataset_config_names,
    get_dataset_infos,
    get_dataset_split_names,
    inspect_dataset,
    inspect_metric,
)


UpperCamelCase__ :   List[Any]						=							pytest.mark.integration





@pytest.mark.parametrize('path'  ,							['paws', 'csv']  )
def        __UpperCAmelCase						(							lowerCamelCase_ :     Any  ,							lowerCamelCase_ :     int  )       ->  Any:







			"""simple docstring"""





			inspect_dataset(lowerCamelCase_  ,							lowerCamelCase_  )
			SCREAMING_SNAKE_CASE_   : List[str]					  =      path + '.py'
			assert script_name in os.listdir(lowerCamelCase_  )
			assert "__pycache__" not in os.listdir(lowerCamelCase_  )





@pytest.mark.filterwarnings('ignore:inspect_metric is deprecated:FutureWarning'  )
@pytest.mark.filterwarnings('ignore:metric_module_factory is deprecated:FutureWarning'  )
@pytest.mark.parametrize('path'  ,							['accuracy']  )
def        __UpperCAmelCase						(							lowerCamelCase_ :     Optional[int]  ,							lowerCamelCase_ :     Dict  )       ->  Optional[Any]:







			"""simple docstring"""





			inspect_metric(lowerCamelCase_  ,							lowerCamelCase_  )
			SCREAMING_SNAKE_CASE_   : Tuple					  =      path + '.py'
			assert script_name in os.listdir(lowerCamelCase_  )
			assert "__pycache__" not in os.listdir(lowerCamelCase_  )





@pytest.mark.parametrize(
    'path, config_name, expected_splits'  ,							[
        ('squad', 'plain_text', ['train', 'validation']),
        ('dalle-mini/wit', 'dalle-mini--wit', ['train']),
        ('paws', 'labeled_final', ['train', 'test', 'validation']),
    ]  ,							)
def        __UpperCAmelCase						(							lowerCamelCase_ :     List[str]  ,							lowerCamelCase_ :     Dict  ,							lowerCamelCase_ :     Optional[Any]  )       ->  Optional[int]:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : int					  =      get_dataset_config_info(lowerCamelCase_  ,							config_name=lowerCamelCase_  )
			assert info.config_name == config_name
			assert list(info.splits.keys()  ) == expected_splits





@pytest.mark.parametrize(
    'path, config_name, expected_exception'  ,							[
        ('paws', None, ValueError),
    ]  ,							)
def        __UpperCAmelCase						(							lowerCamelCase_ :     Union[str, Any]  ,							lowerCamelCase_ :     Optional[int]  ,							lowerCamelCase_ :     int  )       ->  List[Any]:







			"""simple docstring"""





			with pytest.raises(lowerCamelCase_  ):
						get_dataset_config_info(lowerCamelCase_  ,							config_name=lowerCamelCase_  )





@pytest.mark.parametrize(
    'path, expected'  ,							[
        ('squad', 'plain_text'),
        ('acronym_identification', 'default'),
        ('lhoestq/squad', 'plain_text'),
        ('lhoestq/test', 'default'),
        ('lhoestq/demo1', 'lhoestq--demo1'),
        ('dalle-mini/wit', 'dalle-mini--wit'),
    ]  ,							)
def        __UpperCAmelCase						(							lowerCamelCase_ :     Tuple  ,							lowerCamelCase_ :     List[Any]  )       ->  Dict:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : str					  =      get_dataset_config_names(lowerCamelCase_  )
			assert expected in config_names





@pytest.mark.parametrize(
    'path, expected_configs, expected_splits_in_first_config'  ,							[
        ('squad', ['plain_text'], ['train', 'validation']),
        ('dalle-mini/wit', ['dalle-mini--wit'], ['train']),
        ('paws', ['labeled_final', 'labeled_swap', 'unlabeled_final'], ['train', 'test', 'validation']),
    ]  ,							)
def        __UpperCAmelCase						(							lowerCamelCase_ :     List[Any]  ,							lowerCamelCase_ :     int  ,							lowerCamelCase_ :     Union[str, Any]  )       ->  Optional[int]:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : str					  =      get_dataset_infos(lowerCamelCase_  )
			assert list(infos.keys()  ) == expected_configs
			SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      expected_configs[0]
			assert expected_config in infos
			SCREAMING_SNAKE_CASE_   : Any					  =      infos[expected_config]
			assert info.config_name == expected_config
			assert list(info.splits.keys()  ) == expected_splits_in_first_config





@pytest.mark.parametrize(
    'path, expected_config, expected_splits'  ,							[
        ('squad', 'plain_text', ['train', 'validation']),
        ('dalle-mini/wit', 'dalle-mini--wit', ['train']),
        ('paws', 'labeled_final', ['train', 'test', 'validation']),
    ]  ,							)
def        __UpperCAmelCase						(							lowerCamelCase_ :     Union[str, Any]  ,							lowerCamelCase_ :     List[str]  ,							lowerCamelCase_ :     str  )       ->  str:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      get_dataset_infos(lowerCamelCase_  )
			assert expected_config in infos
			SCREAMING_SNAKE_CASE_   : Tuple					  =      infos[expected_config]
			assert info.config_name == expected_config
			assert list(info.splits.keys()  ) == expected_splits





@pytest.mark.parametrize(
    'path, config_name, expected_exception'  ,							[
        ('paws', None, ValueError),
    ]  ,							)
def        __UpperCAmelCase						(							lowerCamelCase_ :     int  ,							lowerCamelCase_ :     int  ,							lowerCamelCase_ :     int  )       ->  int:







			"""simple docstring"""





			with pytest.raises(lowerCamelCase_  ):
						get_dataset_split_names(lowerCamelCase_  ,							config_name=lowerCamelCase_  )



