
'''simple docstring'''

import os
from typing import Optional

import fsspec
from fsspec.archive import AbstractArchiveFileSystem
from fsspec.utils import DEFAULT_BLOCK_SIZE


class  _UpperCAmelCase ( __lowerCamelCase    ):

     """simple docstring"""

     a_    	=					""
     a_    	=					(
         None  # protocol passed in prefix to the url. ex: "gzip", for gzip://file.txt::http://foo.bar/file.txt.gz
     )
     a_    	=					None  # compression type in fsspec. ex: "gzip"
     a_    	=					None  # extension of the filename to strip. ex: "".gz" to get file.txt from file.txt.gz


     def __init__(      self							,		lowerCAmelCase_ = ""							,		lowerCAmelCase_ = None							,		lowerCAmelCase_ = None							,		**lowerCAmelCase_ ):

       '''simple docstring'''

       super().__init__(self							,		**UpperCAmelCase_ )
       # always open as "rb" since fsspec can then use the TextIOWrapper to make it work for "r" mode
       a_      :	int      =							fsspec.open(
           UpperCAmelCase_							,		mode="""rb"""							,		protocol=UpperCAmelCase_							,		compression=self.compression							,		client_kwargs={
               """requote_redirect_url""": False,  # see https://github.com/huggingface/datasets/pull/5459
               """trust_env""": True,  # Enable reading proxy env variables.
               **(target_options or {}).pop("""client_kwargs"""							,		{} ),  # To avoid issues if it was already passed.
           }							,		**(target_options or {})							,		)
       a_      :	Tuple      =							os.path.basename(self.file.path.split("""::""" )[0] )
       a_      :	Union[str, Any]      =							(
           self.compressed_name[: self.compressed_name.rindex(""".""" )]
           if '.' in self.compressed_name
           else self.compressed_name
       )
       a_      :	str      =							None


     @classmethod
     def 							_lowerCAmelCase  (      cls							,		lowerCAmelCase_ ):

       '''simple docstring'''

       return super()._strip_protocol(UpperCAmelCase_ ).lstrip("""/""" )


     def 							_lowerCAmelCase  (      self ):

       '''simple docstring'''

       if self.dir_cache is None:
         a_      :	Tuple      =							{**self.file.fs.info(self.file.path ), 'name': self.uncompressed_name}
         a_      :	Dict      =							{f['name']: f}


     def 							_lowerCAmelCase  (      self							,		lowerCAmelCase_ ):

       '''simple docstring'''

       return self.file.open().read()






     def 							_lowerCAmelCase  (      self							,		lowerCAmelCase_							,		lowerCAmelCase_ = "rb"							,		lowerCAmelCase_=None							,		lowerCAmelCase_=True							,		lowerCAmelCase_=None							,		**lowerCAmelCase_							,		):

       '''simple docstring'''

       a_      :	str      =							self._strip_protocol(UpperCAmelCase_ )
       if mode != "rb":
         raise ValueError(f'''Tried to read with mode {mode} on file {self.file.path} opened with mode \'rb\'''' )
       return self.file.open()







class  _UpperCAmelCase ( __lowerCamelCase    ):

     """simple docstring"""

     a_    	=					"bz2"
     a_    	=					"bz2"
     a_    	=					".bz2"







class  _UpperCAmelCase ( __lowerCamelCase    ):

     """simple docstring"""

     a_    	=					"gzip"
     a_    	=					"gzip"
     a_    	=					".gz"







class  _UpperCAmelCase ( __lowerCamelCase    ):

     """simple docstring"""

     a_    	=					"lz4"
     a_    	=					"lz4"
     a_    	=					".lz4"







class  _UpperCAmelCase ( __lowerCamelCase    ):

     """simple docstring"""

     a_    	=					"xz"
     a_    	=					"xz"
     a_    	=					".xz"







class  _UpperCAmelCase ( __lowerCamelCase    ):

     """simple docstring"""

     a_    	=					"zstd"
     a_    	=					"zstd"
     a_    	=					".zst"


     def __init__(      self							,		lowerCAmelCase_							,		lowerCAmelCase_ = "rb"							,		lowerCAmelCase_ = None							,		lowerCAmelCase_ = None							,		lowerCAmelCase_ = DEFAULT_BLOCK_SIZE							,		**lowerCAmelCase_							,		):

       '''simple docstring'''

       super().__init__(
           fo=UpperCAmelCase_							,		mode=UpperCAmelCase_							,		target_protocol=UpperCAmelCase_							,		target_options=UpperCAmelCase_							,		block_size=UpperCAmelCase_							,		**UpperCAmelCase_							,		)
       # We need to wrap the zstd decompressor to avoid this error in fsspec==2021.7.0 and zstandard==0.15.2:
       #
       # File "/Users/user/.virtualenvs/hf-datasets/lib/python3.7/site-packages/fsspec/core.py", line 145, in open
       #     out.close = close
       # AttributeError: 'zstd.ZstdDecompressionReader' object attribute 'close' is read-only
       #
       # see https://github.com/intake/filesystem_spec/issues/725
       a_      :	str      =							self.file.__enter__


       class  _UpperCAmelCase :

            """simple docstring"""

            def __init__(      self							,		lowerCAmelCase_ ):

              '''simple docstring'''

              a_      :	str      =							file_


            def __enter__(      self ):

              '''simple docstring'''

              self._file.__enter__()
              return self


            def __exit__(      self							,		*lowerCAmelCase_							,		**lowerCAmelCase_ ):

              '''simple docstring'''

              self._file.__exit__(*UpperCAmelCase_							,		**UpperCAmelCase_ )


            def __iter__(      self ):

              '''simple docstring'''

              return iter(self._file )


            def 							_lowerCAmelCase  (      self ):

              '''simple docstring'''

              return next(self._file )






            def __getattr__(      self							,		lowerCAmelCase_ ):

              '''simple docstring'''

              return getattr(self._file							,		UpperCAmelCase_ )

       def fixed_enter(*lowerCAmelCase_							,		**lowerCAmelCase_ ):
         return WrappedFile(_enter(*UpperCAmelCase_							,		**UpperCAmelCase_ ) )

       a_      :	str      =							fixed_enter




'''simple docstring'''

from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching






def 	_snake_case						(      ):
  """simple docstring"""







  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

  a_      :	List[str]      =							"""__test_patch_submodule_mock__"""
  with patch_submodule(_test_patching     ,		"""os.path.join"""     ,		A_   ):
    # 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 	_snake_case						(      ):
  """simple docstring"""







  assert _test_patching.open is open

  a_      :	Tuple      =							"""__test_patch_submodule_builtin_mock__"""
  # _test_patching has "open" in its globals
  assert _test_patching.open is open
  with patch_submodule(_test_patching     ,		"""open"""     ,		A_   ):
    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 	_snake_case						(      ):
  """simple docstring"""







  a_      :	Any      =							"""__test_patch_submodule_missing_mock__"""
  with patch_submodule(_test_patching     ,		"""pandas.read_csv"""     ,		A_   ):
    pass






def 	_snake_case						(      ):
  """simple docstring"""







  a_      :	int      =							"""__test_patch_submodule_missing_builtin_mock__"""
  # _test_patching doesn't have "len" in its globals
  assert getattr(_test_patching     ,		"""len"""     ,		A_   ) is None
  with patch_submodule(_test_patching     ,		"""len"""     ,		A_   ):
    assert _test_patching.len is mock
  assert _test_patching.len is len






def 	_snake_case						(      ):
  """simple docstring"""







  a_      :	List[str]      =							"""__test_patch_submodule_start_and_stop_mock__"""
  a_      :	int      =							patch_submodule(_test_patching     ,		"""open"""     ,		A_   )
  assert _test_patching.open is open
  patch.start()
  assert _test_patching.open is mock
  patch.stop()
  assert _test_patching.open is open






def 	_snake_case						(      ):
  """simple docstring"""







  from os import rename as original_rename
  from os.path import dirname as original_dirname
  from os.path import join as original_join

  a_      :	Any      =							"""__test_patch_submodule_successive_join__"""
  a_      :	Optional[Any]      =							"""__test_patch_submodule_successive_dirname__"""
  a_      :	Optional[int]      =							"""__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"""     ,		A_   ):
    with patch_submodule(_test_patching     ,		"""os.rename"""     ,		A_   ):
      with patch_submodule(_test_patching     ,		"""os.path.dirname"""     ,		A_   ):
        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"""     ,		A_   ):
    with patch_submodule(_test_patching     ,		"""os.path.join"""     ,		A_   ):
      with patch_submodule(_test_patching     ,		"""os.path.dirname"""     ,		A_   ):
        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 	_snake_case						(      ):
  """simple docstring"""







  a_      :	Optional[int]      =							"""__test_patch_submodule_doesnt_exist_mock__"""
  with patch_submodule(_test_patching     ,		"""__module_that_doesn_exist__.__attribute_that_doesn_exist__"""     ,		A_   ):
    pass
  with patch_submodule(_test_patching     ,		"""os.__attribute_that_doesn_exist__"""     ,		A_   ):
    pass


