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 __snake_case    (						_UpperCAmelCase		):




       def      __a						(   self      :    Tuple				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				pa.array(TypedSequence([1, 2, 3]				)				)
         self.assertEqual(arr.type	,     pa.intaa()				)




       def      __a						(   self      :    Any				):



         """simple docstring"""






         with self.assertRaises(SCREAMING_SNAKE_CASE_				):
           SCREAMING_SNAKE_CASE__      							=				pa.array(TypedSequence([1, 2, 3]				)	,     type=pa.intaa()				)




       def      __a						(   self      :    int				):



         """simple docstring"""






         with self.assertRaises(SCREAMING_SNAKE_CASE_				):
           SCREAMING_SNAKE_CASE__      							=				pa.array(TypedSequence([1, 2, 3]	,     try_type=Value("""bool"""				)	,     type=Value("""int64"""				)				)				)




       def      __a						(   self      :    Optional[Any]				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				pa.array(TypedSequence([1, 2, 3]	,     type=Value("""int32"""				)				)				)
         self.assertEqual(arr.type	,     pa.intaa()				)




       def      __a						(   self      :    Dict				):



         """simple docstring"""






         with self.assertRaises((TypeError, pa.lib.ArrowInvalid)				):
           SCREAMING_SNAKE_CASE__      							=				pa.array(TypedSequence(["""foo""", """bar"""]	,     type=Value("""int64"""				)				)				)




       def      __a						(   self      :    str				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				pa.array(TypedSequence([1, 2, 3]	,     try_type=Value("""int32"""				)				)				)
         self.assertEqual(arr.type	,     pa.intaa()				)




       def      __a						(   self      :    List[Any]				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				pa.array(TypedSequence(["""foo""", """bar"""]	,     try_type=Value("""int64"""				)				)				)
         self.assertEqual(arr.type	,     pa.string()				)




       def      __a						(   self      :    Union[str, Any]				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				pa.array(TypedSequence([[[1, 2, 3]]]	,     type=ArrayaD((1, 3)	,     """int64"""				)				)				)
         self.assertEqual(arr.type	,     ArrayaDExtensionType((1, 3)	,     """int64"""				)				)




       def      __a						(   self      :    List[Any]				):



         """simple docstring"""






         with self.assertRaises((TypeError, pa.lib.ArrowInvalid)				):
           SCREAMING_SNAKE_CASE__      							=				pa.array(TypedSequence(["""foo""", """bar"""]	,     type=ArrayaD((1, 3)	,     """int64"""				)				)				)




       def      __a						(   self      :    List[Any]				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				pa.array(TypedSequence([[[1, 2, 3]]]	,     try_type=ArrayaD((1, 3)	,     """int64"""				)				)				)
         self.assertEqual(arr.type	,     ArrayaDExtensionType((1, 3)	,     """int64"""				)				)




       def      __a						(   self      :    int				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				pa.array(TypedSequence(["""foo""", """bar"""]	,     try_type=ArrayaD((1, 3)	,     """int64"""				)				)				)
         self.assertEqual(arr.type	,     pa.string()				)




       @require_pil
       def      __a						(   self      :    List[Any]				):



         """simple docstring"""






         import PIL.Image

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





def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Any			,					__UpperCamelCase   :	int     )							-> str:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				pa.BufferReader(snake_case_     ) if isinstance(snake_case_			,					pa.Buffer     ) else pa.memory_map(snake_case_     )
  SCREAMING_SNAKE_CASE__      							=				pa.ipc.open_stream(snake_case_     )
  SCREAMING_SNAKE_CASE__      							=				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      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	int			,					__UpperCamelCase   :	Any     )							-> int:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				pa.BufferOutputStream()
  SCREAMING_SNAKE_CASE__      							=				pa.schema(snake_case_     ) if fields else None
  with ArrowWriter(stream=snake_case_			,					schema=snake_case_			,					writer_batch_size=snake_case_     ) as writer:
    writer.write({"""col_1""": """foo""", """col_2""": 1}     )
    writer.write({"""col_1""": """bar""", """col_2""": 2}     )
    SCREAMING_SNAKE_CASE__      							=				writer.finalize()
  assert num_examples == 2
  assert num_bytes > 0
  if not fields:
    SCREAMING_SNAKE_CASE__      							=				{"""col_1""": pa.string(), """col_2""": pa.intaa()}
  assert writer._schema == pa.schema(snake_case_			,					metadata=writer._schema.metadata     )
  _check_output(output.getvalue()			,					expected_num_chunks=num_examples if writer_batch_size == 1 else 1     )



def      __SCREAMING_SNAKE_CASE  ( )							-> int:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				pa.BufferOutputStream()
  SCREAMING_SNAKE_CASE__      							=				Features({"""labels""": ClassLabel(names=["""neg""", """pos"""]     )}     )
  with ArrowWriter(stream=snake_case_			,					features=snake_case_     ) as writer:
    writer.write({"""labels""": 0}     )
    writer.write({"""labels""": 1}     )
    SCREAMING_SNAKE_CASE__      							=				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__      							=				pa.BufferReader(output.getvalue()     )
  SCREAMING_SNAKE_CASE__      							=				pa.ipc.open_stream(snake_case_     )
  SCREAMING_SNAKE_CASE__      							=				f.read_all()
  SCREAMING_SNAKE_CASE__      							=				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(snake_case_     )



@pytest.mark.parametrize("""writer_batch_size"""			,					[None, 1, 10]     )
def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Optional[int]     )							-> List[str]:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				pa.BufferOutputStream()
  with ArrowWriter(
      stream=snake_case_			,					writer_batch_size=snake_case_			,					hash_salt="""split_name"""			,					check_duplicates=snake_case_			,					) as writer:
    with pytest.raises(snake_case_     ):
      writer.write({"""col_1""": """foo""", """col_2""": 1}			,					key=[1, 2]     )
      SCREAMING_SNAKE_CASE__      							=				writer.finalize()



@pytest.mark.parametrize("""writer_batch_size"""			,					[None, 2, 10]     )
def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Optional[int]     )							-> Optional[Any]:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				pa.BufferOutputStream()
  with ArrowWriter(
      stream=snake_case_			,					writer_batch_size=snake_case_			,					hash_salt="""split_name"""			,					check_duplicates=snake_case_			,					) as writer:
    with pytest.raises(snake_case_     ):
      writer.write({"""col_1""": """foo""", """col_2""": 1}			,					key=10     )
      writer.write({"""col_1""": """bar""", """col_2""": 2}			,					key=10     )
      SCREAMING_SNAKE_CASE__      							=				writer.finalize()



@pytest.mark.parametrize("""writer_batch_size"""			,					[None, 2, 10]     )
def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Any     )							-> List[str]:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				pa.BufferOutputStream()
  with ArrowWriter(
      stream=snake_case_			,					writer_batch_size=snake_case_			,					hash_salt="""split_name"""			,					check_duplicates=snake_case_			,					) 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__      							=				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      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Optional[int]			,					__UpperCamelCase   :	int     )							-> List[Any]:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				pa.BufferOutputStream()
  SCREAMING_SNAKE_CASE__      							=				pa.schema(snake_case_     ) if fields else None
  with ArrowWriter(stream=snake_case_			,					schema=snake_case_			,					writer_batch_size=snake_case_     ) as writer:
    writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]}     )
    writer.write_batch({"""col_1""": [], """col_2""": []}     )
    SCREAMING_SNAKE_CASE__      							=				writer.finalize()
  assert num_examples == 2
  assert num_bytes > 0
  if not fields:
    SCREAMING_SNAKE_CASE__      							=				{"""col_1""": pa.string(), """col_2""": pa.intaa()}
  assert writer._schema == pa.schema(snake_case_			,					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      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Any			,					__UpperCamelCase   :	Optional[Any]     )							-> Dict:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				pa.BufferOutputStream()
  SCREAMING_SNAKE_CASE__      							=				pa.schema(snake_case_     ) if fields else None
  with ArrowWriter(stream=snake_case_			,					schema=snake_case_			,					writer_batch_size=snake_case_     ) as writer:
    writer.write_table(pa.Table.from_pydict({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]}     )     )
    SCREAMING_SNAKE_CASE__      							=				writer.finalize()
  assert num_examples == 2
  assert num_bytes > 0
  if not fields:
    SCREAMING_SNAKE_CASE__      							=				{"""col_1""": pa.string(), """col_2""": pa.intaa()}
  assert writer._schema == pa.schema(snake_case_			,					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      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Optional[Any]			,					__UpperCamelCase   :	Optional[Any]     )							-> str:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				pa.BufferOutputStream()
  SCREAMING_SNAKE_CASE__      							=				pa.schema(snake_case_     ) if fields else None
  with ArrowWriter(stream=snake_case_			,					schema=snake_case_			,					writer_batch_size=snake_case_     ) 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__      							=				writer.finalize()
  assert num_examples == 2
  assert num_bytes > 0
  if not fields:
    SCREAMING_SNAKE_CASE__      							=				{"""col_1""": pa.string(), """col_2""": pa.intaa()}
  assert writer._schema == pa.schema(snake_case_			,					metadata=writer._schema.metadata     )
  _check_output(output.getvalue()			,					expected_num_chunks=num_examples if writer_batch_size == 1 else 1     )



def      __SCREAMING_SNAKE_CASE  ( )							-> str:







  """simple docstring"""





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



def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Dict     )							-> Optional[Any]:







  """simple docstring"""





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



def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Optional[int]			,					__UpperCamelCase   :	Dict     )							-> Optional[Any]:







  """simple docstring"""





  if isinstance(lst[0]			,					snake_case_     ):
    change_first_primitive_element_in_list(lst[0]			,					snake_case_     )
  else:
    SCREAMING_SNAKE_CASE__      							=				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      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Tuple			,					__UpperCamelCase   :	List[Any]			,					__UpperCamelCase   :	Dict     )							-> Any:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				pa.array(TypedSequence(snake_case_			,					optimized_int_type=snake_case_     )     )
  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      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Union[str, Any]			,					__UpperCamelCase   :	Union[str, Any]			,					__UpperCamelCase   :	str     )							-> int:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				pa.array(OptimizedTypedSequence(snake_case_			,					col=snake_case_     )     )
  assert get_base_dtype(arr.type     ) == expected_dtype

  # not in range
  if col != "other":
    # avoids errors due to in-place modifications
    SCREAMING_SNAKE_CASE__      							=				copy.deepcopy(snake_case_     )
    SCREAMING_SNAKE_CASE__      							=				np.iinfo(expected_dtype.to_pandas_dtype()     ).max + 1
    change_first_primitive_element_in_list(snake_case_			,					snake_case_     )
    SCREAMING_SNAKE_CASE__      							=				pa.array(OptimizedTypedSequence(snake_case_			,					col=snake_case_     )     )
    assert get_base_dtype(arr.type     ) == pa.intaa()



@pytest.mark.parametrize("""raise_exception"""			,					[False, True]     )
def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	Dict			,					__UpperCamelCase   :	Tuple     )							-> Optional[Any]:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				str(tmp_path / """dataset-train.arrow"""     )
  try:
    with ArrowWriter(path=snake_case_     ) as writer:
      if raise_exception:
        raise pa.lib.ArrowInvalid()
      else:
        writer.stream.close()
  except pa.lib.ArrowInvalid:
    pass
  finally:
    assert writer.stream.closed



def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	List[str]     )							-> Dict:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				"""mock://dataset-train.arrow"""
  with ArrowWriter(path=snake_case_			,					storage_options=mockfs.storage_options     ) as writer:
    assert isinstance(writer._fs			,					type(snake_case_     )     )
    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__      							=				writer.finalize()
  assert num_examples == 2
  assert num_bytes > 0
  assert mockfs.exists(snake_case_     )



def      __SCREAMING_SNAKE_CASE  ( )							-> List[str]:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				pa.BufferOutputStream()
  with ParquetWriter(stream=snake_case_     ) as writer:
    writer.write({"""col_1""": """foo""", """col_2""": 1}     )
    writer.write({"""col_1""": """bar""", """col_2""": 2}     )
    SCREAMING_SNAKE_CASE__      							=				writer.finalize()
  assert num_examples == 2
  assert num_bytes > 0
  SCREAMING_SNAKE_CASE__      							=				pa.BufferReader(output.getvalue()     )
  SCREAMING_SNAKE_CASE__      							=				pq.read_table(snake_case_     )
  assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]}



@require_pil
@pytest.mark.parametrize("""embed_local_files"""			,					[False, True]     )
def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	str			,					__UpperCamelCase   :	List[Any]     )							-> Any:







  """simple docstring"""





  import PIL.Image

  SCREAMING_SNAKE_CASE__      							=				str(tmp_path / """test_image_rgb.jpg"""     )
  PIL.Image.fromarray(np.zeros((5, 5)			,					dtype=np.uinta     )     ).save(snake_case_			,					format="""png"""     )
  SCREAMING_SNAKE_CASE__      							=				pa.BufferOutputStream()
  with ParquetWriter(
      stream=snake_case_			,					features=Features({"""image""": Image()}     )			,					embed_local_files=snake_case_     ) as writer:
    writer.write({"""image""": image_path}     )
    writer.finalize()
  SCREAMING_SNAKE_CASE__      							=				pa.BufferReader(output.getvalue()     )
  SCREAMING_SNAKE_CASE__      							=				pq.read_table(snake_case_     )
  SCREAMING_SNAKE_CASE__      							=				pa_table.to_pydict()
  if embed_local_files:
    assert isinstance(out["""image"""][0]["""path"""]			,					snake_case_     )
    with open(snake_case_			,					"""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      __SCREAMING_SNAKE_CASE  ( )							-> Union[str, Any]:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				pa.schema([pa.field("""col_1"""			,					pa.string()			,					nullable=snake_case_     )]     )
  SCREAMING_SNAKE_CASE__      							=				pa.BufferOutputStream()
  with ArrowWriter(stream=snake_case_     ) as writer:
    writer._build_writer(inferred_schema=snake_case_     )
    assert writer._schema == pa.schema([pa.field("""col_1"""			,					pa.string()     )]     )

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


__lowerCamelCase      :			Tuple							       =		DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

__lowerCamelCase      :			Optional[Any]							       =		'''main'''
# Default branch name
__lowerCamelCase      :			Optional[int]							       =		'''f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'''
# One particular commit (not the top of `main`)
__lowerCamelCase      :			Any							       =		'''aaaaaaa'''
# This commit does not exist, so we should 404.

__lowerCamelCase      :			List[str]							       =		'''d9e9f15bc825e4b2c9249e9578f884bbcb5e3684'''
# Sha-1 of config.json on the top of `main`, for checking purposes
__lowerCamelCase      :			List[Any]							       =		'''4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'''



@contextlib.contextmanager
def      __SCREAMING_SNAKE_CASE  ( )							-> str:







  """simple docstring"""





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



@contextlib.contextmanager
def      __SCREAMING_SNAKE_CASE  ( )							-> Any:







  """simple docstring"""





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







class __snake_case    (						unittest.TestCase		):




   def      __a						(   self      :    List[Any]				):



     """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      __a						(   self      :    List[str]	,     _lowercase      :    str				):



     """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      __a						(   self      :    Optional[Any]	,     _lowercase      :    str				):



     """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      __a						(   self      :    Tuple	,     _lowercase      :    Dict				):



     """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      __a						(   self      :    Union[str, Any]				):



     """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      __a						(   self      :    Any				):



     """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      __a						(   self      :    Union[str, Any]				):



     """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				)	,     []				)
