


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


__lowerCamelCase   	=  {
    '''auto_factory''': ['''get_values'''],
    '''configuration_auto''': ['''ALL_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''CONFIG_MAPPING''', '''MODEL_NAMES_MAPPING''', '''AutoConfig'''],
    '''feature_extraction_auto''': ['''FEATURE_EXTRACTOR_MAPPING''', '''AutoFeatureExtractor'''],
    '''image_processing_auto''': ['''IMAGE_PROCESSOR_MAPPING''', '''AutoImageProcessor'''],
    '''processing_auto''': ['''PROCESSOR_MAPPING''', '''AutoProcessor'''],
    '''tokenization_auto''': ['''TOKENIZER_MAPPING''', '''AutoTokenizer'''],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowerCamelCase   	=  [
           '''MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING''',
           '''MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING''',
           '''MODEL_FOR_AUDIO_XVECTOR_MAPPING''',
           '''MODEL_FOR_BACKBONE_MAPPING''',
           '''MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING''',
           '''MODEL_FOR_CAUSAL_LM_MAPPING''',
           '''MODEL_FOR_CTC_MAPPING''',
           '''MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING''',
           '''MODEL_FOR_DEPTH_ESTIMATION_MAPPING''',
           '''MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING''',
           '''MODEL_FOR_IMAGE_SEGMENTATION_MAPPING''',
           '''MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING''',
           '''MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING''',
           '''MODEL_FOR_MASKED_LM_MAPPING''',
           '''MODEL_FOR_MASK_GENERATION_MAPPING''',
           '''MODEL_FOR_MULTIPLE_CHOICE_MAPPING''',
           '''MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING''',
           '''MODEL_FOR_OBJECT_DETECTION_MAPPING''',
           '''MODEL_FOR_PRETRAINING_MAPPING''',
           '''MODEL_FOR_QUESTION_ANSWERING_MAPPING''',
           '''MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING''',
           '''MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING''',
           '''MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING''',
           '''MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING''',
           '''MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING''',
           '''MODEL_FOR_TEXT_ENCODING_MAPPING''',
           '''MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING''',
           '''MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING''',
           '''MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING''',
           '''MODEL_FOR_VISION_2_SEQ_MAPPING''',
           '''MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING''',
           '''MODEL_MAPPING''',
           '''MODEL_WITH_LM_HEAD_MAPPING''',
           '''MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING''',
           '''MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING''',
           '''AutoModel''',
           '''AutoBackbone''',
           '''AutoModelForAudioClassification''',
           '''AutoModelForAudioFrameClassification''',
           '''AutoModelForAudioXVector''',
           '''AutoModelForCausalLM''',
           '''AutoModelForCTC''',
           '''AutoModelForDepthEstimation''',
           '''AutoModelForImageClassification''',
           '''AutoModelForImageSegmentation''',
           '''AutoModelForInstanceSegmentation''',
           '''AutoModelForMaskGeneration''',
           '''AutoModelForTextEncoding''',
           '''AutoModelForMaskedImageModeling''',
           '''AutoModelForMaskedLM''',
           '''AutoModelForMultipleChoice''',
           '''AutoModelForNextSentencePrediction''',
           '''AutoModelForObjectDetection''',
           '''AutoModelForPreTraining''',
           '''AutoModelForQuestionAnswering''',
           '''AutoModelForSemanticSegmentation''',
           '''AutoModelForSeq2SeqLM''',
           '''AutoModelForSequenceClassification''',
           '''AutoModelForSpeechSeq2Seq''',
           '''AutoModelForTableQuestionAnswering''',
           '''AutoModelForTokenClassification''',
           '''AutoModelForUniversalSegmentation''',
           '''AutoModelForVideoClassification''',
           '''AutoModelForVision2Seq''',
           '''AutoModelForVisualQuestionAnswering''',
           '''AutoModelForDocumentQuestionAnswering''',
           '''AutoModelWithLMHead''',
           '''AutoModelForZeroShotImageClassification''',
           '''AutoModelForZeroShotObjectDetection''',
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowerCamelCase   	=  [
           '''TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING''',
           '''TF_MODEL_FOR_CAUSAL_LM_MAPPING''',
           '''TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING''',
           '''TF_MODEL_FOR_MASK_GENERATION_MAPPING''',
           '''TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING''',
           '''TF_MODEL_FOR_MASKED_LM_MAPPING''',
           '''TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING''',
           '''TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING''',
           '''TF_MODEL_FOR_PRETRAINING_MAPPING''',
           '''TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING''',
           '''TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING''',
           '''TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING''',
           '''TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING''',
           '''TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING''',
           '''TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING''',
           '''TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING''',
           '''TF_MODEL_FOR_TEXT_ENCODING_MAPPING''',
           '''TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING''',
           '''TF_MODEL_FOR_VISION_2_SEQ_MAPPING''',
           '''TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING''',
           '''TF_MODEL_MAPPING''',
           '''TF_MODEL_WITH_LM_HEAD_MAPPING''',
           '''TFAutoModel''',
           '''TFAutoModelForAudioClassification''',
           '''TFAutoModelForCausalLM''',
           '''TFAutoModelForImageClassification''',
           '''TFAutoModelForMaskedImageModeling''',
           '''TFAutoModelForMaskedLM''',
           '''TFAutoModelForMaskGeneration''',
           '''TFAutoModelForMultipleChoice''',
           '''TFAutoModelForNextSentencePrediction''',
           '''TFAutoModelForPreTraining''',
           '''TFAutoModelForDocumentQuestionAnswering''',
           '''TFAutoModelForQuestionAnswering''',
           '''TFAutoModelForSemanticSegmentation''',
           '''TFAutoModelForSeq2SeqLM''',
           '''TFAutoModelForSequenceClassification''',
           '''TFAutoModelForSpeechSeq2Seq''',
           '''TFAutoModelForTableQuestionAnswering''',
           '''TFAutoModelForTextEncoding''',
           '''TFAutoModelForTokenClassification''',
           '''TFAutoModelForVision2Seq''',
           '''TFAutoModelForZeroShotImageClassification''',
           '''TFAutoModelWithLMHead''',
       ]

try:
       if not is_flax_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowerCamelCase   	=  [
           '''FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING''',
           '''FLAX_MODEL_FOR_CAUSAL_LM_MAPPING''',
           '''FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING''',
           '''FLAX_MODEL_FOR_MASKED_LM_MAPPING''',
           '''FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING''',
           '''FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING''',
           '''FLAX_MODEL_FOR_PRETRAINING_MAPPING''',
           '''FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING''',
           '''FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING''',
           '''FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING''',
           '''FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING''',
           '''FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING''',
           '''FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING''',
           '''FLAX_MODEL_MAPPING''',
           '''FlaxAutoModel''',
           '''FlaxAutoModelForCausalLM''',
           '''FlaxAutoModelForImageClassification''',
           '''FlaxAutoModelForMaskedLM''',
           '''FlaxAutoModelForMultipleChoice''',
           '''FlaxAutoModelForNextSentencePrediction''',
           '''FlaxAutoModelForPreTraining''',
           '''FlaxAutoModelForQuestionAnswering''',
           '''FlaxAutoModelForSeq2SeqLM''',
           '''FlaxAutoModelForSequenceClassification''',
           '''FlaxAutoModelForSpeechSeq2Seq''',
           '''FlaxAutoModelForTokenClassification''',
           '''FlaxAutoModelForVision2Seq''',
       ]


if TYPE_CHECKING:
       from .auto_factory import get_values
       from .configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP, CONFIG_MAPPING, MODEL_NAMES_MAPPING, AutoConfig
       from .feature_extraction_auto import FEATURE_EXTRACTOR_MAPPING, AutoFeatureExtractor
       from .image_processing_auto import IMAGE_PROCESSOR_MAPPING, AutoImageProcessor
       from .processing_auto import PROCESSOR_MAPPING, AutoProcessor
       from .tokenization_auto import TOKENIZER_MAPPING, AutoTokenizer

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_auto import (
                  MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
                  MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING,
                  MODEL_FOR_AUDIO_XVECTOR_MAPPING,
                  MODEL_FOR_BACKBONE_MAPPING,
                  MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
                  MODEL_FOR_CAUSAL_LM_MAPPING,
                  MODEL_FOR_CTC_MAPPING,
                  MODEL_FOR_DEPTH_ESTIMATION_MAPPING,
                  MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
                  MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
                  MODEL_FOR_IMAGE_SEGMENTATION_MAPPING,
                  MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING,
                  MODEL_FOR_MASK_GENERATION_MAPPING,
                  MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
                  MODEL_FOR_MASKED_LM_MAPPING,
                  MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
                  MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
                  MODEL_FOR_OBJECT_DETECTION_MAPPING,
                  MODEL_FOR_PRETRAINING_MAPPING,
                  MODEL_FOR_QUESTION_ANSWERING_MAPPING,
                  MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
                  MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
                  MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
                  MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
                  MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
                  MODEL_FOR_TEXT_ENCODING_MAPPING,
                  MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
                  MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING,
                  MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
                  MODEL_FOR_VISION_2_SEQ_MAPPING,
                  MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING,
                  MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
                  MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING,
                  MODEL_MAPPING,
                  MODEL_WITH_LM_HEAD_MAPPING,
                  AutoBackbone,
                  AutoModel,
                  AutoModelForAudioClassification,
                  AutoModelForAudioFrameClassification,
                  AutoModelForAudioXVector,
                  AutoModelForCausalLM,
                  AutoModelForCTC,
                  AutoModelForDepthEstimation,
                  AutoModelForDocumentQuestionAnswering,
                  AutoModelForImageClassification,
                  AutoModelForImageSegmentation,
                  AutoModelForInstanceSegmentation,
                  AutoModelForMaskedImageModeling,
                  AutoModelForMaskedLM,
                  AutoModelForMaskGeneration,
                  AutoModelForMultipleChoice,
                  AutoModelForNextSentencePrediction,
                  AutoModelForObjectDetection,
                  AutoModelForPreTraining,
                  AutoModelForQuestionAnswering,
                  AutoModelForSemanticSegmentation,
                  AutoModelForSeqaSeqLM,
                  AutoModelForSequenceClassification,
                  AutoModelForSpeechSeqaSeq,
                  AutoModelForTableQuestionAnswering,
                  AutoModelForTextEncoding,
                  AutoModelForTokenClassification,
                  AutoModelForUniversalSegmentation,
                  AutoModelForVideoClassification,
                  AutoModelForVisionaSeq,
                  AutoModelForVisualQuestionAnswering,
                  AutoModelForZeroShotImageClassification,
                  AutoModelForZeroShotObjectDetection,
                  AutoModelWithLMHead,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_auto import (
                  TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
                  TF_MODEL_FOR_CAUSAL_LM_MAPPING,
                  TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
                  TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
                  TF_MODEL_FOR_MASK_GENERATION_MAPPING,
                  TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
                  TF_MODEL_FOR_MASKED_LM_MAPPING,
                  TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
                  TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
                  TF_MODEL_FOR_PRETRAINING_MAPPING,
                  TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
                  TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
                  TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
                  TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
                  TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
                  TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
                  TF_MODEL_FOR_TEXT_ENCODING_MAPPING,
                  TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
                  TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
                  TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
                  TF_MODEL_MAPPING,
                  TF_MODEL_WITH_LM_HEAD_MAPPING,
                  TFAutoModel,
                  TFAutoModelForAudioClassification,
                  TFAutoModelForCausalLM,
                  TFAutoModelForDocumentQuestionAnswering,
                  TFAutoModelForImageClassification,
                  TFAutoModelForMaskedImageModeling,
                  TFAutoModelForMaskedLM,
                  TFAutoModelForMaskGeneration,
                  TFAutoModelForMultipleChoice,
                  TFAutoModelForNextSentencePrediction,
                  TFAutoModelForPreTraining,
                  TFAutoModelForQuestionAnswering,
                  TFAutoModelForSemanticSegmentation,
                  TFAutoModelForSeqaSeqLM,
                  TFAutoModelForSequenceClassification,
                  TFAutoModelForSpeechSeqaSeq,
                  TFAutoModelForTableQuestionAnswering,
                  TFAutoModelForTextEncoding,
                  TFAutoModelForTokenClassification,
                  TFAutoModelForVisionaSeq,
                  TFAutoModelForZeroShotImageClassification,
                  TFAutoModelWithLMHead,
              )

       try:
              if not is_flax_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_flax_auto import (
                  FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
                  FLAX_MODEL_FOR_CAUSAL_LM_MAPPING,
                  FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
                  FLAX_MODEL_FOR_MASKED_LM_MAPPING,
                  FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
                  FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
                  FLAX_MODEL_FOR_PRETRAINING_MAPPING,
                  FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
                  FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
                  FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
                  FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
                  FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
                  FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING,
                  FLAX_MODEL_MAPPING,
                  FlaxAutoModel,
                  FlaxAutoModelForCausalLM,
                  FlaxAutoModelForImageClassification,
                  FlaxAutoModelForMaskedLM,
                  FlaxAutoModelForMultipleChoice,
                  FlaxAutoModelForNextSentencePrediction,
                  FlaxAutoModelForPreTraining,
                  FlaxAutoModelForQuestionAnswering,
                  FlaxAutoModelForSeqaSeqLM,
                  FlaxAutoModelForSequenceClassification,
                  FlaxAutoModelForSpeechSeqaSeq,
                  FlaxAutoModelForTokenClassification,
                  FlaxAutoModelForVisionaSeq,
              )

else:
       import sys

       __lowerCamelCase   	=  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






"""simple docstring"""



import csv
import os

import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.csv import CsvDatasetReader, CsvDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases





def 			_snake_case  (     UpperCAmelCase_	:       Any       , UpperCAmelCase_	:       Any      ):
     assert isinstance(UpperCAmelCase_       , UpperCAmelCase_      )
     assert dataset.num_rows == 4
     assert dataset.num_columns == 3
     assert dataset.column_names == ["col_1", "col_2", "col_3"]
     for feature, expected_dtype in expected_features.items():
          assert dataset.features[feature].dtype == expected_dtype





@pytest.mark.parametrize("""keep_in_memory"""       , [False, True]      )
def 			_snake_case  (     UpperCAmelCase_	:       Tuple       , UpperCAmelCase_	:       Tuple       , UpperCAmelCase_	:       Optional[Any]      ):
     A__				      =	tmp_path / """cache"""
     A__				      =	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
     with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
          A__				      =	CsvDatasetReader(UpperCAmelCase_       , cache_dir=UpperCAmelCase_       , keep_in_memory=UpperCAmelCase_      ).read()
     _check_csv_dataset(UpperCAmelCase_       , UpperCAmelCase_      )





@pytest.mark.parametrize(
    """features"""       , [
        None,
        {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""},
        {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""},
        {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""},
        {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""},
    ]       , )
def 			_snake_case  (     UpperCAmelCase_	:       int       , UpperCAmelCase_	:       List[str]       , UpperCAmelCase_	:       Dict      ):
     A__				      =	tmp_path / """cache"""
     # CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
     A__				      =	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
     A__				      =	features.copy() if features else default_expected_features
     A__				      =	(
         Features({feature: Value(UpperCAmelCase_      ) for feature, dtype in features.items()}      ) if features is not None else None
     )
     A__				      =	CsvDatasetReader(UpperCAmelCase_       , features=UpperCAmelCase_       , cache_dir=UpperCAmelCase_      ).read()
     _check_csv_dataset(UpperCAmelCase_       , UpperCAmelCase_      )





@pytest.mark.parametrize("""split"""       , [None, NamedSplit("""train"""      ), """train""", """test"""]      )
def 			_snake_case  (     UpperCAmelCase_	:       Optional[int]       , UpperCAmelCase_	:       Optional[int]       , UpperCAmelCase_	:       int      ):
     A__				      =	tmp_path / """cache"""
     A__				      =	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
     A__				      =	CsvDatasetReader(UpperCAmelCase_       , cache_dir=UpperCAmelCase_       , split=UpperCAmelCase_      ).read()
     _check_csv_dataset(UpperCAmelCase_       , UpperCAmelCase_      )
     assert dataset.split == split if split else "train"





@pytest.mark.parametrize("""path_type"""       , [str, list]      )
def 			_snake_case  (     UpperCAmelCase_	:       Tuple       , UpperCAmelCase_	:       Tuple       , UpperCAmelCase_	:       Dict      ):
     if issubclass(UpperCAmelCase_       , UpperCAmelCase_      ):
          A__				      =	csv_path
     elif issubclass(UpperCAmelCase_       , UpperCAmelCase_      ):
          A__				      =	[csv_path]
     A__				      =	tmp_path / """cache"""
     A__				      =	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
     A__				      =	CsvDatasetReader(UpperCAmelCase_       , cache_dir=UpperCAmelCase_      ).read()
     _check_csv_dataset(UpperCAmelCase_       , UpperCAmelCase_      )





def 			_snake_case  (     UpperCAmelCase_	:       Optional[Any]       , UpperCAmelCase_	:       Dict       , UpperCAmelCase_	:       int=("train",)      ):
     assert isinstance(UpperCAmelCase_       , UpperCAmelCase_      )
     for split in splits:
          A__				      =	dataset_dict[split]
          assert dataset.num_rows == 4
          assert dataset.num_columns == 3
          assert dataset.column_names == ["col_1", "col_2", "col_3"]
          for feature, expected_dtype in expected_features.items():
               assert dataset.features[feature].dtype == expected_dtype





@pytest.mark.parametrize("""keep_in_memory"""       , [False, True]      )
def 			_snake_case  (     UpperCAmelCase_	:       int       , UpperCAmelCase_	:       Tuple       , UpperCAmelCase_	:       List[str]      ):
     A__				      =	tmp_path / """cache"""
     A__				      =	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
     with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
          A__				      =	CsvDatasetReader({"""train""": csv_path}       , cache_dir=UpperCAmelCase_       , keep_in_memory=UpperCAmelCase_      ).read()
     _check_csv_datasetdict(UpperCAmelCase_       , UpperCAmelCase_      )





@pytest.mark.parametrize(
    """features"""       , [
        None,
        {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""},
        {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""},
        {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""},
        {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""},
    ]       , )
def 			_snake_case  (     UpperCAmelCase_	:       Dict       , UpperCAmelCase_	:       Any       , UpperCAmelCase_	:       Optional[Any]      ):
     A__				      =	tmp_path / """cache"""
     # CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
     A__				      =	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
     A__				      =	features.copy() if features else default_expected_features
     A__				      =	(
         Features({feature: Value(UpperCAmelCase_      ) for feature, dtype in features.items()}      ) if features is not None else None
     )
     A__				      =	CsvDatasetReader({"""train""": csv_path}       , features=UpperCAmelCase_       , cache_dir=UpperCAmelCase_      ).read()
     _check_csv_datasetdict(UpperCAmelCase_       , UpperCAmelCase_      )





@pytest.mark.parametrize("""split"""       , [None, NamedSplit("""train"""      ), """train""", """test"""]      )
def 			_snake_case  (     UpperCAmelCase_	:       Any       , UpperCAmelCase_	:       List[str]       , UpperCAmelCase_	:       Optional[int]      ):
     if split:
          A__				      =	{split: csv_path}
     else:
          A__				      =	{"""train""": csv_path, """test""": csv_path}
     A__				      =	tmp_path / """cache"""
     A__				      =	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
     A__				      =	CsvDatasetReader(UpperCAmelCase_       , cache_dir=UpperCAmelCase_      ).read()
     _check_csv_datasetdict(UpperCAmelCase_       , UpperCAmelCase_       , splits=list(path.keys()      )      )
     assert all(dataset[split].split == split for split in path.keys()      )





def 			_snake_case  (     UpperCAmelCase_	:       Optional[Any]      ):
     with open(UpperCAmelCase_       , encoding="""utf-8"""      ) as csvfile:
          yield from csv.reader(UpperCAmelCase_      )





def 			_snake_case  (     UpperCAmelCase_	:       str       , UpperCAmelCase_	:       int      ):
     A__				      =	tmp_path / """cache"""
     A__				      =	os.path.join(UpperCAmelCase_       , """tmp.csv"""      )
     A__				      =	CsvDatasetReader({"""train""": csv_path}       , cache_dir=UpperCAmelCase_      ).read()
     CsvDatasetWriter(dataset["""train"""]       , UpperCAmelCase_       , num_proc=1      ).write()

     A__				      =	iter_csv_file(UpperCAmelCase_      )
     A__				      =	iter_csv_file(UpperCAmelCase_      )

     for rowa, rowa in zip(UpperCAmelCase_       , UpperCAmelCase_      ):
          assert rowa == rowa





def 			_snake_case  (     UpperCAmelCase_	:       Any       , UpperCAmelCase_	:       List[Any]      ):
     A__				      =	tmp_path / """cache"""
     A__				      =	os.path.join(UpperCAmelCase_       , """tmp.csv"""      )
     A__				      =	CsvDatasetReader({"""train""": csv_path}       , cache_dir=UpperCAmelCase_      ).read()
     CsvDatasetWriter(dataset["""train"""]       , UpperCAmelCase_       , num_proc=2      ).write()

     A__				      =	iter_csv_file(UpperCAmelCase_      )
     A__				      =	iter_csv_file(UpperCAmelCase_      )

     for rowa, rowa in zip(UpperCAmelCase_       , UpperCAmelCase_      ):
          assert rowa == rowa





def 			_snake_case  (     UpperCAmelCase_	:       Any       , UpperCAmelCase_	:       Any      ):
     A__				      =	tmp_path / """cache"""
     A__				      =	os.path.join(UpperCAmelCase_       , """tmp.csv"""      )
     A__				      =	CsvDatasetReader({"""train""": csv_path}       , cache_dir=UpperCAmelCase_      ).read()
     with pytest.raises(UpperCAmelCase_      ):
          CsvDatasetWriter(dataset["""train"""]       , UpperCAmelCase_       , num_proc=0      )






