





import itertools
from dataclasses import dataclass
from typing import Optional

import pandas as pd
import pyarrow as pa

import datasets
from datasets.table import table_cast

@dataclass
class 		SCREAMING_SNAKE_CASE__				(       datasets.BuilderConfig  ):
      A_						:				Optional[datasets.Features]							=    None






class 		SCREAMING_SNAKE_CASE__				(       datasets.ArrowBasedBuilder  ):
      A_						:				Optional[int]							=    PandasConfig


      def    a (self       :      List[Any]      ):





         """simple docstring"""



         return datasets.DatasetInfo(features=self.config.features      )


      def    a (self       :      Optional[int]				,			a__       :      Union[str, Any]      ):





         """simple docstring"""



         if not self.config.data_files:
            raise ValueError(f"""At least one data file must be specified, but got data_files={self.config.data_files}"""      )
         __snake_case							       =   dl_manager.download_and_extract(self.config.data_files      )
         if isinstance(a__				,			(str, list, tuple)      ):
            __snake_case							       =   data_files
            if isinstance(a__				,			a__      ):
               __snake_case							       =   [files]
            # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
            __snake_case							       =   [dl_manager.iter_files(a__      ) for file in files]
            return [datasets.SplitGenerator(name=datasets.Split.TRAIN				,			gen_kwargs={'''files''': files}      )]
         __snake_case							       =   []
         for split_name, files in data_files.items():
            if isinstance(a__				,			a__      ):
               __snake_case							       =   [files]
            # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
            __snake_case							       =   [dl_manager.iter_files(a__      ) for file in files]
            splits.append(datasets.SplitGenerator(name=a__				,			gen_kwargs={'''files''': files}      )      )
         return splits


      def    a (self       :      Tuple				,			a__       :      pa.Table      ):





         """simple docstring"""



         if self.config.features is not None:
            # more expensive cast to support nested features with keys in a different order
            # allows str <-> int/float or str to Audio for example
            __snake_case							       =   table_cast(a__				,			self.config.features.arrow_schema      )
         return pa_table


      def    a (self       :      Union[str, Any]				,			a__       :      str      ):





         """simple docstring"""



         for i, file in enumerate(itertools.chain.from_iterable(a__      )      ):
            with open(a__				,			'''rb'''      ) as f:
               __snake_case							       =   pa.Table.from_pandas(pd.read_pickle(a__      )      )
               yield i, self._cast_table(a__      )








from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching






def lowerCamelCase__    (							)      ->				Any:
   import os as original_os
   from os import path as original_path
   from os import rename as original_rename
   from os.path import dirname as original_dirname
   from os.path import join as original_join

   assert _test_patching.os is original_os
   assert _test_patching.path is original_path
   assert _test_patching.join is original_join

   assert _test_patching.renamed_os is original_os
   assert _test_patching.renamed_path is original_path
   assert _test_patching.renamed_join is original_join

   __snake_case							       =   '''__test_patch_submodule_mock__'''
   with patch_submodule(_test_patching       ,      '''os.path.join'''       ,      snake_case_       ):
      # Every way to access os.path.join must be patched, and the rest must stay untouched

      # check os.path.join
      assert isinstance(_test_patching.os       ,      _PatchedModuleObj       )
      assert isinstance(_test_patching.os.path       ,      _PatchedModuleObj       )
      assert _test_patching.os.path.join is mock

      # check path.join
      assert isinstance(_test_patching.path       ,      _PatchedModuleObj       )
      assert _test_patching.path.join is mock

      # check join
      assert _test_patching.join is mock

      # check that the other attributes are untouched
      assert _test_patching.os.rename is original_rename
      assert _test_patching.path.dirname is original_dirname
      assert _test_patching.os.path.dirname is original_dirname

      # Even renamed modules or objects must be patched

      # check renamed_os.path.join
      assert isinstance(_test_patching.renamed_os       ,      _PatchedModuleObj       )
      assert isinstance(_test_patching.renamed_os.path       ,      _PatchedModuleObj       )
      assert _test_patching.renamed_os.path.join is mock

      # check renamed_path.join
      assert isinstance(_test_patching.renamed_path       ,      _PatchedModuleObj       )
      assert _test_patching.renamed_path.join is mock

      # check renamed_join
      assert _test_patching.renamed_join is mock

      # check that the other attributes are untouched
      assert _test_patching.renamed_os.rename is original_rename
      assert _test_patching.renamed_path.dirname is original_dirname
      assert _test_patching.renamed_os.path.dirname is original_dirname

   # check that everthing is back to normal when the patch is over

   assert _test_patching.os is original_os
   assert _test_patching.path is original_path
   assert _test_patching.join is original_join

   assert _test_patching.renamed_os is original_os
   assert _test_patching.renamed_path is original_path
   assert _test_patching.renamed_join is original_join






def lowerCamelCase__    (							)      ->				Any:
   assert _test_patching.open is open

   __snake_case							       =   '''__test_patch_submodule_builtin_mock__'''
   # _test_patching has "open" in its globals
   assert _test_patching.open is open
   with patch_submodule(_test_patching       ,      '''open'''       ,      snake_case_       ):
      assert _test_patching.open is mock

   # check that everthing is back to normal when the patch is over

   assert _test_patching.open is open






def lowerCamelCase__    (							)      ->				List[str]:
   # pandas.read_csv is not present in _test_patching
   __snake_case							       =   '''__test_patch_submodule_missing_mock__'''
   with patch_submodule(_test_patching       ,      '''pandas.read_csv'''       ,      snake_case_       ):
      pass






def lowerCamelCase__    (							)      ->				Union[str, Any]:
   # builtin should always be mocked even if they're not in the globals
   # in case they're loaded at one point
   __snake_case							       =   '''__test_patch_submodule_missing_builtin_mock__'''
   # _test_patching doesn't have "len" in its globals
   assert getattr(_test_patching       ,      '''len'''       ,      snake_case_       ) is None
   with patch_submodule(_test_patching       ,      '''len'''       ,      snake_case_       ):
      assert _test_patching.len is mock
   assert _test_patching.len is len






def lowerCamelCase__    (							)      ->				Union[str, Any]:
   __snake_case							       =   '''__test_patch_submodule_start_and_stop_mock__'''
   __snake_case							       =   patch_submodule(_test_patching       ,      '''open'''       ,      snake_case_       )
   assert _test_patching.open is open
   patch.start()
   assert _test_patching.open is mock
   patch.stop()
   assert _test_patching.open is open






def lowerCamelCase__    (							)      ->				Optional[int]:
   from os import rename as original_rename
   from os.path import dirname as original_dirname
   from os.path import join as original_join

   __snake_case							       =   '''__test_patch_submodule_successive_join__'''
   __snake_case							       =   '''__test_patch_submodule_successive_dirname__'''
   __snake_case							       =   '''__test_patch_submodule_successive_rename__'''
   assert _test_patching.os.path.join is original_join
   assert _test_patching.os.path.dirname is original_dirname
   assert _test_patching.os.rename is original_rename

   with patch_submodule(_test_patching       ,      '''os.path.join'''       ,      snake_case_       ):
      with patch_submodule(_test_patching       ,      '''os.rename'''       ,      snake_case_       ):
         with patch_submodule(_test_patching       ,      '''os.path.dirname'''       ,      snake_case_       ):
            assert _test_patching.os.path.join is mock_join
            assert _test_patching.os.path.dirname is mock_dirname
            assert _test_patching.os.rename is mock_rename

    # try another order
   with patch_submodule(_test_patching       ,      '''os.rename'''       ,      snake_case_       ):
      with patch_submodule(_test_patching       ,      '''os.path.join'''       ,      snake_case_       ):
         with patch_submodule(_test_patching       ,      '''os.path.dirname'''       ,      snake_case_       ):
            assert _test_patching.os.path.join is mock_join
            assert _test_patching.os.path.dirname is mock_dirname
            assert _test_patching.os.rename is mock_rename

   assert _test_patching.os.path.join is original_join
   assert _test_patching.os.path.dirname is original_dirname
   assert _test_patching.os.rename is original_rename







def lowerCamelCase__    (							)      ->				Tuple:
   __snake_case							       =   '''__test_patch_submodule_doesnt_exist_mock__'''
   with patch_submodule(_test_patching       ,      '''__module_that_doesn_exist__.__attribute_that_doesn_exist__'''       ,      snake_case_       ):
      pass
   with patch_submodule(_test_patching       ,      '''os.__attribute_that_doesn_exist__'''       ,      snake_case_       ):
      pass

