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 					lowercase__						(   __lowerCamelCase):


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





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[Any]							=							pa.array(TypedSequence([1, 2, 3]						)						)
												self.assertEqual(arr.type    ,		pa.intaa()						)


						def        __A       (       self	:				Optional[int]						):





												'''simple docstring'''





												with self.assertRaises(UpperCamelCase__						):
																		SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							pa.array(TypedSequence([1, 2, 3]						)    ,		type=pa.intaa()						)


						def        __A       (       self	:				int						):





												'''simple docstring'''





												with self.assertRaises(UpperCamelCase__						):
																		SCREAMING_SNAKE_CASE							:    List[Any]							=							pa.array(TypedSequence([1, 2, 3]    ,		try_type=Value('''bool'''						)    ,		type=Value('''int64'''						)						)						)


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





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    int							=							pa.array(TypedSequence([1, 2, 3]    ,		type=Value('''int32'''						)						)						)
												self.assertEqual(arr.type    ,		pa.intaa()						)


						def        __A       (       self	:				Optional[Any]						):





												'''simple docstring'''





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


						def        __A       (       self	:				Dict						):





												'''simple docstring'''





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


						def        __A       (       self	:				Optional[Any]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Tuple							=							pa.array(TypedSequence(['''foo''', '''bar''']    ,		try_type=Value('''int64'''						)						)						)
												self.assertEqual(arr.type    ,		pa.string()						)


						def        __A       (       self	:				Dict						):





												'''simple docstring'''





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


						def        __A       (       self	:				Dict						):





												'''simple docstring'''





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


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





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[Any]							=							pa.array(TypedSequence([[[1, 2, 3]]]    ,		try_type=ArrayaD((1, 3)    ,		'''int64'''						)						)						)
												self.assertEqual(arr.type    ,		ArrayaDExtensionType((1, 3)    ,		'''int64'''						)						)


						def        __A       (       self	:				Optional[Any]						):





												'''simple docstring'''





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



						@require_pil
						def        __A       (       self	:				str						):





												'''simple docstring'''





												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=UpperCamelCase__						) as mock_cast_to_python_objects:
																		SCREAMING_SNAKE_CASE							:    List[Any]							=							pa.array(TypedSequence([{'''path''': None, '''bytes''': B'''image_bytes'''}, pil_image]    ,		type=Image()						)						)
																		SCREAMING_SNAKE_CASE							:    List[Any]							=							mock_cast_to_python_objects.call_args_list[-1]
																		self.assertIn('''optimize_list_casting'''    ,		UpperCamelCase__						)
																		self.assertFalse(kwargs['''optimize_list_casting''']						)






def       A	(    _lowercase		,  _lowercase						):
						SCREAMING_SNAKE_CASE							:    List[Any]							=							pa.BufferReader(SCREAMING_SNAKE_CASE__						) if isinstance(SCREAMING_SNAKE_CASE__		,  pa.Buffer						) else pa.memory_map(SCREAMING_SNAKE_CASE__						)
						SCREAMING_SNAKE_CASE							:    Tuple							=							pa.ipc.open_stream(SCREAMING_SNAKE_CASE__						)
						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       A	(    _lowercase		,  _lowercase						):
						SCREAMING_SNAKE_CASE							:    List[str]							=							pa.BufferOutputStream()
						SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							pa.schema(SCREAMING_SNAKE_CASE__						) if fields else None
						with ArrowWriter(stream=SCREAMING_SNAKE_CASE__		,  schema=SCREAMING_SNAKE_CASE__		,  writer_batch_size=SCREAMING_SNAKE_CASE__						) as writer:
												writer.write({'''col_1''': '''foo''', '''col_2''': 1}						)
												writer.write({'''col_1''': '''bar''', '''col_2''': 2}						)
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							writer.finalize()
						assert num_examples == 2
						assert num_bytes > 0
						if not fields:
												SCREAMING_SNAKE_CASE							:    Dict							=							{"""col_1""": pa.string(), """col_2""": pa.intaa()}
						assert writer._schema == pa.schema(SCREAMING_SNAKE_CASE__		,  metadata=writer._schema.metadata						)
						_check_output(output.getvalue()		,  expected_num_chunks=num_examples if writer_batch_size == 1 else 1						)
def       A	(    ):
						SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							pa.BufferOutputStream()
						SCREAMING_SNAKE_CASE							:    Tuple							=							Features({'''labels''': ClassLabel(names=['''neg''', '''pos''']						)}						)
						with ArrowWriter(stream=SCREAMING_SNAKE_CASE__		,  features=SCREAMING_SNAKE_CASE__						) as writer:
												writer.write({'''labels''': 0}						)
												writer.write({'''labels''': 1}						)
												SCREAMING_SNAKE_CASE							:    List[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							:    Optional[Any]							=							pa.BufferReader(output.getvalue()						)
						SCREAMING_SNAKE_CASE							:    Optional[int]							=							pa.ipc.open_stream(SCREAMING_SNAKE_CASE__						)
						SCREAMING_SNAKE_CASE							:    pa.Table							=							f.read_all()
						SCREAMING_SNAKE_CASE							:    Tuple							=							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(SCREAMING_SNAKE_CASE__						)
@pytest.mark.parametrize('''writer_batch_size'''		,  [None, 1, 10]						)
def       A	(    _lowercase						):
						SCREAMING_SNAKE_CASE							:    List[str]							=							pa.BufferOutputStream()
						with ArrowWriter(
						    stream=SCREAMING_SNAKE_CASE__		,  writer_batch_size=SCREAMING_SNAKE_CASE__		,  hash_salt='''split_name'''		,  check_duplicates=SCREAMING_SNAKE_CASE__		,  ) as writer:
												with pytest.raises(SCREAMING_SNAKE_CASE__						):
																		writer.write({'''col_1''': '''foo''', '''col_2''': 1}		,  key=[1, 2]						)
																		SCREAMING_SNAKE_CASE							:    List[str]							=							writer.finalize()
@pytest.mark.parametrize('''writer_batch_size'''		,  [None, 2, 10]						)
def       A	(    _lowercase						):
						SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							pa.BufferOutputStream()
						with ArrowWriter(
						    stream=SCREAMING_SNAKE_CASE__		,  writer_batch_size=SCREAMING_SNAKE_CASE__		,  hash_salt='''split_name'''		,  check_duplicates=SCREAMING_SNAKE_CASE__		,  ) as writer:
												with pytest.raises(SCREAMING_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							:    Tuple							=							writer.finalize()
@pytest.mark.parametrize('''writer_batch_size'''		,  [None, 2, 10]						)
def       A	(    _lowercase						):
						SCREAMING_SNAKE_CASE							:    str							=							pa.BufferOutputStream()
						with ArrowWriter(
						    stream=SCREAMING_SNAKE_CASE__		,  writer_batch_size=SCREAMING_SNAKE_CASE__		,  hash_salt='''split_name'''		,  check_duplicates=SCREAMING_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							:    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       A	(    _lowercase		,  _lowercase						):
						SCREAMING_SNAKE_CASE							:    Tuple							=							pa.BufferOutputStream()
						SCREAMING_SNAKE_CASE							:    List[str]							=							pa.schema(SCREAMING_SNAKE_CASE__						) if fields else None
						with ArrowWriter(stream=SCREAMING_SNAKE_CASE__		,  schema=SCREAMING_SNAKE_CASE__		,  writer_batch_size=SCREAMING_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							:    Optional[Any]							=							writer.finalize()
						assert num_examples == 2
						assert num_bytes > 0
						if not fields:
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							{"""col_1""": pa.string(), """col_2""": pa.intaa()}
						assert writer._schema == pa.schema(SCREAMING_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       A	(    _lowercase		,  _lowercase						):
						SCREAMING_SNAKE_CASE							:    Tuple							=							pa.BufferOutputStream()
						SCREAMING_SNAKE_CASE							:    Optional[int]							=							pa.schema(SCREAMING_SNAKE_CASE__						) if fields else None
						with ArrowWriter(stream=SCREAMING_SNAKE_CASE__		,  schema=SCREAMING_SNAKE_CASE__		,  writer_batch_size=SCREAMING_SNAKE_CASE__						) as writer:
												writer.write_table(pa.Table.from_pydict({'''col_1''': ['''foo''', '''bar'''], '''col_2''': [1, 2]}						)						)
												SCREAMING_SNAKE_CASE							:    str							=							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(SCREAMING_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       A	(    _lowercase		,  _lowercase						):
						SCREAMING_SNAKE_CASE							:    int							=							pa.BufferOutputStream()
						SCREAMING_SNAKE_CASE							:    Optional[int]							=							pa.schema(SCREAMING_SNAKE_CASE__						) if fields else None
						with ArrowWriter(stream=SCREAMING_SNAKE_CASE__		,  schema=SCREAMING_SNAKE_CASE__		,  writer_batch_size=SCREAMING_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							:    Union[str, Any]							=							writer.finalize()
						assert num_examples == 2
						assert num_bytes > 0
						if not fields:
												SCREAMING_SNAKE_CASE							:    Tuple							=							{"""col_1""": pa.string(), """col_2""": pa.intaa()}
						assert writer._schema == pa.schema(SCREAMING_SNAKE_CASE__		,  metadata=writer._schema.metadata						)
						_check_output(output.getvalue()		,  expected_num_chunks=num_examples if writer_batch_size == 1 else 1						)
def       A	(    ):
						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(SCREAMING_SNAKE_CASE__		,  '''test.arrow'''						)
												with ArrowWriter(path=SCREAMING_SNAKE_CASE__		,  schema=pa.schema(SCREAMING_SNAKE_CASE__						)						) as writer:
																		writer.write_batch({'''col_1''': ['''foo''', '''bar'''], '''col_2''': [1, 2]}						)
																		SCREAMING_SNAKE_CASE							:    Any							=							writer.finalize()
												assert num_examples == 2
												assert num_bytes > 0
												assert writer._schema == pa.schema(SCREAMING_SNAKE_CASE__		,  metadata=writer._schema.metadata						)
												_check_output(SCREAMING_SNAKE_CASE__		,  1						)
def       A	(    _lowercase						):
						if pa.types.is_list(SCREAMING_SNAKE_CASE__						):
												return get_base_dtype(arr_type.value_type						)
						else:
												return arr_type
def       A	(    _lowercase		,  _lowercase						):
						if isinstance(lst[0]		,  SCREAMING_SNAKE_CASE__						):
												change_first_primitive_element_in_list(lst[0]		,  SCREAMING_SNAKE_CASE__						)
						else:
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							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       A	(    _lowercase		,  _lowercase		,  _lowercase						):
						SCREAMING_SNAKE_CASE							:    str							=							pa.array(TypedSequence(SCREAMING_SNAKE_CASE__		,  optimized_int_type=SCREAMING_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       A	(    _lowercase		,  _lowercase		,  _lowercase						):
						# in range
						SCREAMING_SNAKE_CASE							:    Optional[int]							=							pa.array(OptimizedTypedSequence(SCREAMING_SNAKE_CASE__		,  col=SCREAMING_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							:    Optional[int]							=							copy.deepcopy(SCREAMING_SNAKE_CASE__						)
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							np.iinfo(expected_dtype.to_pandas_dtype()						).max + 1
												change_first_primitive_element_in_list(SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__						)
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							pa.array(OptimizedTypedSequence(SCREAMING_SNAKE_CASE__		,  col=SCREAMING_SNAKE_CASE__						)						)
												assert get_base_dtype(arr.type						) == pa.intaa()
@pytest.mark.parametrize('''raise_exception'''		,  [False, True]						)
def       A	(    _lowercase		,  _lowercase						):
						SCREAMING_SNAKE_CASE							:    int							=							str(tmp_path / '''dataset-train.arrow'''						)
						try:
												with ArrowWriter(path=SCREAMING_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       A	(    _lowercase						):
						SCREAMING_SNAKE_CASE							:    Any							=							"""mock://dataset-train.arrow"""
						with ArrowWriter(path=SCREAMING_SNAKE_CASE__		,  storage_options=mockfs.storage_options						) as writer:
												assert isinstance(writer._fs		,  type(SCREAMING_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							:    Dict							=							writer.finalize()
						assert num_examples == 2
						assert num_bytes > 0
						assert mockfs.exists(SCREAMING_SNAKE_CASE__						)
def       A	(    ):
						SCREAMING_SNAKE_CASE							:    List[str]							=							pa.BufferOutputStream()
						with ParquetWriter(stream=SCREAMING_SNAKE_CASE__						) as writer:
												writer.write({'''col_1''': '''foo''', '''col_2''': 1}						)
												writer.write({'''col_1''': '''bar''', '''col_2''': 2}						)
												SCREAMING_SNAKE_CASE							:    str							=							writer.finalize()
						assert num_examples == 2
						assert num_bytes > 0
						SCREAMING_SNAKE_CASE							:    List[Any]							=							pa.BufferReader(output.getvalue()						)
						SCREAMING_SNAKE_CASE							:    pa.Table							=							pq.read_table(SCREAMING_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       A	(    _lowercase		,  _lowercase						):
						import PIL.Image

						SCREAMING_SNAKE_CASE							:    Any							=							str(tmp_path / '''test_image_rgb.jpg'''						)
						PIL.Image.fromarray(np.zeros((5, 5)		,  dtype=np.uinta						)						).save(SCREAMING_SNAKE_CASE__		,  format='''png'''						)
						SCREAMING_SNAKE_CASE							:    List[str]							=							pa.BufferOutputStream()
						with ParquetWriter(
						    stream=SCREAMING_SNAKE_CASE__		,  features=Features({'''image''': Image()}						)		,  embed_local_files=SCREAMING_SNAKE_CASE__						) 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(SCREAMING_SNAKE_CASE__						)
						SCREAMING_SNAKE_CASE							:    Tuple							=							pa_table.to_pydict()
						if embed_local_files:
												assert isinstance(out['''image'''][0]['''path''']		,  SCREAMING_SNAKE_CASE__						)
												with open(SCREAMING_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       A	(    ):
						SCREAMING_SNAKE_CASE							:    Optional[int]							=							pa.schema([pa.field('''col_1'''		,  pa.string()		,  nullable=SCREAMING_SNAKE_CASE__						)]						)
						SCREAMING_SNAKE_CASE							:    Tuple							=							pa.BufferOutputStream()
						with ArrowWriter(stream=SCREAMING_SNAKE_CASE__						) as writer:
												writer._build_writer(inferred_schema=SCREAMING_SNAKE_CASE__						)
												assert writer._schema == pa.schema([pa.field('''col_1'''		,  pa.string()						)]						)












from . import __version__

# Backward compatibility imports, to make sure all those objects can be found in file_utils
from .utils import (
    CLOUDFRONT_DISTRIB_PREFIX,
    CONFIG_NAME,
    DISABLE_TELEMETRY,
    DUMMY_INPUTS,
    DUMMY_MASK,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    FEATURE_EXTRACTOR_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_PREFIX,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    MODEL_CARD_NAME,
    MULTIPLE_CHOICE_DUMMY_INPUTS,
    PYTORCH_PRETRAINED_BERT_CACHE,
    PYTORCH_TRANSFORMERS_CACHE,
    S3_BUCKET_PREFIX,
    SENTENCEPIECE_UNDERLINE,
    SPIECE_UNDERLINE,
    TF2_WEIGHTS_NAME,
    TF_WEIGHTS_NAME,
    TORCH_FX_REQUIRED_VERSION,
    TRANSFORMERS_CACHE,
    TRANSFORMERS_DYNAMIC_MODULE_NAME,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
    ContextManagers,
    DummyObject,
    EntryNotFoundError,
    ExplicitEnum,
    ModelOutput,
    PaddingStrategy,
    PushToHubMixin,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    TensorType,
    _LazyModule,
    add_code_sample_docstrings,
    add_end_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    cached_property,
    copy_func,
    default_cache_path,
    define_sagemaker_information,
    get_cached_models,
    get_file_from_repo,
    get_full_repo_name,
    get_torch_version,
    has_file,
    http_user_agent,
    is_apex_available,
    is_bsa_available,
    is_coloredlogs_available,
    is_datasets_available,
    is_detectrona_available,
    is_faiss_available,
    is_flax_available,
    is_ftfy_available,
    is_in_notebook,
    is_ipex_available,
    is_librosa_available,
    is_offline_mode,
    is_onnx_available,
    is_pandas_available,
    is_phonemizer_available,
    is_protobuf_available,
    is_psutil_available,
    is_pyanvml_available,
    is_pyctcdecode_available,
    is_pytesseract_available,
    is_pytorch_quantization_available,
    is_rjieba_available,
    is_sagemaker_dp_enabled,
    is_sagemaker_mp_enabled,
    is_scipy_available,
    is_sentencepiece_available,
    is_seqio_available,
    is_sklearn_available,
    is_soundfile_availble,
    is_spacy_available,
    is_speech_available,
    is_tensor,
    is_tensorflow_probability_available,
    is_tfaonnx_available,
    is_tf_available,
    is_timm_available,
    is_tokenizers_available,
    is_torch_available,
    is_torch_bfaa_available,
    is_torch_cuda_available,
    is_torch_fx_available,
    is_torch_fx_proxy,
    is_torch_mps_available,
    is_torch_tfaa_available,
    is_torch_tpu_available,
    is_torchaudio_available,
    is_training_run_on_sagemaker,
    is_vision_available,
    replace_return_docstrings,
    requires_backends,
    to_numpy,
    to_py_obj,
    torch_only_method,
)






