



"""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


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

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

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

@contextlib.contextmanager
def  __SCREAMING_SNAKE_CASE		(			):
						"""simple docstring"""






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

@contextlib.contextmanager
def  __SCREAMING_SNAKE_CASE		(			):
						"""simple docstring"""






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

class       _a  ( unittest.TestCase):



			def 				__lowercase					(			self							:				Dict		)							->					Optional[int]:
									# If the spec is missing, importlib would not be able to import the module dynamically.
									assert transformers.__spec__ is not None
									assert importlib.util.find_spec("transformers"		) is not None



class       _a  ( unittest.TestCase):



			@unittest.mock.patch("sys.stdout"   ,	new_callable=io.StringIO		)
			def 				__lowercase					(			self							:				Union[str, Any]   ,	_lowercase							:				Optional[int]		)							->					Optional[Any]:
									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 				__lowercase					(			self							:				Any   ,	_lowercase							:				Any		)							->					Dict:
									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 				__lowercase					(			self							:				str   ,	_lowercase							:				List[Any]		)							->					Optional[int]:
									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 				__lowercase					(			self							:				Any		)							->					Union[str, Any]:
									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       _a  ( SCREAMING_SNAKE_CASE__):
												pass



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



			@require_tf
			def 				__lowercase					(			self							:				Optional[Any]		)							->					int:
									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       _a  ( SCREAMING_SNAKE_CASE__):
												pass



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



			@require_flax
			def 				__lowercase					(			self							:				Tuple		)							->					List[Any]:
									# Flax models don't have labels
									self.assertEqual(find_labels(_lowercase		)   ,	[]		)
									self.assertEqual(find_labels(_lowercase		)   ,	[]		)
									self.assertEqual(find_labels(_lowercase		)   ,	[]		)

									class       _a  ( SCREAMING_SNAKE_CASE__):
												pass



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








"""simple docstring"""







import os
import textwrap

import pyarrow as pa
import pytest

from datasets import ClassLabel, Features, Image
from datasets.packaged_modules.csv.csv import Csv

from ..utils import require_pil

@pytest.fixture
def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							Optional[Any] ):
						"""simple docstring"""






						snake_case   :			str						    = tmp_path / "file.csv"
						snake_case   :			Tuple						    = textwrap.dedent(
						    "\\n        header1,header2\n        1,2\n        10,20\n        " )
						with open(lowerCamelCase_     ,		"w" ) as f:
												f.write(lowerCamelCase_ )
						return str(lowerCamelCase_ )

@pytest.fixture
def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							List[str] ):
						"""simple docstring"""






						snake_case   :			List[Any]						    = tmp_path / "malformed_file.csv"
						snake_case   :			Union[str, Any]						    = textwrap.dedent(
						    "\\n        header1,header2\n        1,2\n        10,20,\n        " )
						with open(lowerCamelCase_     ,		"w" ) as f:
												f.write(lowerCamelCase_ )
						return str(lowerCamelCase_ )

@pytest.fixture
def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							int     ,		lowerCamelCase_:							Optional[Any] ):
						"""simple docstring"""






						snake_case   :			Dict						    = tmp_path / "csv_with_image.csv"
						snake_case   :			List[Any]						    = textwrap.dedent(
						    f'''\
        image
        {image_file}
        ''' )
						with open(lowerCamelCase_     ,		"w" ) as f:
												f.write(lowerCamelCase_ )
						return str(lowerCamelCase_ )

@pytest.fixture
def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							List[str] ):
						"""simple docstring"""






						snake_case   :			Optional[Any]						    = tmp_path / "csv_with_label.csv"
						snake_case   :			Tuple						    = textwrap.dedent(
						    "\\n        label\n        good\n        bad\n        good\n        " )
						with open(lowerCamelCase_     ,		"w" ) as f:
												f.write(lowerCamelCase_ )
						return str(lowerCamelCase_ )

@pytest.fixture
def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							List[Any] ):
						"""simple docstring"""






						snake_case   :			Union[str, Any]						    = tmp_path / "csv_with_int_list.csv"
						snake_case   :			Optional[int]						    = textwrap.dedent(
						    "\\n        int_list\n        1 2 3\n        4 5 6\n        7 8 9\n        " )
						with open(lowerCamelCase_     ,		"w" ) as f:
												f.write(lowerCamelCase_ )
						return str(lowerCamelCase_ )

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							List[str]     ,		lowerCamelCase_:							Any     ,		lowerCamelCase_:							List[str] ):
						"""simple docstring"""






						snake_case   :			Tuple						    = Csv()
						snake_case   :			str						    = csv._generate_tables([[csv_file, malformed_csv_file]] )
						with pytest.raises(lowerCamelCase_     ,		match="Error tokenizing data" ):
												for _ in generator:
																		pass
						assert any(
						    record.levelname == "ERROR"
						    and "Failed to read file" in record.message
						    and os.path.basename(lowerCamelCase_ ) in record.message
						    for record in caplog.records )

@require_pil
def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							str ):
						"""simple docstring"""






						with open(lowerCamelCase_     ,		encoding="utf-8" ) as f:
												snake_case   :			List[Any]						    = f.read().splitlines()[1]
						snake_case   :			List[str]						    = Csv(encoding="utf-8"     ,		features=Features({"image": Image()} ) )
						snake_case   :			Optional[int]						    = csv._generate_tables([[csv_file_with_image]] )
						snake_case   :			List[Any]						    = pa.concat_tables([table for _, table in generator] )
						assert pa_table.schema.field("image" ).type == Image()()
						snake_case   :			str						    = pa_table.to_pydict()["image"]
						assert generated_content == [{"path": image_file, "bytes": None}]

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							int ):
						"""simple docstring"""






						with open(lowerCamelCase_     ,		encoding="utf-8" ) as f:
												snake_case   :			Optional[Any]						    = f.read().splitlines()[1:]
						snake_case   :			List[str]						    = Csv(encoding="utf-8"     ,		features=Features({"label": ClassLabel(names=["good", "bad"] )} ) )
						snake_case   :			int						    = csv._generate_tables([[csv_file_with_label]] )
						snake_case   :			Dict						    = pa.concat_tables([table for _, table in generator] )
						assert pa_table.schema.field("label" ).type == ClassLabel(names=["good", "bad"] )()
						snake_case   :			Dict						    = pa_table.to_pydict()["label"]
						assert generated_content == [ClassLabel(names=["good", "bad"] ).straint(lowerCamelCase_ ) for label in labels]

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							Union[str, Any] ):
						"""simple docstring"""






						snake_case   :			List[Any]						    = Csv(encoding="utf-8"     ,		sep=","     ,		converters={"int_list": lambda lowerCamelCase_ : [int(lowerCamelCase_ ) for i in x.split()]} )
						snake_case   :			Tuple						    = csv._generate_tables([[csv_file_with_int_list]] )
						snake_case   :			str						    = pa.concat_tables([table for _, table in generator] )
						assert pa.types.is_list(pa_table.schema.field("int_list" ).type )
						snake_case   :			Any						    = pa_table.to_pydict()["int_list"]
						assert generated_content == [[1, 2, 3], [4, 5, 6], [7, 8, 9]]



