

"""simple docstring"""






import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
	from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
	from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
	from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


snake_case_        =       DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

snake_case_        =       """main"""
# Default branch name
snake_case_        =       """f2c752cfc5c0ab6f4bdec59acea69eefbee381c2"""
# One particular commit (not the top of `main`)
snake_case_        =       """aaaaaaa"""
# This commit does not exist, so we should 404.

snake_case_        =       """d9e9f15bc825e4b2c9249e9578f884bbcb5e3684"""
# Sha-1 of config.json on the top of `main`, for checking purposes
snake_case_        =       """4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3"""



@contextlib.contextmanager
def   lowercase_	(    ):




					'''simple docstring'''






					print("Welcome!"	)
					yield
					print("Bye!"	)



@contextlib.contextmanager
def   lowercase_	(    ):




					'''simple docstring'''






					print("Bonjour!"	)
					yield
					print("Au revoir!"	)







class       snake_case__  ( unittest.TestCase     ):







			def 			__lowerCAmelCase				(			self			: Dict  ):





								'''simple docstring'''



								assert transformers.__spec__ is not None
								assert importlib.util.find_spec("transformers"  ) is not None







class       snake_case__  ( unittest.TestCase     ):







			@unittest.mock.patch("sys.stdout"			,  new_callable=io.StringIO  )
			def 			__lowerCAmelCase				(			self			: List[Any]			,  lowercase			: Tuple  ):





								'''simple docstring'''



								with ContextManagers([]  ):
													print("Transformers are awesome!"  )
								# The print statement adds a new line at the end of the output
								self.assertEqual(mock_stdout.getvalue()			,  "Transformers are awesome!\n"  )







			@unittest.mock.patch("sys.stdout"			,  new_callable=io.StringIO  )
			def 			__lowerCAmelCase				(			self			: List[Any]			,  lowercase			: Union[str, Any]  ):





								'''simple docstring'''



								with ContextManagers([context_en()]  ):
													print("Transformers are awesome!"  )
								# The output should be wrapped with an English welcome and goodbye
								self.assertEqual(mock_stdout.getvalue()			,  "Welcome!\nTransformers are awesome!\nBye!\n"  )







			@unittest.mock.patch("sys.stdout"			,  new_callable=io.StringIO  )
			def 			__lowerCAmelCase				(			self			: int			,  lowercase			: Optional[Any]  ):





								'''simple docstring'''



								with ContextManagers([context_fr(), context_en()]  ):
													print("Transformers are awesome!"  )
								# The output should be wrapped with an English and French welcome and goodbye
								self.assertEqual(mock_stdout.getvalue()			,  "Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n"  )







			@require_torch
			def 			__lowerCAmelCase				(			self			: str  ):





								'''simple docstring'''



								self.assertEqual(find_labels(lowercase  )			,  ["labels"]  )
								self.assertEqual(find_labels(lowercase  )			,  ["labels", "next_sentence_label"]  )
								self.assertEqual(find_labels(lowercase  )			,  ["start_positions", "end_positions"]  )







								class       snake_case__  ( lowerCAmelCase_     ):
											pass

								self.assertEqual(find_labels(lowercase  )			,  ["labels"]  )







			@require_tf
			def 			__lowerCAmelCase				(			self			: Tuple  ):





								'''simple docstring'''



								self.assertEqual(find_labels(lowercase  )			,  ["labels"]  )
								self.assertEqual(find_labels(lowercase  )			,  ["labels", "next_sentence_label"]  )
								self.assertEqual(find_labels(lowercase  )			,  ["start_positions", "end_positions"]  )







								class       snake_case__  ( lowerCAmelCase_     ):
											pass

								self.assertEqual(find_labels(lowercase  )			,  ["labels"]  )







			@require_flax
			def 			__lowerCAmelCase				(			self			: str  ):





								'''simple docstring'''



								self.assertEqual(find_labels(lowercase  )			,  []  )
								self.assertEqual(find_labels(lowercase  )			,  []  )
								self.assertEqual(find_labels(lowercase  )			,  []  )







								class       snake_case__  ( lowerCAmelCase_     ):
											pass

								self.assertEqual(find_labels(lowercase  )			,  []  )





"""simple docstring"""






import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.text import TextDatasetReader

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases



def   lowercase_	(    _lowercase       :		Optional[int]							,      _lowercase       :		int	):




					'''simple docstring'''






					assert isinstance(_lowercase							,      _lowercase	)
					assert dataset.num_rows == 4
					assert dataset.num_columns == 1
					assert dataset.column_names == ["text"]
					for feature, expected_dtype in expected_features.items():
										assert dataset.features[feature].dtype == expected_dtype



@pytest.mark.parametrize("keep_in_memory"							,      [False, True]	)
def   lowercase_	(    _lowercase       :		Union[str, Any]							,      _lowercase       :		Optional[int]							,      _lowercase       :		Dict	):




					'''simple docstring'''






					UpperCAmelCase			:   Dict      =				tmp_path / "cache"
					UpperCAmelCase			:   str      =				{"text": "string"}
					with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
										UpperCAmelCase			:   Tuple      =				TextDatasetReader(_lowercase							,      cache_dir=_lowercase							,      keep_in_memory=_lowercase	).read()
					_check_text_dataset(_lowercase							,      _lowercase	)



@pytest.mark.parametrize(
    "features"							,      [
        None,
        {"text": "string"},
        {"text": "int32"},
        {"text": "float32"},
    ]							,      )
def   lowercase_	(    _lowercase       :		Dict							,      _lowercase       :		Union[str, Any]							,      _lowercase       :		Optional[int]	):




					'''simple docstring'''






					UpperCAmelCase			:   int      =				tmp_path / "cache"
					UpperCAmelCase			:   Any      =				{"text": "string"}
					UpperCAmelCase			:   List[str]      =				features.copy() if features else default_expected_features
					UpperCAmelCase			:   Union[str, Any]      =				(
					    Features({feature: Value(_lowercase	) for feature, dtype in features.items()}	) if features is not None else None
					)
					UpperCAmelCase			:   str      =				TextDatasetReader(_lowercase							,      features=_lowercase							,      cache_dir=_lowercase	).read()
					_check_text_dataset(_lowercase							,      _lowercase	)



@pytest.mark.parametrize("split"							,      [None, NamedSplit("train"	), "train", "test"]	)
def   lowercase_	(    _lowercase       :		int							,      _lowercase       :		Tuple							,      _lowercase       :		List[str]	):




					'''simple docstring'''






					UpperCAmelCase			:   str      =				tmp_path / "cache"
					UpperCAmelCase			:   Any      =				{"text": "string"}
					UpperCAmelCase			:   List[Any]      =				TextDatasetReader(_lowercase							,      cache_dir=_lowercase							,      split=_lowercase	).read()
					_check_text_dataset(_lowercase							,      _lowercase	)
					assert dataset.split == split if split else "train"



@pytest.mark.parametrize("path_type"							,      [str, list]	)
def   lowercase_	(    _lowercase       :		Optional[int]							,      _lowercase       :		Any							,      _lowercase       :		Union[str, Any]	):




					'''simple docstring'''






					if issubclass(_lowercase							,      _lowercase	):
										UpperCAmelCase			:   List[str]      =				text_path
					elif issubclass(_lowercase							,      _lowercase	):
										UpperCAmelCase			:   List[Any]      =				[text_path]
					UpperCAmelCase			:   Union[str, Any]      =				tmp_path / "cache"
					UpperCAmelCase			:   List[Any]      =				{"text": "string"}
					UpperCAmelCase			:   Tuple      =				TextDatasetReader(_lowercase							,      cache_dir=_lowercase	).read()
					_check_text_dataset(_lowercase							,      _lowercase	)



def   lowercase_	(    _lowercase       :		Dict							,      _lowercase       :		int							,      _lowercase       :		Optional[Any]=("train",)	):




					'''simple docstring'''






					assert isinstance(_lowercase							,      _lowercase	)
					for split in splits:
										UpperCAmelCase			:   str      =				dataset_dict[split]
										assert dataset.num_rows == 4
										assert dataset.num_columns == 1
										assert dataset.column_names == ["text"]
										for feature, expected_dtype in expected_features.items():
															assert dataset.features[feature].dtype == expected_dtype



@pytest.mark.parametrize("keep_in_memory"							,      [False, True]	)
def   lowercase_	(    _lowercase       :		Dict							,      _lowercase       :		str							,      _lowercase       :		Dict	):




					'''simple docstring'''






					UpperCAmelCase			:   str      =				tmp_path / "cache"
					UpperCAmelCase			:   Union[str, Any]      =				{"text": "string"}
					with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
										UpperCAmelCase			:   Tuple      =				TextDatasetReader({"train": text_path}							,      cache_dir=_lowercase							,      keep_in_memory=_lowercase	).read()
					_check_text_datasetdict(_lowercase							,      _lowercase	)



@pytest.mark.parametrize(
    "features"							,      [
        None,
        {"text": "string"},
        {"text": "int32"},
        {"text": "float32"},
    ]							,      )
def   lowercase_	(    _lowercase       :		List[Any]							,      _lowercase       :		Union[str, Any]							,      _lowercase       :		int	):




					'''simple docstring'''






					UpperCAmelCase			:   int      =				tmp_path / "cache"
					# CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
					UpperCAmelCase			:   List[str]      =				{"text": "string"}
					UpperCAmelCase			:   str      =				features.copy() if features else default_expected_features
					UpperCAmelCase			:   Optional[int]      =				(
					    Features({feature: Value(_lowercase	) for feature, dtype in features.items()}	) if features is not None else None
					)
					UpperCAmelCase			:   Optional[int]      =				TextDatasetReader({"train": text_path}							,      features=_lowercase							,      cache_dir=_lowercase	).read()
					_check_text_datasetdict(_lowercase							,      _lowercase	)




@pytest.mark.parametrize("split"							,      [None, NamedSplit("train"	), "train", "test"]	)
def   lowercase_	(    _lowercase       :		int							,      _lowercase       :		Tuple							,      _lowercase       :		Optional[Any]	):




					'''simple docstring'''






					if split:
										UpperCAmelCase			:   Optional[Any]      =				{split: text_path}
					else:
										UpperCAmelCase			:   str      =				"train"
										UpperCAmelCase			:   Union[str, Any]      =				{"train": text_path, "test": text_path}
					UpperCAmelCase			:   Any      =				tmp_path / "cache"
					UpperCAmelCase			:   List[Any]      =				{"text": "string"}
					UpperCAmelCase			:   Any      =				TextDatasetReader(_lowercase							,      cache_dir=_lowercase	).read()
					_check_text_datasetdict(_lowercase							,      _lowercase							,      splits=list(path.keys()	)	)
					assert all(dataset[split].split == split for split in path.keys()	)


